py-wlcli 0.8.0__py3-none-any.whl

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

@@ -0,0 +1,53 @@
+"""Gitignore template manager."""
+
+import shutil
+from pathlib import Path
+
+from wl_cli.utils.logging import log_info, log_info_pair
+
+
+class GitignoreManager:
+    """Manager for .gitignore template operations."""
+
+    def __init__(self, skip_remote_ops: bool = False) -> None:
+        self.skip_remote_ops = skip_remote_ops
+
+    def copy_gitignore_template(self) -> None:
+        """Copy .gitignore template from vendors to project root.
+
+        Copies the .gitignore template from the vendors directory to the
+        current working directory if no .gitignore file already exists.
+        """
+        gitignore_path = Path(".gitignore")
+
+        # Only copy if .gitignore doesn't exist and not in test environment
+        if gitignore_path.exists() or self.skip_remote_ops:
+            return
+
+        try:
+            # Calculate path to vendors/git/.gitignore relative to this file
+            template_path = (
+                Path(__file__).parent.parent.parent.parent.parent
+                / "vendors"
+                / "git"
+                / ".gitignore"
+            )
+
+            log_info(f"Looking for .gitignore template at: {template_path}")
+
+            if template_path.exists():
+                shutil.copy2(template_path, ".gitignore")
+                log_info_pair(
+                    "✓ .gitignore template copied successfully",
+                    "✓ .gitignore 模板复制成功",
+                )
+            else:
+                log_info_pair(
+                    f"Warning: .gitignore template not found at {template_path}",
+                    f"警告: 未找到 .gitignore 模板 {template_path}",
+                )
+        except Exception as e:
+            log_info_pair(
+                f"Warning: Failed to copy .gitignore template: {e}",
+                f"警告: 复制 .gitignore 模板失败: {e}",
+            )

wl_cli/commands/initenv/components/git_initializer.py

