py-wlcli 0.8.0__py3-none-any.whl

wl_cli/commands/initenv/common/exceptions.py

@@ -0,0 +1,52 @@
+"""Custom exceptions for initenv module."""
+
+from ....exceptions import CommandError
+
+
+class InitEnvError(CommandError):
+    """Base exception for initenv errors."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+class ProjectStructureError(InitEnvError):
+    """Failed to create project structure."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+class VenvCreationError(InitEnvError):
+    """Failed to create virtual environment."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+class GitInitError(InitEnvError):
+    """Failed to initialize Git repository."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+class GitLfsInitError(InitEnvError):
+    """Failed to initialize Git LFS."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+class CargoSyncError(InitEnvError):
+    """Failed to sync Cargo.toml with pyproject.toml."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+class LfsLockError(InitEnvError):
+    """Failed to initialize LFS lock workflow configuration."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)

wl_cli/commands/initenv/components/__init__.py

@@ -0,0 +1,4 @@
+"""Reusable components for initenv module."""
+
+# No exports needed - imports are direct by path
+__all__ = []

wl_cli/commands/initenv/components/cargo_sync.py

@@ -0,0 +1,240 @@
+"""
+Cargo.toml synchronization functionality for init command.
+"""
+
+import re
+from pathlib import Path
+from typing import Any, cast
+
+# Try to import TOML libraries
+tomllib: Any
+try:
+    import tomllib
+except ImportError:
+    # If not available, we'll handle it when needed
+    tomllib = None
+
+# --- Constants for Cargo sync ---
+PYO3_VERSION = "0.21"
+PYO3_FEATURES = ["extension-module"]
+
+
+def load_toml(path: Path) -> dict[str, Any]:
+    """Loads a TOML file, handling errors."""
+    if tomllib is None:
+        raise RuntimeError("错误: 需要 Python 3.11+ 或安装 tomli/toml 包")
+
+    try:
+        with open(path, "rb") as f:
+            return cast("dict[str, Any]", tomllib.load(f))
+    except FileNotFoundError:
+        raise FileNotFoundError(f"错误: {path} 未找到。")
+    except Exception as e:
+        raise RuntimeError(f"错误: 解析 {path} 失败: {e}")
+
+
+def _format_complex_value(value: Any) -> str:
+    """Format complex values like dicts and mixed lists."""
+    if isinstance(value, dict):
+        parts = []
+        for k, v in value.items():
+            if isinstance(v, str):
+                parts.append(f'{k} = "{v}"')
+            elif isinstance(v, bool):
+                parts.append(f"{k} = {str(v).lower()}")
+            elif isinstance(v, list):
+                formatted_list = "[" + ", ".join(f'"{item}"' for item in v) + "]"
+                parts.append(f"{k} = {formatted_list}")
+            else:
+                parts.append(f"{k} = {v}")
+        return "{ " + ", ".join(parts) + " }"
+    elif isinstance(value, bool):
+        return str(value).lower()
+    else:
+        return str(value)
+
+
+def _write_toml_value(f, key: str, value: Any) -> None:
+    """Write a single TOML key-value pair."""
+    if isinstance(value, str):
+        f.write(f'{key} = "{value}"\n')
+    elif isinstance(value, bool):
+        f.write(f"{key} = {str(value).lower()}\n")
+    elif isinstance(value, list):
+        if all(isinstance(item, str) for item in value):
+            formatted_list = "[" + ", ".join(f'"{item}"' for item in value) + "]"
+            f.write(f"{key} = {formatted_list}\n")
+        else:
+            # For complex lists like pyo3 dependency
+            f.write(f"{key} = {_format_complex_value(value)}\n")
+    elif isinstance(value, dict):
+        f.write(f"{key} = {_format_complex_value(value)}\n")
+    else:
+        f.write(f"{key} = {value}\n")
+
+
+def _write_toml_dict(data: dict[str, Any], f) -> None:
+    """Simple TOML writer for basic data structures."""
+    for key, value in data.items():
+        if isinstance(value, dict):
+            f.write(f"\n[{key}]\n")
+            for subkey, subvalue in value.items():
+                _write_toml_value(f, subkey, subvalue)
+        else:
+            _write_toml_value(f, key, value)
+
+
+def write_toml(data: dict[str, Any], path: Path) -> None:
+    """Writes data to a TOML file, handling errors."""
+    try:
+        with open(path, "w", encoding="utf-8") as f:
+            _write_toml_dict(data, f)
+    except OSError as e:
+        raise RuntimeError(f"错误: 写入 {path} 失败: {e}")
+
+
+def clean_cargo_name(name: str) -> str:
+    """Cleans a string to be a valid Cargo package name.
+    - Replaces invalid characters (anything not letter, number, _, -) with underscore.
+    - Ensures it doesn't start/end with invalid chars like _ or -.
+    """
+    cleaned = re.sub(r"[^a-zA-Z0-9_]+", "_", name.replace("-", "_"))
+    cleaned = cleaned.strip("_")
+    if not cleaned:
+        return "rust_package"
+    if cleaned[0].isdigit():
+        cleaned = "_" + cleaned
+    return cleaned
+
+
+def extract_rust_crate_name(pyproject_data: dict[str, Any]) -> str | None:
+    """Extracts and cleans the Rust crate name from pyproject data."""
+    try:
+        maturin_config = pyproject_data["tool"]["maturin"]
+        module_name = maturin_config.get("module-name")
+        if module_name and "." in module_name:
+            raw_name = module_name.split(".")[-1]
+            return clean_cargo_name(raw_name)
+        else:
+            return None
+    except KeyError:
+        return None
+
+
+def format_authors(authors_list: list[dict[str, str]]) -> list[str]:
+    """Formats pyproject authors for Cargo.toml."""
+    formatted = []
+    for author in authors_list:
+        name = author.get("name")
+        email = author.get("email")
+        if name and email:
+            formatted.append(f"{name} <{email}>")
+        elif name:
+            formatted.append(name)
+    return formatted
+
+
+def extract_pyproject_metadata(pyproject_data: dict[str, Any]) -> dict[str, Any]:
+    """Extracts relevant metadata from pyproject data."""
+    project_info = pyproject_data.get("project", {})
+    return {
+        "version": project_info.get("version"),
+        "description": project_info.get("description"),
+        "authors": project_info.get("authors"),
+        "license": project_info.get("license"),
+    }
+
+
+def update_cargo_package_section(
+    cargo_data: dict[str, Any],
+    metadata: dict[str, Any],
+    rust_crate_name: str | None,
+    cargo_path: Path,
+) -> None:
+    """Updates the [package] section of Cargo data."""
+    package_info = cargo_data.setdefault("package", {})
+
+    # Update name
+    if rust_crate_name:
+        package_info["name"] = rust_crate_name
+    elif "name" not in package_info:
+        raise RuntimeError(
+            "错误: 无法确定 Cargo 包名，且 Cargo.toml 中未设置 [package].name"
+        )
+
+    # Update other metadata
+    if metadata["version"]:
+        package_info["version"] = metadata["version"]
+    if metadata["description"]:
+        package_info["description"] = metadata["description"]
+    if metadata["authors"]:
+        package_info["authors"] = format_authors(metadata["authors"])
+    if metadata["license"]:
+        # Handle license format from pyproject.toml
+        if isinstance(metadata["license"], dict) and "file" in metadata["license"]:
+            # If license is in format {"file": "LICENSE"}, use license-file field
+            # Calculate the relative path from Cargo.toml to the license file
+            license_file = metadata["license"]["file"]
+            # Calculate the relative path from Cargo.toml's directory to the license file
+            # The license file is usually in the project root, so we need to go up one level
+            # if Cargo.toml is in a subdirectory like rust/
+            relative_path = Path(license_file)
+            if not relative_path.is_absolute():
+                # If the license file path is relative in pyproject.toml, it's relative to the project root
+                # So we need to calculate the relative path from Cargo.toml's directory
+                # Assuming Cargo.toml is in rust/ directory, go up one level
+                relative_path = Path("../") / license_file
+            # Always use forward slashes in Cargo.toml paths, regardless of platform
+            package_info["license-file"] = str(relative_path).replace("\\", "/")
+        else:
+            # Otherwise use regular license field
+            package_info["license"] = metadata["license"]
+
+
+def update_cargo_dependencies(cargo_data: dict[str, Any]) -> None:
+    """Updates the [dependencies] section, adding pyo3 if missing."""
+    dependencies = cargo_data.setdefault("dependencies", {})
+    if "pyo3" not in dependencies:
+        dependencies["pyo3"] = {"version": PYO3_VERSION, "features": PYO3_FEATURES}
+
+
+def update_cargo_lib_section(cargo_data: dict[str, Any]) -> None:
+    """Updates the [lib] section, ensuring crate-type is set."""
+    if "lib" not in cargo_data:
+        cargo_data["lib"] = {"crate-type": ["cdylib"]}
+    elif "crate-type" not in cargo_data.get("lib", {}):
+        cargo_data.setdefault("lib", {})["crate-type"] = ["cdylib"]
+
+
+def sync_toml_files(pyproject_path: Path, cargo_path: Path) -> None:
+    """Loads pyproject.toml and Cargo.toml, syncs metadata, and saves Cargo.toml."""
+    # Load pyproject.toml
+    pyproject_data = load_toml(pyproject_path)
+
+    # Check if Cargo.toml exists
+    if not cargo_path.exists():
+        # If Cargo.toml doesn't exist, skip syncing
+        from wl_cli.utils.logging import log_info_pair
+
+        log_info_pair(
+            f"Cargo.toml not found at {cargo_path}, skipping sync",
+            f"未找到 {cargo_path}，跳过同步",
+        )
+        return
+
+    # Load Cargo.toml
+    cargo_data = load_toml(cargo_path)
+
+    # Extract info
+    rust_crate_name = extract_rust_crate_name(pyproject_data)
+    pyproject_metadata = extract_pyproject_metadata(pyproject_data)
+
+    # Update Cargo data
+    update_cargo_package_section(
+        cargo_data, pyproject_metadata, rust_crate_name, cargo_path
+    )
+    update_cargo_dependencies(cargo_data)
+    update_cargo_lib_section(cargo_data)
+
+    # Write back Cargo.toml
+    write_toml(cargo_data, cargo_path)

wl_cli/commands/initenv/components/config_manager.py

@@ -0,0 +1,106 @@
+"""Configuration manager utility."""
+
+import json
+import os
+from pathlib import Path
+from typing import Any, cast
+
+import tomllib as toml  # stdlib (py>=3.11): typed, so mypy is env-independent
+
+from ....utils.platform_adapter import PlatformAdapter
+
+
+class ConfigManager:
+    """Manager for loading and managing configuration."""
+
+    def __init__(self, config_file: str = "config.json") -> None:
+        self.config_file = config_file
+        self.config: dict[str, Any] = {}
+        self.load_config()
+        self._vendor_path = self._get_vendor_path()
+
+    def _get_vendor_path(self) -> Path:
+        """Get the path to the vendors directory."""
+        current_file = Path(__file__)
+        vendor_path = current_file.parent.parent.parent.parent / "vendors"
+        return vendor_path.resolve()
+
+    def load_config(self) -> None:
+        """Load configuration from file or environment variables."""
+        # Load from config file if exists
+        if Path(self.config_file).exists():
+            try:
+                with open(self.config_file, encoding="utf-8") as f:
+                    self.config = json.load(f)
+            except (json.JSONDecodeError, OSError):
+                # If file loading fails, continue with empty config
+                self.config = {}
+
+        # Override with environment variables
+        self._load_from_env()
+
+    def _load_from_env(self) -> None:
+        """Load configuration from environment variables."""
+        # Example environment variable loading
+        python_version = os.environ.get("PYTHON_VERSION")
+        if python_version:
+            self.config["python_version"] = python_version
+
+        venv_path = os.environ.get("VENV_PATH")
+        if venv_path:
+            self.config["venv_path"] = venv_path
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get configuration value by key."""
+        return self.config.get(key, default)
+
+    def set(self, key: str, value: Any) -> None:
+        """Set configuration value by key."""
+        self.config[key] = value
+
+    def get_vendor_config_path(self, config_file: str) -> Path:
+        """Get the path to a configuration file in the vendors directory.
+
+        For hooks, automatically selects the appropriate directory based on the platform,
+        unless an explicit platform directory (win/unix) is already specified.
+        """
+
+        # Check if we're dealing with hooks and no explicit platform is specified
+        if config_file.startswith("hooks") and not any(
+            platform in config_file for platform in ["/win", "/unix", "win/", "unix/"]
+        ):
+            # Determine the appropriate hook directory based on platform
+            if PlatformAdapter.is_windows():  # Windows
+                # Replace hooks/ with hooks/win/
+                if config_file == "hooks":
+                    config_file = "hooks/win"
+                elif config_file.startswith("hooks/"):
+                    config_file = config_file.replace("hooks/", "hooks/win/")
+            else:  # Unix-like (Linux, macOS)
+                # Replace hooks/ with hooks/unix/
+                if config_file == "hooks":
+                    config_file = "hooks/unix"
+                elif config_file.startswith("hooks/"):
+                    config_file = config_file.replace("hooks/", "hooks/unix/")
+
+        return self._vendor_path / config_file
+
+    def load_vendor_config(self, config_file: str) -> dict[str, Any]:
+        """Load configuration from a file in the vendors directory."""
+        config_path = self._vendor_path / config_file
+        if not config_path.exists():
+            return {}
+
+        try:
+            if config_path.suffix == ".toml":
+                with open(config_path, "rb") as f:
+                    return toml.load(f)  # tomllib typed -> returns dict[str, Any]
+            elif config_path.suffix == ".json":
+                with open(config_path, encoding="utf-8") as f:
+                    return cast("dict[str, Any]", json.load(f))
+            else:
+                # For other file types, return the raw content
+                with open(config_path, encoding="utf-8") as f:
+                    return {"content": f.read()}
+        except (OSError, json.JSONDecodeError, toml.TOMLDecodeError):
+            return {}

