py-wlcli 0.8.0__py3-none-any.whl

wl_cli/commands/initenv/initenv.py

@@ -0,0 +1,169 @@
+"""初始化项目命令"""
+
+import os
+
+import click
+
+from ...exceptions import CommandError
+from ..lfs.initializer import LfsLockInitializer, lfs_lock_init_failure_message
+from .components.git.git_flow_manager import GitFlowManager
+from .components.git_initializer import GitInitializer
+from .services.environment_initializer import EnvironmentInitializer
+from .services.git_lfs_initializer import GitLfsInitializer
+from .services.project_structure_initializer import ProjectStructureInitializer
+
+
+@click.group(
+    invoke_without_command=True,
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+@click.option(
+    "-v",
+    "--verbose",
+    is_flag=True,
+    help="Enable verbose output showing detailed progress information",
+)
+@click.option(
+    "--log-level",
+    type=click.Choice(["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]),
+    help="Set the log level for the project",
+)
+@click.option(
+    "--log-console",
+    is_flag=True,
+    help="Enable console logging",
+)
+@click.option(
+    "--log-file",
+    help="Set the log file path",
+)
+def initenv_group(
+    verbose: bool, log_level: str | None, log_console: bool, log_file: str | None
+) -> None:
+    """Initialize project environment or project structure.
+
+    Use one of the subcommands: env, project, git, lfs, work
+
+    If no subcommand is specified, defaults to 'env'.
+    """
+    ctx = click.get_current_context()
+    if ctx.invoked_subcommand is None:
+        _execute_env_command(verbose, log_level, log_console, log_file)
+
+
+def _execute_env_command(
+    verbose: bool, log_level: str | None, log_console: bool, log_file: str | None
+) -> None:
+    """Execute the env command logic."""
+    env_initializer = EnvironmentInitializer(env=os.environ.copy())
+    kwargs: dict = {"verbose": verbose}
+    if log_level:
+        kwargs["log_level"] = log_level
+    if log_console:
+        kwargs["log_console"] = True
+    if log_file:
+        kwargs["log_file"] = log_file
+    try:
+        env_initializer.initialize(**kwargs)
+    except CommandError as exc:
+        # Surface the failure as a Click error so ``wl init env`` / bare
+        # ``wl init`` exit non-zero instead of reporting success.
+        raise click.ClickException(str(exc)) from exc
+
+
+@initenv_group.command()
+@click.option(
+    "-v",
+    "--verbose",
+    is_flag=True,
+    help="Enable verbose output showing detailed progress information",
+)
+@click.option(
+    "--log-level",
+    type=click.Choice(["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]),
+    help="Set the log level for the project",
+)
+@click.option(
+    "--log-console",
+    is_flag=True,
+    help="Enable console logging",
+)
+@click.option(
+    "--log-file",
+    help="Set the log file path",
+)
+def env(
+    verbose: bool, log_level: str | None, log_console: bool, log_file: str | None
+) -> None:
+    """Initialize project environment."""
+    _execute_env_command(verbose, log_level, log_console, log_file)
+
+
+@initenv_group.command()
+@click.option(
+    "--workspace/--no-workspace",
+    default=True,
+    help="Initialize project as uv workspace (packages/* layout) or flat layout (default: workspace)",
+)
+def project(workspace: bool) -> None:
+    """Initialize project structure."""
+    project_initializer = ProjectStructureInitializer()
+    project_initializer.initialize(workspace=workspace)
+
+
+@initenv_group.command()
+@click.argument(
+    "work_type",
+    type=click.Choice(["feature", "fix", "hotfix", "release"]),
+)
+def work(work_type: str) -> None:
+    """Initialize Git Flow work environment."""
+    env = dict(os.environ)
+    skip_remote_ops = os.environ.get("PYTEST_CURRENT_TEST") is not None
+    manager = GitFlowManager(env, skip_remote_ops=skip_remote_ops)
+    manager.setup_git_flow_branches_by_work_type(work_type)
+
+
+@initenv_group.command()
+def git() -> None:
+    """Initialize Git repository."""
+    env = dict(os.environ)
+    skip_remote_ops = os.environ.get("PYTEST_CURRENT_TEST") is not None
+    initializer = GitInitializer(env, skip_remote_ops=skip_remote_ops)
+    initializer.initialize()
+
+
+@initenv_group.command()
+@click.option(
+    "--fix",
+    is_flag=True,
+    help="Automatically fix issues like nested .git directories when initializing LFS",
+)
+@click.option(
+    "--with-locks",
+    is_flag=True,
+    help="Initialize LFS lock workflow configuration",
+)
+def lfs(fix: bool, with_locks: bool) -> None:
+    """Initialize Git LFS."""
+    lock_initializer = LfsLockInitializer() if with_locks else None
+    # Probe the lock workflow's precondition before the Git LFS step mutates
+    # the repository (filters, hooks, config): failing afterwards would leave
+    # the project half-initialized (#198).
+    if lock_initializer is not None and not lock_initializer.wl_dir_ready():
+        raise click.ClickException(
+            lfs_lock_init_failure_message(lock_initializer.project_root)
+        )
+
+    lfs_initializer = GitLfsInitializer()
+    lfs_initializer.initialize(auto_fix=fix)
+
+    if lock_initializer is not None and lock_initializer.initialize() is False:
+        raise click.ClickException(
+            lfs_lock_init_failure_message(lock_initializer.project_root)
+        )
+
+
+def initenv() -> click.Group:
+    """Return the initenv Click group for registration."""
+    return initenv_group

wl_cli/commands/initenv/services/__init__.py

@@ -0,0 +1,11 @@
+"""Business services for initenv module."""
+
+from .environment_initializer import EnvironmentInitializer
+from .git_lfs_initializer import GitLfsInitializer
+from .project_structure_initializer import ProjectStructureInitializer
+
+__all__ = [
+    "EnvironmentInitializer",
+    "ProjectStructureInitializer",
+    "GitLfsInitializer",
+]

wl_cli/commands/initenv/services/environment_initializer.py

@@ -0,0 +1,288 @@
+"""Environment initialization coordinator."""
+
+import subprocess
+from pathlib import Path
+
+from ....exceptions import CommandError
+from ....utils.logging import (
+    log_debug,
+    log_debug_pair,
+    log_error_pair,
+    log_info_pair,
+)
+from ....utils.platform_adapter import PlatformAdapter
+from ....utils.workspace_detector import WorkspaceDetector
+from ..common import error_handler
+from ..components import (
+    cargo_sync,
+    config_manager,
+    i18n_manager,
+    log_manager,
+    pyproject_generator,
+    rust_initializer,
+    venv_manager,
+)
+from ..components.project_structure.setup_handler import ProjectStructureSetup
+
+
+class EnvironmentInitializer:
+    """Coordinator for project initialization."""
+
+    def __init__(self, env: dict[str, str]) -> None:
+        self.env = env
+        self.project_name = Path.cwd().name
+        self.config_manager = config_manager.ConfigManager()
+        self.i18n_manager = i18n_manager.I18nManager()
+        self.log_manager = log_manager.LogManager()
+        self.workspace_detector = WorkspaceDetector()
+
+        # Initialize sub-components
+        self.project_structure_setup = ProjectStructureSetup()
+        self.rust_initializer = rust_initializer.RustInitializer()
+        self.venv_manager = venv_manager.VenvManager(env)
+
+    @error_handler("Failed to initialize project environment")
+    def initialize(self, **kwargs) -> None:
+        """
+        Initialize complete project environment.
+
+        Args:
+            **kwargs: Command line arguments including log configuration parameters
+        """
+        log_info_pair(
+            "=== Starting initialization of project environment ===",
+            "=== 开始初始化项目环境 ===",
+        )
+
+        # Check uv installation
+        self.check_uv_installed()
+
+        # Apply logging configuration
+        log_manager.LogManager.configure_logging(**kwargs)
+
+        # Check if project is already initialized
+        is_initialized = self.is_project_initialized()
+
+        if is_initialized:
+            log_info_pair(
+                "=== Project already initialized, performing daily update ===",
+                "=== 项目已初始化，执行每日更新 ===",
+            )
+            # Execute update process
+            self.update_project()
+        else:
+            # Execute full initialization process
+            # Setup project structure (don't use workspace config, don't copy template pyproject.toml)
+            # pyproject.toml will be generated by PyProjectGenerator with complete configuration
+            self.setup_project_structure(use_workspace=False, copy_pyproject=False)
+
+            # Initialize Rust if needed
+            self.init_rust()
+
+            # Generate pyproject.toml if needed
+            # Run after init_rust to correctly detect Rust environment
+            self.generate_pyproject()
+
+            # Sync Cargo.toml with pyproject.toml
+            self.sync_cargo_toml()
+
+            # Create virtual environment
+            self.create_venv()
+
+        # Platform-specific finalization
+        self._finalize()
+
+        log_info_pair(
+            "Project environment initialization completed!",
+            "项目环境初始化完成!",
+        )
+
+    @staticmethod
+    def _finalize() -> None:
+        """Run the platform-specific finalization step.
+
+        The former ``_finalize_windows`` and ``_finalize_unix`` differed only
+        in the label they logged, so the platform is read from
+        :class:`PlatformAdapter` here rather than branched on by the caller.
+        """
+        if PlatformAdapter.is_windows():
+            log_info_pair(
+                "✓ Windows-specific finalization completed",
+                "✓ Windows特定的最终化完成",
+            )
+        else:
+            log_info_pair(
+                "✓ Unix-specific finalization completed",
+                "✓ Unix特定的最终化完成",
+            )
+
+    @error_handler("Failed to check uv installation")
+    def check_uv_installed(self) -> None:
+        """Check if uv is installed."""
+        subprocess.run(
+            ["uv", "--version"], check=True, capture_output=True, env=self.env
+        )
+        log_info_pair(
+            "✓ uv command found.",
+            "✓ 找到 uv 命令。",
+        )
+
+    @error_handler("Failed to setup project structure")
+    def setup_project_structure(
+        self, use_workspace: bool | None = None, copy_pyproject: bool = True
+    ) -> None:
+        """Setup project structure.
+
+        Args:
+            use_workspace: If True, use pyproject.toml with workspace config.
+                          If False, use pyproject.toml without workspace config.
+                          If None, auto-detect based on current environment.
+            copy_pyproject: If True, copy pyproject.toml from template.
+                           If False, skip pyproject.toml (will be generated by PyProjectGenerator).
+        """
+        log_debug_pair(
+            "Setting up project structure...",
+            "设置项目结构...",
+        )
+
+        # Determine workspace mode
+        if use_workspace is None:
+            # Auto-detect if we're in a uv workspace environment
+            is_workspace = self.workspace_detector.detect(Path.cwd())
+        else:
+            is_workspace = use_workspace
+
+        self.project_structure_setup.setup(
+            self.project_name,
+            use_workspace=is_workspace,
+            copy_pyproject=copy_pyproject,
+        )
+        log_debug_pair(
+            "✓ Project structure setup completed",
+            "✓ 项目结构设置完成",
+        )
+
+    @error_handler("Failed to initialize Rust")
+    def init_rust(self) -> None:
+        """Initialize Rust environment."""
+        log_debug_pair(
+            "Initializing Rust environment...",
+            "初始化Rust环境...",
+        )
+        self.rust_initializer.initialize()
+        log_debug_pair(
+            "✓ Rust environment initialized",
+            "✓ Rust环境初始化完成",
+        )
+
+    @error_handler("Failed to generate pyproject.toml")
+    def generate_pyproject(self) -> None:
+        """Generate pyproject.toml if it doesn't exist."""
+        if not Path("pyproject.toml").exists():
+            log_debug_pair(
+                "pyproject.toml not found, generating...",
+                "未找到 pyproject.toml，正在生成...",
+            )
+
+            # Create PyProjectGenerator instance and generate pyproject.toml
+            generator = pyproject_generator.PyProjectGenerator(self.project_name)
+            generator.set_project_info()
+            generator.set_build_system(is_rust=Path("rust").exists())
+            generator.set_development_tools()
+            generator.generate()
+
+            log_info_pair(
+                "✓ pyproject.toml generated successfully",
+                "✓ pyproject.toml 生成成功",
+            )
+        else:
+            log_debug_pair(
+                "✓ pyproject.toml already exists, skipping generation",
+                "✓ pyproject.toml 已存在，跳过生成",
+            )
+
+    @error_handler("Failed to sync Cargo.toml")
+    def sync_cargo_toml(self) -> None:
+        """Sync Cargo.toml with pyproject.toml."""
+        cargo_sync.sync_toml_files(Path("pyproject.toml"), Path("rust/Cargo.toml"))
+        log_debug("✓ rust/Cargo.toml 已成功同步和更新。")
+
+    @error_handler("Failed to create virtual environment")
+    def create_venv(self) -> None:
+        """Create the virtual environment unless a uv workspace provides one.
+
+        The former ``_create_venv_windows`` and ``_create_venv_unix`` differed
+        only in which ``VenvManager`` entry point they reached for the same
+        destination and version; that split now lives inside
+        :meth:`VenvManager.create_venv`, which takes the environment
+        explicitly.
+        """
+        log_debug_pair(
+            "Checking uv workspace status to determine if virtual environment should be created...",
+            "检查uv workspace状态以决定是否创建虚拟环境...",
+        )
+
+        if self._detect_uv_workspace():
+            log_debug_pair(
+                "✓ uv workspace environment detected, skipping local .venv creation",
+                "✓ 检测到uv workspace环境，跳过创建本地.venv",
+            )
+        else:
+            log_debug_pair(
+                "Ensuring virtual environment exists...",
+                "确保虚拟环境存在...",
+            )
+            venv_path = self.config_manager.get("venv_path", ".venv")
+            python_version = self.config_manager.get("python_version", "3.10")
+            if not self.venv_manager.create_venv(venv_path, python_version, self.env):
+                log_error_pair(
+                    "✗ Failed to create the virtual environment; "
+                    "see the warning above for details",
+                    "✗ 虚拟环境创建失败；详情见上方警告",
+                )
+                raise CommandError("uv could not create the virtual environment")
+            log_info_pair(
+                "✓ Virtual environment created successfully",
+                "✓ 虚拟环境创建成功",
+            )
+
+    def _detect_uv_workspace(self) -> bool:
+        return self.workspace_detector.detect(Path.cwd())
+
+    def is_project_initialized(self) -> bool:
+        """Check if the project is already initialized."""
+        # 检测项目是否已经初始化
+        # 检查是否存在pyproject.toml文件
+        is_pyproject_exists = Path("pyproject.toml").exists()
+
+        return is_pyproject_exists
+
+    @error_handler("Failed to update project")
+    def update_project(self) -> None:
+        """Update the project by syncing environment."""
+        # 确保项目结构（包括.wl目录）存在
+        log_debug_pair(
+            "Ensuring project structure exists...",
+            "确保项目结构存在...",
+        )
+        self.setup_project_structure()
+
+        # 确保pyproject.toml是最新的
+        self.generate_pyproject()
+
+        # 同步Cargo.toml与pyproject.toml
+        self.sync_cargo_toml()
+
+        # 同步uv环境
+        if not self.venv_manager.sync_environment():
+            log_error_pair(
+                "✗ Failed to sync environment dependencies; "
+                "see the warning above for details",
+                "✗ 环境依赖同步失败；详情见上方警告",
+            )
+            raise CommandError("uv could not sync the environment dependencies")
+
+        log_info_pair(
+            "✓ Project update completed",
+            "✓ 项目更新完成",
+        )

wl_cli/commands/initenv/services/git_lfs_initializer.py

@@ -0,0 +1,26 @@
+"""Git LFS initialization coordinator."""
+
+import os
+
+from ....utils.logging import log_info_pair
+from ..common import error_handler
+from ..components.git.git_lfs_manager import GitLFSManager
+
+
+class GitLfsInitializer:
+    """Coordinator for Git LFS initialization."""
+
+    @staticmethod
+    @error_handler("Failed to initialize Git LFS")
+    def initialize(*, auto_fix: bool = False) -> None:
+        """Initialize Git LFS."""
+        log_info_pair(
+            "=== Starting initialization of Git LFS ===", "=== 开始初始化Git LFS ==="
+        )
+
+        # Get environment
+        env = dict(os.environ)
+        initializer = GitLFSManager(env)
+        initializer.initialize(auto_fix=auto_fix)
+
+        log_info_pair("Git LFS initialization completed!", "Git LFS初始化完成!")

wl_cli/commands/initenv/services/project_structure_initializer.py

@@ -0,0 +1,52 @@
+"""Project structure initialization coordinator."""
+
+from pathlib import Path
+
+from ....utils.logging import log_info, log_info_pair
+from ..common import error_handler
+from ..components.project_structure.directory_creator import normalize_project_name
+from ..components.project_structure.setup_handler import ProjectStructureSetup
+from ..components.pyproject_generator import PyProjectGenerator
+
+
+class ProjectStructureInitializer:
+    """Coordinator for project structure initialization."""
+
+    @staticmethod
+    @error_handler("Failed to initialize project structure")
+    def initialize(workspace: bool = True) -> None:
+        """Initialize project structure.
+
+        Args:
+            workspace: If True, create workspace layout (packages/{name}/).
+                       If False, create flat layout (src/{name}/).
+        """
+        log_info_pair(
+            "=== Starting initialization of project structure ===",
+            "=== 开始初始化项目结构 ===",
+        )
+
+        project_name = Path.cwd().name
+        project_structure_setup = ProjectStructureSetup()
+        project_structure_setup.setup(
+            project_name=project_name,
+            use_workspace=workspace,
+            copy_pyproject=workspace,
+            workspace_mode=workspace,
+        )
+
+        if workspace:
+            normalized = normalize_project_name(project_name)
+            pkg_root = Path(f"packages/{normalized}")
+            pkg_pyproject = pkg_root / "pyproject.toml"
+            if not pkg_pyproject.exists():
+                has_rust = (pkg_root / "rust").exists()
+                generator = PyProjectGenerator(project_name)
+                generator.generate_package_pyproject(
+                    str(pkg_pyproject), is_rust=has_rust
+                )
+                log_info("✓ Generated package pyproject.toml")
+
+        log_info_pair(
+            "Project structure initialization completed!", "项目结构初始化完成!"
+        )