py-wlcli 0.8.0__py3-none-any.whl

wl_cli/commands/initenv/components/git/git_flow_manager.py

@@ -0,0 +1,159 @@
+"""Git Flow 分支管理器"""
+
+import os
+import time
+
+from wl_cli.utils.logging import log_info_pair
+
+from .branch_creator import BranchCreator
+from .git_flow_interface import GitFlowInterface
+
+# 导入新创建的模块
+from .git_utility import GitUtility
+
+
+class GitFlowManager(GitFlowInterface):
+    """Git Flow 分支管理器，实现 Git Flow 接口"""
+
+    def __init__(self, env: dict[str, str], skip_remote_ops: bool = False) -> None:
+        """
+        初始化 GitFlowManager 类
+
+        Args:
+            env: 执行 Git 命令时使用的环境变量
+            skip_remote_ops: 是否跳过远程操作
+        """
+        self.env = env
+        self.skip_remote_ops = skip_remote_ops
+        self.git_utility = GitUtility(env)
+        self.branch_creator = BranchCreator(self.git_utility)
+
+    def _cleanup_index_lock(self) -> None:
+        """
+        检查并清理可能存在的 index.lock 文件
+        在 Windows 上，Git 操作可能会留下未及时删除的 index.lock 文件
+        """
+        result = self.git_utility._run_git_command(
+            ["git", "rev-parse", "--git-dir"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode != 0:
+            return
+        git_dir = result.stdout.strip()
+        index_lock_path = os.path.join(git_dir, "index.lock")
+        if os.path.exists(index_lock_path):
+            if os.path.islink(index_lock_path):
+                log_info_pair(
+                    "Warning: index.lock is a symbolic link, skipping removal",
+                    "警告: index.lock 是符号链接，跳过删除",
+                )
+                return
+            if time.time() - os.path.getmtime(index_lock_path) < 5:
+                log_info_pair(
+                    "Warning: index.lock was recently modified, skipping removal",
+                    "警告: index.lock 最近被修改，跳过删除",
+                )
+                return
+            try:
+                os.remove(index_lock_path)
+                log_info_pair(
+                    "✓ Cleaned up existing index.lock file",
+                    "✓ 清理了存在的 index.lock 文件",
+                )
+            except OSError as e:
+                log_info_pair(
+                    f"Warning: Failed to remove index.lock file: {e}",
+                    f"警告: 无法删除 index.lock 文件: {e}",
+                )
+
+    def setup_git_flow_branches(self) -> None:
+        """
+        设置 Git Flow 分支结构
+
+        创建主开发分支 (main)、开发分支 (develop)、功能分支 (features)，
+        并确保所有分支都拉取最新代码。如果分支已存在，则直接切换到该分支。
+        """
+        if self.skip_remote_ops:
+            return
+
+        log_info_pair("Setting up Git Flow branches...", "设置 Git Flow 分支结构...")
+
+        try:
+            # 检查并清理可能存在的 index.lock 文件
+            self._cleanup_index_lock()
+
+            # Check if we're in a git repository
+            if not self.git_utility.is_git_repository():
+                log_info_pair(
+                    "Warning: Not inside a git repository", "警告: 不在 git 仓库内"
+                )
+                return
+
+            # 设置初始分支（main 和 develop）
+            self.branch_creator.setup_initial_branches()
+
+            # 检查并清理可能存在的 index.lock 文件
+            self._cleanup_index_lock()
+
+            # 检查并创建 features 分支（默认快速开发分支）
+            log_info_pair("Creating features branch...", "创建 features 分支...")
+
+            if not self.git_utility.branch_exists("features"):
+                # 直接创建 features 分支，不依赖 develop 分支的提交
+                self.git_utility.create_and_checkout_branch("features")
+                log_info_pair("✓ features branch created", "✓ features 分支创建成功")
+            else:
+                log_info_pair("features branch already exists", "features 分支已存在")
+                # 确保我们在 features 分支上
+                self.git_utility.checkout_branch("features")
+
+            log_info_pair("Git Flow branches setup completed", "Git Flow 分支设置完成")
+        except Exception as e:
+            log_info_pair(
+                f"Warning: Failed to set up Git Flow branches: {e}",
+                f"警告: 设置 Git Flow 分支失败: {e}",
+            )
+
+    def setup_git_flow_branches_by_work_type(self, work_type: str) -> None:
+        """
+        根据工作类型设置 Git Flow 分支
+
+        Args:
+            work_type: 工作类型 (feature, fix, hotfix, release)
+        """
+        # Define branch sources based on work type
+        branch_sources = {
+            "feature": "develop",
+            "features": "develop",
+            "fix": "develop",
+            "hotfix": "main",
+            "release": "develop",
+        }
+
+        # Validate work type
+        if work_type not in branch_sources:
+            from ...common.exceptions import GitInitError
+
+            raise GitInitError(
+                f"Invalid work type: {work_type}. Valid types are: {', '.join(branch_sources.keys())}"
+            )
+
+        # Get the source branch for the current work type
+        source_branch = branch_sources[work_type]
+
+        # Check and pull main branch
+        if work_type in ["feature", "features", "fix", "release"]:
+            self.branch_creator.check_and_pull_branch("main")
+
+        # Check and pull develop branch
+        if work_type in ["feature", "features", "fix", "release"]:
+            self.branch_creator.check_and_pull_branch("develop")
+
+        # Check and pull source branch (if it's different from main/develop) or for hotfix
+        if source_branch not in ["main", "develop"] or work_type == "hotfix":
+            self.branch_creator.check_and_pull_branch(source_branch)
+
+        # Create the new branch based on work type
+        self.branch_creator.create_git_flow_branch(work_type, source_branch)

wl_cli/commands/initenv/components/git/git_lfs_manager.py

@@ -0,0 +1,272 @@
+"""Git LFS manager utility."""
+
+import shutil
+import subprocess
+from pathlib import Path
+
+from wl_cli.utils.logging import log_error_pair, log_info_pair, log_warning_pair
+
+
+class GitLFSManager:
+    """Git LFS manager for initializing and configuring Git LFS."""
+
+    def __init__(self, env: dict[str, str]) -> None:
+        """Initialize Git LFS manager.
+
+        Args:
+            env: Environment variables for subprocess calls.
+        """
+        self.env = env
+        # 常见的3D模型文件类型
+        self.three_d_file_types = [
+            # SolidWorks
+            "*.sldprt",
+            "*.sldasm",
+            "*.slddrw",
+            # CAD
+            "*.dwg",
+            "*.dxf",
+            # 3D交换格式
+            "*.iges",
+            "*.igs",
+            "*.step",
+            "*.stp",
+            # 3D打印格式
+            "*.stl",
+            # 其他常见的3D模型格式
+            "*.obj",
+            "*.fbx",
+            "*.blend",
+            "*.3ds",
+        ]
+
+    def _check_git_lfs_installed(self) -> bool:
+        """检查Git LFS是否已安装.
+
+        Returns:
+            True if Git LFS is installed, False otherwise.
+        """
+        try:
+            result = subprocess.run(
+                ["git", "lfs", "version"],
+                check=True,
+                capture_output=True,
+                env=self.env,
+                text=True,
+            )
+            log_info_pair(
+                f"✓ Git LFS is installed: {result.stdout.strip()}",
+                f"✓ Git LFS 已安装: {result.stdout.strip()}",
+            )
+            return True
+        except subprocess.CalledProcessError:
+            log_error_pair("✗ Git LFS is not installed", "✗ Git LFS 未安装")
+            log_error_pair(
+                "Please install Git LFS from https://git-lfs.com/",
+                "请从 https://git-lfs.com/ 安装 Git LFS",
+            )
+            return False
+        except FileNotFoundError:
+            log_error_pair("✗ Git is not installed", "✗ Git 未安装")
+            return False
+
+    def _install_git_lfs(self) -> bool:
+        """安装Git LFS.
+
+        Returns:
+            True if Git LFS is installed successfully, False otherwise.
+        """
+        try:
+            log_info_pair("Initializing Git LFS...", "初始化 Git LFS...")
+            subprocess.run(
+                ["git", "lfs", "install", "--force"],
+                check=True,
+                capture_output=False,
+                env=self.env,
+            )
+            log_info_pair("✓ Git LFS initialized", "✓ Git LFS 初始化完成")
+            return True
+        except subprocess.CalledProcessError as e:
+            log_error_pair(
+                f"✗ Failed to initialize Git LFS: {e}", f"✗ 初始化 Git LFS 失败: {e}"
+            )
+            return False
+
+    def _configure_lfs_tracking(self) -> None:
+        """配置Git LFS跟踪3D模型文件类型."""
+        log_info_pair(
+            "Configuring Git LFS to track 3D model files...",
+            "配置 Git LFS 跟踪3D模型文件...",
+        )
+
+        # 跟踪所有3D模型文件类型
+        for file_type in self.three_d_file_types:
+            try:
+                subprocess.run(
+                    ["git", "lfs", "track", file_type],
+                    check=True,
+                    capture_output=False,
+                    env=self.env,
+                )
+                log_info_pair(f"✓ Tracking {file_type}", f"✓ 跟踪 {file_type}")
+            except subprocess.CalledProcessError as e:
+                log_error_pair(
+                    f"✗ Failed to track {file_type}: {e}",
+                    f"✗ 跟踪 {file_type} 失败: {e}",
+                )
+
+        # 确保.gitattributes文件被添加到Git
+        if Path(".gitattributes").exists():
+            try:
+                subprocess.run(
+                    ["git", "add", ".gitattributes"],
+                    check=True,
+                    capture_output=False,
+                    env=self.env,
+                )
+                log_info_pair(
+                    "✓ Added .gitattributes to Git", "✓ 将 .gitattributes 添加到 Git"
+                )
+            except subprocess.CalledProcessError as e:
+                log_error_pair(
+                    f"✗ Failed to add .gitattributes to Git: {e}",
+                    f"✗ 将 .gitattributes 添加到 Git 失败: {e}",
+                )
+
+    def _check_nested_git(self, auto_fix: bool = False) -> bool:
+        """检查项目中是否存在嵌套的.git目录，并可选择自动修复
+
+        Args:
+            auto_fix: 是否自动移除嵌套的.git目录
+
+        Returns:
+            True if no nested .git directories are found or all were successfully fixed,
+            False otherwise.
+        """
+        # 获取当前目录
+        current_dir = Path.cwd()
+        nested_git_dirs = []
+
+        # 查找所有嵌套的.git目录（不包括根目录的.git）
+        for git_dir in current_dir.glob("**/.git"):
+            # 跳过根目录的.git文件夹
+            if git_dir.parent == current_dir:
+                continue
+
+            # 检查是否是目录
+            if git_dir.is_dir():
+                nested_git_dirs.append(git_dir)
+
+        # 如果找到嵌套的.git目录，记录警告并可选择自动修复
+        if nested_git_dirs:
+            log_warning_pair(
+                "Found nested .git directories, which may cause Git operations to fail:",
+                "发现嵌套的.git目录，这可能导致Git操作失败:",
+            )
+
+            for git_dir in nested_git_dirs:
+                # Language-neutral payload (a path): both variants are identical by design.
+                log_warning_pair(f"  - {git_dir}", f"  - {git_dir}")
+
+            # 自动修复逻辑
+            if auto_fix:
+                log_info_pair(
+                    "\nAutomatically removing nested .git directories...",
+                    "\n正在自动移除嵌套的.git目录...",
+                )
+
+                all_removed = True
+                for git_dir in nested_git_dirs:
+                    try:
+                        shutil.rmtree(git_dir)
+                        log_info_pair(
+                            f"✓ Successfully removed: {git_dir}",
+                            f"✓ 成功移除: {git_dir}",
+                        )
+                    except Exception as e:
+                        log_error_pair(
+                            f"✗ Failed to remove {git_dir}: {e}",
+                            f"✗ 移除失败 {git_dir}: {e}",
+                        )
+                        all_removed = False
+
+                return all_removed
+            else:
+                log_warning_pair(
+                    "\nConsider removing these nested .git directories to avoid Git operation problems.",
+                    "\n建议移除这些嵌套的.git目录以避免Git操作问题。",
+                )
+                log_warning_pair(
+                    "Use the --fix option to automatically remove these nested .git directories.",
+                    "使用 --fix 选项可以自动移除这些嵌套的.git目录。",
+                )
+                return False
+
+        return True
+
+    def _check_git_repo(self) -> bool:
+        """检查当前目录是否是Git仓库.
+
+        Returns:
+            True if current directory is a Git repository, False otherwise.
+        """
+        git_dir = Path(".git")
+        if git_dir.is_dir():
+            log_info_pair(
+                "✓ Current directory is a Git repository", "✓ 当前目录是Git仓库"
+            )
+            return True
+        else:
+            log_error_pair(
+                "✗ Current directory is not a Git repository", "✗ 当前目录不是Git仓库"
+            )
+            log_error_pair(
+                "Please initialize Git repository first with: git init",
+                "请先使用 git init 初始化Git仓库",
+            )
+            return False
+
+    def initialize(self, auto_fix: bool = False) -> None:
+        """初始化Git LFS.
+
+        Args:
+            auto_fix: 是否自动移除嵌套的.git目录
+
+        Raises:
+            Exception: If Git LFS initialization fails.
+        """
+        # 检查当前目录是否是Git仓库
+        if not self._check_git_repo():
+            raise RuntimeError("Not a Git repository. Please run 'git init' first.")
+
+        # 检查是否存在嵌套的.git目录
+        self._check_nested_git(auto_fix)
+
+        # 检查Git LFS是否已安装
+        if not self._check_git_lfs_installed():
+            raise RuntimeError(
+                "Git LFS is not installed. Please install Git LFS first."
+            )
+
+        # 安装Git LFS
+        if not self._install_git_lfs():
+            raise RuntimeError("Failed to initialize Git LFS.")
+
+        # 配置Git LFS跟踪3D模型文件类型
+        self._configure_lfs_tracking()
+
+        log_info_pair(
+            "\n✓ Git LFS initialization completed successfully!",
+            "✓ Git LFS 初始化成功完成！",
+        )
+        log_info_pair(
+            "\nGit LFS is now configured to track the following file types:",
+            "Git LFS 现已配置为跟踪以下文件类型：",
+        )
+        for file_type in self.three_d_file_types:
+            # Language-neutral payload (a glob): both variants are identical by design.
+            log_info_pair(f"  - {file_type}", f"  - {file_type}")
+        log_info_pair(
+            "\nYou can now use Git commands as usual to manage your 3D model files.",
+            "现在您可以像往常一样使用 Git 命令来管理您的 3D 模型文件。",
+        )

wl_cli/commands/initenv/components/git/git_utility.py

@@ -0,0 +1,254 @@
+"""Git 工具类，封装基础的 Git 操作"""
+
+import subprocess
+import time
+from typing import cast
+
+from wl_cli.utils.logging import log_info
+from wl_cli.utils.subprocess_utils import SubprocessExecutor
+
+
+class GitUtility:
+    """提供基础的 Git 操作功能"""
+
+    def __init__(self, env: dict[str, str]):
+        """
+        初始化 GitUtility 类
+
+        Args:
+            env: 执行 Git 命令时使用的环境变量
+        """
+        self.env = env
+        self.max_retries = 3
+        self.retry_delay = 1.0
+        self._executor = SubprocessExecutor()
+
+    def _run_git_command(
+        self, command, check=False, capture_output=False, text=True
+    ) -> subprocess.CompletedProcess[str]:
+        """
+        执行 Git 命令并处理 index.lock 错误，包含重试机制
+
+        Args:
+            command: 要执行的 Git 命令
+            check: 是否检查返回码
+            capture_output: 是否捕获输出
+            text: 是否返回文本输出
+
+        Returns:
+            subprocess.CompletedProcess: 命令执行结果
+        """
+        for attempt in range(self.max_retries):
+            try:
+                prepared_env = self._executor._prepare_environment(self.env)
+                return cast(
+                    "subprocess.CompletedProcess[str]",
+                    subprocess.run(
+                        command,
+                        check=check,
+                        capture_output=capture_output,
+                        text=text,
+                        env=prepared_env,
+                    ),
+                )
+            except subprocess.CalledProcessError as e:
+                # 检查是否是 index.lock 错误
+                output = (e.stdout or "") + (e.stderr or "")
+                if (
+                    "index.lock" in str(output)
+                    if isinstance(output, str)
+                    else b"index.lock" in output
+                ) or "index.lock" in str(e):
+                    if attempt < self.max_retries - 1:
+                        # 等待一段时间后重试
+                        time.sleep(self.retry_delay)
+                        continue
+                raise
+            except Exception as e:
+                # 检查是否是 index.lock 相关的文件操作错误
+                if "index.lock" in str(e):
+                    if attempt < self.max_retries - 1:
+                        # 等待一段时间后重试
+                        time.sleep(self.retry_delay)
+                        continue
+                raise
+        # 如果所有重试都失败，再次执行命令让它抛出原始错误
+        prepared_env = self._executor._prepare_environment(self.env)
+        return cast(
+            "subprocess.CompletedProcess[str]",
+            subprocess.run(
+                command,
+                check=check,
+                capture_output=capture_output,
+                text=text,
+                env=prepared_env,
+            ),
+        )
+
+    def run_git_command(
+        self,
+        cmd: list[str],
+        description: str = "",
+        max_retries: int | None = None,
+    ) -> bool:
+        retries = max_retries if max_retries is not None else self.max_retries
+        desc = description or " ".join(cmd)
+        log_info(f"执行 Git 命令: {desc}")
+        for attempt in range(retries):
+            try:
+                self._run_git_command(cmd, check=True, capture_output=True, text=True)
+                log_info(f"Git 命令执行成功: {desc}")
+                return True
+            except FileNotFoundError:
+                log_info(f"Git 命令未找到: {desc}")
+                return False
+            except PermissionError:
+                log_info(f"Git 命令权限不足: {desc}")
+                return False
+            except subprocess.CalledProcessError:
+                if attempt < retries - 1:
+                    time.sleep(self.retry_delay)
+                    continue
+                log_info(f"Git 命令执行失败: {desc}")
+                return False
+        return False
+
+    def is_git_repository(self) -> bool:
+        """
+        检查当前目录是否在 Git 仓库内
+
+        Returns:
+            bool: 如果在 Git 仓库内返回 True，否则返回 False
+        """
+        result = self._run_git_command(
+            ["git", "rev-parse", "--is-inside-work-tree"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        return result.returncode == 0
+
+    def get_current_branch(self) -> str:
+        """
+        获取当前分支名称
+
+        Returns:
+            str: 当前分支名称
+        """
+        result = self._run_git_command(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        return result.stdout.strip()
+
+    def branch_exists(self, branch_name: str) -> bool:
+        """
+        检查指定分支是否存在
+
+        Args:
+            branch_name: 要检查的分支名称
+
+        Returns:
+            bool: 如果分支存在返回 True，否则返回 False
+        """
+        result = self._run_git_command(
+            ["git", "branch", "--list", branch_name],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        for line in result.stdout.strip().splitlines():
+            cleaned = line.strip().lstrip("* ")
+            if cleaned == branch_name:
+                return True
+        return False
+
+    def checkout_branch(self, branch_name: str) -> None:
+        """
+        切换到指定分支
+
+        Args:
+            branch_name: 要切换到的分支名称
+        """
+        self._run_git_command(
+            ["git", "checkout", branch_name],
+            check=False,
+            capture_output=False,
+        )
+
+    def create_and_checkout_branch(
+        self, branch_name: str, source_branch: str | None = None
+    ) -> None:
+        """
+        创建并切换到新分支
+
+        Args:
+            branch_name: 新分支名称
+            source_branch: 源分支名称（可选）
+        """
+        if source_branch:
+            self._run_git_command(
+                ["git", "checkout", "-b", branch_name, source_branch],
+                check=False,
+                capture_output=False,
+            )
+        else:
+            self._run_git_command(
+                ["git", "checkout", "-b", branch_name],
+                check=False,
+                capture_output=False,
+            )
+
+    def pull_branch(self, branch_name: str, remote: str = "origin") -> None:
+        """
+        拉取指定分支的最新更改
+
+        Args:
+            branch_name: 分支名称
+            remote: 远程仓库名称（默认: origin）
+        """
+        self._run_git_command(
+            ["git", "pull", remote, branch_name],
+            check=True,
+            capture_output=False,
+        )
+
+    def create_branch_from_remote(
+        self, branch_name: str, remote: str = "origin"
+    ) -> None:
+        """
+        从远程创建本地分支
+
+        Args:
+            branch_name: 分支名称
+            remote: 远程仓库名称（默认: origin）
+        """
+        self._run_git_command(
+            ["git", "checkout", "-b", branch_name, f"{remote}/{branch_name}"],
+            check=True,
+            capture_output=False,
+        )
+
+    def local_branch_exists(self, branch_name: str) -> bool:
+        """
+        检查本地分支是否存在
+
+        Args:
+            branch_name: 分支名称
+
+        Returns:
+            bool: 如果本地分支存在返回 True，否则返回 False
+        """
+        result = self._run_git_command(
+            ["git", "branch", "--list", branch_name],
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        for line in result.stdout.strip().splitlines():
+            cleaned = line.strip().lstrip("* ")
+            if cleaned == branch_name:
+                return True
+        return False