wl_cli/commands/initenv/components/directory_utils.py

@@ -0,0 +1,71 @@
+"""
+Directory utilities for deployment functionality.
+"""
+
+import os
+
+# Whitelist: only these files or directories will be deployed
+DEPLOY_WHITELIST = [
+    ".uv",
+    ".lingma",
+    "tools",
+    "Makefile",
+    ".python-version",
+    "project_vendors",
+]
+
+
+def find_py_directories() -> list[str]:
+    """
+    查找当前目录下所有以 py_ 开头的文件夹
+    """
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    py_dirs = []
+
+    try:
+        for item in os.listdir(current_dir):
+            item_path = os.path.join(current_dir, item)
+            if item.startswith("py_") and os.path.isdir(item_path):
+                py_dirs.append(item_path)
+    except OSError:
+        pass
+
+    return py_dirs
+
+
+def is_ignored_directory(dir_name: str) -> bool:
+    """
+    检查目录是否应被忽略
+    """
+    ignored_dirs = [".git", "__pycache__"]  # 移除了 .cursor 和 .uv
+    for ignored in ignored_dirs:
+        if ignored in dir_name.split(os.sep):
+            return True
+    return False
+
+
+def is_excluded_file(file_name: str) -> bool:
+    """
+    检查文件是否应被排除不创建链接
+    """
+    excluded_files = ["README.md", ".gitignore"]  # 添加.gitignore到排除列表
+    return file_name in excluded_files
+
+
+def is_in_whitelist(path: str, source_dir: str) -> bool:
+    """
+    检查文件或目录是否在白名单中
+    """
+    try:
+        rel_path = os.path.relpath(path, source_dir)
+        if rel_path == ".":
+            return False
+
+        # 检查路径或其父目录是否在白名单中
+        path_parts = rel_path.split(os.sep)
+        for i in range(len(path_parts)):
+            if os.sep.join(path_parts[: i + 1]) in DEPLOY_WHITELIST:
+                return True
+        return False
+    except (OSError, ValueError):
+        return False

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