@@ -0,0 +1,212 @@
+"""Git initializer utility."""
+
+import subprocess
+from pathlib import Path
+
+from ....utils.logging import log_debug_pair, log_info, log_info_pair
+from ....utils.root import _clear_root_cache
+from ..common.check_git_bash import check_git_bash_installed
+from ..common.exceptions import GitInitError
+from .git.git_flow_manager import GitFlowManager
+from .git.gitignore_manager import GitignoreManager
+from .log_manager import performance_monitor
+
+
+class GitInitializer:
+    """Git repository initializer."""
+
+    def __init__(
+        self,
+        env: dict[str, str],
+        project_root: Path | None = None,
+        skip_remote_ops: bool = False,
+    ) -> None:
+        self.env = env
+        self.project_root = project_root or Path.cwd()
+        self.skip_remote_ops = skip_remote_ops
+        self.gitignore_manager = GitignoreManager(skip_remote_ops=skip_remote_ops)
+        self.git_flow_manager = GitFlowManager(env, skip_remote_ops=skip_remote_ops)
+
+    @performance_monitor
+    def initialize(self) -> None:
+        """
+        Initialize Git repository if it doesn't exist.
+        """
+        # Check for Git Bash (only runs on Windows)
+        check_git_bash_installed()
+
+        # Copy .gitignore template if it doesn't exist and we're not in a test environment
+        if not (self.project_root / ".gitignore").exists() and not self.skip_remote_ops:
+            self.gitignore_manager.copy_gitignore_template()
+
+        if not Path(".git").exists():
+            log_debug_pair("Initializing Git repository...", "初始化Git仓库...")
+            try:
+                if not self.git_flow_manager.git_utility.run_git_command(
+                    ["git", "init"], description="Initialize Git repository"
+                ):
+                    raise GitInitError(
+                        "Failed to initialize Git repository after multiple attempts"
+                    )
+                # The work tree did not exist a moment ago, so any DEPLOY root
+                # memoised for this directory came from the PROJECT fallback and
+                # is now wrong (it may point at a parent workspace or
+                # sub-package). Drop it so the rest of this run anchors the
+                # hooks leg at the root git just created (#103).
+                # The root module memoises every kind in one cache, including the
+                # negative answer (#113 User Story 17: "not found" is a cacheable
+                # answer, so a ``None`` asked for before this ``git init`` would
+                # otherwise stick for the whole process). This is the *only*
+                # invalidator now: the per-resolver clearers were deleted along
+                # with the resolvers themselves in #123.
+                _clear_root_cache()
+                log_info_pair("✓ Git repository initialized", "✓ Git仓库初始化完成")
+            except Exception as e:
+                log_info_pair(
+                    "Warning: Failed to initialize Git repository",
+                    "警告: 初始化Git仓库失败",
+                )
+                raise GitInitError(f"Failed to initialize Git repository: {e}")
+        else:
+            log_debug_pair(
+                "Git repository already exists, skipping initialization",
+                "Git仓库已存在，跳过初始化",
+            )
+
+            # Update repository if it already exists (skip during tests)
+            if not self.skip_remote_ops:
+                self.update_repository()
+
+        # Setup Git Flow branches (main, develop, features) and switch to features
+        if not self.skip_remote_ops:
+            try:
+                self.git_flow_manager.setup_git_flow_branches()
+            except Exception as e:
+                log_info_pair(
+                    f"Warning: Failed to setup Git Flow branches: {e}",
+                    f"警告: 设置Git Flow分支失败: {e}",
+                )
+                # Continue execution even if Git Flow setup fails
+
+    def setup_git_flow_branches(self, work_type: str) -> None:
+        """Setup Git Flow branches based on work type."""
+        self.git_flow_manager.setup_git_flow_branches_by_work_type(work_type)
+
+    def update_repository(self) -> None:
+        """Update the repository by pulling latest changes from all important branches.
+
+        This method:
+        1. Updates the main branch
+        2. Updates the develop branch
+        3. Updates all feature branches (skipped in test environments)
+        4. Switches back to the develop branch
+        """
+        log_info_pair("Updating repository...", "更新仓库...")
+
+        # Update main branch
+        log_info_pair("Updating main branch...", "更新main分支...")
+        self._update_branch("main")
+
+        # Update develop branch
+        log_info_pair("Updating develop branch...", "更新develop分支...")
+        self._update_branch("develop")
+
+        # Update all feature branches - skip in test environment to speed up tests
+        if not self.skip_remote_ops:
+            self._update_feature_branches()
+
+        # Switch back to develop branch as a safe default
+        log_info("Switching back to develop branch...")
+        self.git_flow_manager.git_utility.run_git_command(
+            ["git", "checkout", "develop"], description="Switch to develop branch"
+        )
+
+    def _update_branch(self, branch_name: str) -> bool:
+        """
+        Update a specific git branch.
+
+        Args:
+            branch_name: Name of the branch to update
+
+        Returns:
+            bool: True if branch was updated successfully
+        """
+        success = False
+
+        if self.git_flow_manager.git_utility.run_git_command(
+            ["git", "fetch", "origin", branch_name],
+            description=f"Fetch {branch_name} branch",
+        ):
+            if self.git_flow_manager.git_utility.run_git_command(
+                ["git", "checkout", branch_name],
+                description=f"Checkout {branch_name} branch",
+            ):
+                if self.git_flow_manager.git_utility.run_git_command(
+                    ["git", "pull", "origin", branch_name],
+                    description=f"Pull {branch_name} branch",
+                ):
+                    log_info_pair(
+                        f"✓ {branch_name} branch updated successfully",
+                        f"✓ {branch_name}分支更新完成",
+                    )
+                    success = True
+
+        return success
+
+    def _update_feature_branches(self) -> None:
+        """
+        Update all feature branches in the repository.
+        """
+        log_info_pair(
+            "Updating all feature branches...", "拉取所有feature分支最新变更..."
+        )
+
+        try:
+            # Get all remote feature branches
+            result = subprocess.run(
+                ["git", "branch", "-r"],
+                check=True,
+                capture_output=True,
+                env=self.env,
+                text=True,
+            )
+
+            # Parse feature branches
+            feature_branches = [
+                line.strip()
+                for line in result.stdout.split("\n")
+                if line.strip().startswith("origin/feature/")
+            ]
+
+            # Update each feature branch
+            success_count = 0
+            for branch in feature_branches:
+                branch_name = branch.replace("origin/", "")
+                log_info_pair(f"Updating {branch_name}...", f"拉取{branch_name}...")
+
+                if self.git_flow_manager.git_utility.run_git_command(
+                    ["git", "fetch", "origin", branch_name],
+                    description=f"Fetch {branch_name}",
+                ):
+                    success_count += 1
+
+            # Report results
+            if feature_branches:
+                total_count = len(feature_branches)
+                log_info_pair(
+                    f"✓ Updated {success_count}/{total_count} feature branches",
+                    f"✓ 已更新 {success_count}/{total_count} 个feature分支",
+                )
+            else:
+                log_info_pair("✓ No feature branches found", "✓ 未找到feature分支")
+
+        except subprocess.CalledProcessError as e:
+            log_info_pair(
+                f"Warning: Failed to list feature branches: {e.stderr}",
+                f"警告: 列出feature分支失败: {e.stderr}",
+            )
+        except Exception as e:
+            log_info_pair(
+                f"Warning: Failed to update feature branches: {e}",
+                f"警告: 更新feature分支失败: {e}",
+            )

wl_cli/commands/initenv/components/i18n_manager.py

@@ -0,0 +1,104 @@
+"""Internationalization manager utility."""
+
+
+class I18nManager:
+    """Manager for internationalization support."""
+
+    def __init__(self, default_lang: str = "en") -> None:
+        self.default_lang = default_lang
+        self.current_lang = default_lang
+        self.translations: dict[str, dict[str, str]] = {}
+        self._load_default_translations()
+
+    def _load_default_translations(self) -> None:
+        """Load default translations."""
+        # Default translations for initenv module
+        default_translations = {
+            "git_init_start": {
+                "en": "Initializing Git repository...",
+                "zh": "初始化Git仓库...",
+            },
+            "git_init_success": {
+                "en": "✓ Git repository initialized",
+                "zh": "✓ Git仓库初始化完成",
+            },
+            "git_init_skip": {
+                "en": "Git repository already exists, skipping initialization",
+                "zh": "Git仓库已存在，跳过初始化",
+            },
+            "git_init_fail": {
+                "en": "Warning: Failed to initialize Git repository",
+                "zh": "警告: 初始化Git仓库失败",
+            },
+            "project_structure_start": {
+                "en": "Setting up project structure...",
+                "zh": "设置项目结构...",
+            },
+            "project_structure_success": {
+                "en": "✓ Project structure created successfully",
+                "zh": "✓ 项目结构创建成功",
+            },
+            "project_structure_fail": {
+                "en": "Warning: Failed to setup project structure",
+                "zh": "警告: 设置项目结构失败",
+            },
+            "rust_init_start": {
+                "en": "Initializing Rust environment...",
+                "zh": "初始化Rust环境...",
+            },
+            "rust_init_success": {
+                "en": "✓ Rust project initialized successfully",
+                "zh": "✓ Rust项目初始化成功",
+            },
+            "rust_init_fail": {
+                "en": "Warning: Failed to initialize Rust environment",
+                "zh": "警告: 初始化Rust环境失败",
+            },
+            "venv_create_start": {
+                "en": "Creating virtual environment...",
+                "zh": "创建虚拟环境...",
+            },
+            "venv_create_success": {
+                "en": "✓ Virtual environment created successfully",
+                "zh": "✓ 虚拟环境创建成功",
+            },
+            "venv_create_fail": {
+                "en": "Warning: Failed to create virtual environment",
+                "zh": "警告: 创建虚拟环境失败",
+            },
+            "init_complete": {
+                "en": "Project environment initialization completed!",
+                "zh": "项目环境初始化完成!",
+            },
+        }
+
+        for key, translations in default_translations.items():
+            self.add_translation(key, translations)
+
+    def add_translation(self, key: str, translations: dict[str, str]) -> None:
+        """Add translation for a key."""
+        self.translations[key] = translations
+
+    def get_text(self, key: str, lang: str | None = None) -> str:
+        """Get translated text by key."""
+        if key not in self.translations:
+            return key
+
+        target_lang = lang or self.current_lang
+        translations = self.translations[key]
+
+        if target_lang in translations:
+            return translations[target_lang]
+
+        if self.default_lang in translations:
+            return translations[self.default_lang]
+
+        # Return first available translation
+        if translations:
+            return next(iter(translations.values()))
+
+        return key
+
+    def t(self, key: str, lang: str | None = None) -> str:
+        """Shortcut for get_text."""
+        return self.get_text(key, lang)