@@ -0,0 +1,9 @@
+# Git utilities module
+
+from .git_flow_manager import GitFlowManager
+from .gitignore_manager import GitignoreManager
+
+__all__ = [
+    "GitignoreManager",
+    "GitFlowManager",
+]

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

@@ -0,0 +1,143 @@
+"""分支创建器，处理 Git Flow 分支创建逻辑"""
+
+import re
+import subprocess
+import sys
+
+from wl_cli.utils.logging import log_info, log_info_pair
+
+
+class BranchCreator:
+    """处理 Git Flow 分支创建逻辑"""
+
+    def __init__(self, git_utility):
+        """
+        初始化 BranchCreator 类
+
+        Args:
+            git_utility: GitUtility 实例，用于执行基础 Git 操作
+        """
+        self.git_utility = git_utility
+
+    def setup_initial_branches(self) -> None:
+        """设置初始的 Git Flow 分支结构（main 和 develop）"""
+        log_info_pair("Starting setup_initial_branches...", "开始设置初始分支...")
+
+        current_branch = self.git_utility.get_current_branch()
+        log_info_pair(
+            f"Current branch: {current_branch}", f"当前分支: {current_branch}"
+        )
+
+        if not self.git_utility.branch_exists("main"):
+            log_info_pair("Creating main branch...", "创建 main 分支...")
+
+            if current_branch != "main":
+                log_info("Creating main branch directly...")
+                self.git_utility.create_and_checkout_branch("main")
+            else:
+                log_info("Already on main branch")
+
+            log_info_pair("✓ Main branch created", "✓ Main 分支创建成功")
+        else:
+            log_info_pair("Main branch already exists", "Main 分支已存在")
+            self.git_utility.checkout_branch("main")
+
+        if not self.git_utility.branch_exists("develop"):
+            log_info_pair("Creating develop branch...", "创建 develop 分支...")
+
+            log_info("Creating develop branch directly...")
+            self.git_utility.create_and_checkout_branch("develop")
+
+            log_info_pair("✓ Develop branch created", "✓ Develop 分支创建成功")
+        else:
+            log_info_pair("Develop branch already exists", "Develop 分支已存在")
+            self.git_utility.checkout_branch("develop")
+
+    def check_and_pull_branch(self, branch_name: str) -> None:
+        """
+        检查分支是否存在并拉取最新更改
+
+        Args:
+            branch_name: 要检查和拉取的分支名称
+        """
+        log_info_pair(
+            f"Checking and pulling {branch_name} branch...",
+            f"正在检查并拉取 {branch_name} 分支...",
+        )
+
+        try:
+            if self.git_utility.local_branch_exists(branch_name):
+                self.git_utility.checkout_branch(branch_name)
+
+                self.git_utility.pull_branch(branch_name)
+                log_info_pair(
+                    f"✓ {branch_name} branch pulled successfully",
+                    f"✓ {branch_name} 分支拉取成功",
+                )
+            else:
+                self.git_utility.create_branch_from_remote(branch_name)
+                log_info_pair(
+                    f"✓ {branch_name} branch created from remote",
+                    f"✓ 从远程创建 {branch_name} 分支成功",
+                )
+        except subprocess.CalledProcessError as e:
+            log_info_pair(
+                f"Warning: Failed to check and pull {branch_name} branch",
+                f"警告: 检查并拉取 {branch_name} 分支失败",
+            )
+            log_info_pair(f"Error details: {e}", f"错误详情: {e}")
+
+    def create_git_flow_branch(self, work_type: str, source_branch: str) -> None:
+        """
+        根据工作类型创建 Git Flow 分支
+
+        Args:
+            work_type: 工作类型 (feature, fix, hotfix, release)
+            source_branch: 源分支名称
+        """
+        log_info_pair(
+            f"Creating {work_type} branch from {source_branch}...",
+            f"正在从 {source_branch} 创建 {work_type} 分支...",
+        )
+
+        try:
+            if not sys.stdin.isatty():
+                log_info_pair(
+                    "Non-interactive environment detected, skipping branch creation",
+                    "检测到非交互环境，跳过分支创建",
+                )
+                return
+
+            current_branch = self.git_utility.get_current_branch()
+
+            if current_branch != source_branch:
+                self.git_utility.checkout_branch(source_branch)
+
+            branch_name = input(
+                f"Enter {work_type} branch name (e.g., {work_type}/my-feature): "
+            )
+
+            if not re.match(r"^[a-zA-Z0-9._/-]+$", branch_name):
+                log_info_pair(
+                    f"Invalid branch name: {branch_name}",
+                    f"无效的分支名称: {branch_name}",
+                )
+                return
+
+            if not branch_name.startswith(f"{work_type}/"):
+                branch_name = f"{work_type}/{branch_name}"
+
+            self.git_utility.create_and_checkout_branch(branch_name)
+
+            log_info_pair(
+                f"✓ Created and checked out {branch_name} branch",
+                f"✓ 创建并切换到 {branch_name} 分支成功",
+            )
+        except subprocess.CalledProcessError as e:
+            log_info_pair(
+                f"Warning: Failed to create {work_type} branch",
+                f"警告: 创建 {work_type} 分支失败",
+            )
+            log_info_pair(f"Error details: {e}", f"错误详情: {e}")
+        except KeyboardInterrupt:
+            log_info_pair("\nOperation cancelled by user", "\n用户取消了操作")

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

@@ -0,0 +1,24 @@
+"""Git Flow 接口定义"""
+
+from abc import ABC, abstractmethod
+
+
+class GitFlowInterface(ABC):
+    """Git Flow 接口，定义 Git Flow 操作的基本方法"""
+
+    @abstractmethod
+    def setup_git_flow_branches(self) -> None:
+        """
+        设置 Git Flow 分支结构
+        """
+        pass
+
+    @abstractmethod
+    def setup_git_flow_branches_by_work_type(self, work_type: str) -> None:
+        """
+        根据工作类型设置 Git Flow 分支
+
+        Args:
+            work_type: 工作类型 (feature, fix, hotfix, release)
+        """
+        pass