wl_cli/commands/initenv/components/log_manager.py

@@ -0,0 +1,241 @@
+"""Log manager utility for initenv module."""
+
+import time
+from collections.abc import Callable
+from functools import wraps
+from typing import Any
+
+from ....utils.log_levels import LogLevel
+from ....utils.logging import (
+    StructuredLogger,
+    clear_log_context,
+    get_logger,
+    log_debug,
+    log_error,
+    log_exception,
+    log_info,
+    log_warning,
+    pop_log_context,
+    push_log_context,
+)
+from ....utils.logging import configure_logging as global_configure_logging
+
+
+class LogManager:
+    """Manager for logging with levels - now using unified logging system."""
+
+    def __init__(self, name: str = "initenv") -> None:
+        self.logger: StructuredLogger = get_logger(name)
+        # Set default log level to INFO to match test expectations
+        self.logger.min_level = LogLevel.INFO
+
+    def info(self, message: str, lang: str = "en", **kwargs) -> None:
+        """Log info message."""
+        log_info(message, lang=lang, **kwargs)
+
+    def warning(self, message: str, **kwargs) -> None:
+        """Log warning message."""
+        log_warning(message, **kwargs)
+
+    def error(self, message: str, **kwargs) -> None:
+        """Log error message."""
+        log_error(message, **kwargs)
+
+    def debug(self, message: str, **kwargs) -> None:
+        """Log debug message."""
+        log_debug(message, **kwargs)
+
+    def push_context(self, **context) -> None:
+        """Push context to the logger's context stack."""
+        if hasattr(self.logger, "push_context"):
+            self.logger.push_context(**context)
+        else:
+            push_log_context(**context)
+
+    def pop_context(self) -> dict[str, Any] | None:
+        """Pop context from the logger's context stack."""
+        if hasattr(self.logger, "pop_context"):
+            return self.logger.pop_context()
+        else:
+            return pop_log_context()
+
+    def clear_context(self) -> None:
+        """Clear all context from the logger's context stack."""
+        if hasattr(self.logger, "clear_context"):
+            self.logger.clear_context()
+        else:
+            clear_log_context()
+
+    @staticmethod
+    def configure_logging(**kwargs) -> None:
+        """
+        Configure logging based on command-line arguments.
+
+        Args:
+            **kwargs: Command-line arguments including logging configuration
+        """
+        from wl_cli.utils.config import get_config_manager
+
+        config_manager = get_config_manager()
+
+        # Get logging configuration from kwargs
+        log_level = kwargs.get("log_level")
+        log_console = kwargs.get("log_console")
+        log_file = kwargs.get("log_file")
+        log_format = kwargs.get("log_format")
+        log_rotation = kwargs.get("log_rotation")
+
+        # Update configuration
+        config_updates = {}
+        if log_level:
+            config_updates["log_level"] = log_level
+        if log_console is not None:
+            config_updates["log_console"] = log_console
+        if log_file:
+            config_updates["log_file"] = log_file
+        if log_format:
+            config_updates["log_file_format"] = log_format
+        if log_rotation:
+            config_updates["log_max_size"] = log_rotation
+
+        # Apply configuration updates
+        for key, value in config_updates.items():
+            config_manager.set(key, value)
+
+        # Configure the global logger
+        if config_updates:
+            global_configure_logging(config_updates)
+
+    @staticmethod
+    def get_logger(
+        name: str = "initenv", config: dict[str, Any] | None = None
+    ) -> StructuredLogger:
+        """
+        Get a logger instance with the specified name and configuration.
+
+        Args:
+            name (str): Logger name.
+            config (Optional[Dict[str, Any]]): Logger configuration.
+
+        Returns:
+            StructuredLogger: Logger instance.
+        """
+        return get_logger(name, config)
+
+
+def performance_monitor(func: Callable[..., Any]) -> Callable[..., Any]:
+    """Decorator to monitor function execution time and add context."""
+
+    @wraps(func)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        # Add function context
+        context = {"function": func.__name__, "module": func.__module__}
+        push_log_context(**context)
+
+        start_time = time.time()
+        log_info(f"Starting {func.__name__}...")
+
+        try:
+            result = func(*args, **kwargs)
+            end_time = time.time()
+            execution_time = end_time - start_time
+            log_info(
+                f"Finished {func.__name__} in {execution_time:.2f} seconds",
+                duration=execution_time,
+                result="success",
+            )
+            return result
+        except Exception as e:
+            end_time = time.time()
+            execution_time = end_time - start_time
+            log_exception(
+                f"Error in {func.__name__} after {execution_time:.2f} seconds",
+                exc_info=e,
+                duration=execution_time,
+                result="error",
+            )
+            raise
+        finally:
+            pop_log_context()
+
+    return wrapper
+
+
+def log_context(**context) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    """Decorator to add context to log messages."""
+
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        @wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            push_log_context(**context)
+            try:
+                return func(*args, **kwargs)
+            finally:
+                pop_log_context()
+
+        return wrapper
+
+    return decorator
+
+
+def error_handler(func: Callable[..., Any]) -> Callable[..., Any]:
+    """Decorator to handle and log errors."""
+
+    @wraps(func)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            log_exception(f"Error in {func.__name__}", exc_info=e)
+            raise
+
+    return wrapper
+
+
+def debug_only(func: Callable[..., Any]) -> Callable[..., Any]:
+    """Decorator to only execute function in debug mode."""
+
+    @wraps(func)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        logger = get_logger(func.__module__)
+        if logger.min_level <= LogLevel.DEBUG:
+            return func(*args, **kwargs)
+        return None
+
+    return wrapper
+
+
+def timed_operation(
+    description: str,
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    """Decorator to time and log an operation with a description."""
+
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        @wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            start_time = time.time()
+            log_info(f"Starting {description}...")
+            try:
+                result = func(*args, **kwargs)
+                end_time = time.time()
+                execution_time = end_time - start_time
+                log_info(
+                    f"Finished {description} in {execution_time:.2f} seconds",
+                    duration=execution_time,
+                    operation=description,
+                )
+                return result
+            except Exception as e:
+                end_time = time.time()
+                execution_time = end_time - start_time
+                log_exception(
+                    f"Error in {description} after {execution_time:.2f} seconds",
+                    exc_info=e,
+                    duration=execution_time,
+                    operation=description,
+                )
+                raise
+
+        return wrapper
+
+    return decorator

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

@@ -0,0 +1,23 @@
+"""Project structure utilities package."""
+
+from .directory_creator import (
+    _create_init_files,
+    _create_readme,
+    _create_required_directories,
+    _normalize_project_name,
+    normalize_project_name,
+    setup_project_structure,
+)
+from .hooks_manager import sync_hooks
+from .setup_handler import ProjectStructureSetup
+
+__all__ = [
+    "ProjectStructureSetup",
+    "setup_project_structure",
+    "sync_hooks",
+    "_create_required_directories",
+    "_create_init_files",
+    "_create_readme",
+    "_normalize_project_name",
+    "normalize_project_name",
+]