py-wlcli 0.8.0__py3-none-any.whl

wl_cli/commands/clean/utils/__init__.py

@@ -0,0 +1,34 @@
+"""
+Clean command utilities package
+
+Note: This package is kept for backward compatibility.
+New code should import directly from the modules at the clean package level:
+- wl_cli.commands.clean.core
+- wl_cli.commands.clean.python
+- wl_cli.commands.clean.rust
+- wl_cli.commands.clean.venv
+- wl_cli.commands.clean.build
+- wl_cli.commands.clean.lfs
+"""
+
+from ..core import remove_directories, remove_files
+from ..python import remove_egg_info_dirs, remove_log_files, remove_pycache_dirs
+from ..rust import clean_rust_artifacts, remove_rust_analyzer_dirs
+from ..venv import (
+    remove_auto_activation_scripts,
+    remove_uv_lock,
+    remove_virtual_environments,
+)
+
+__all__ = [
+    "remove_directories",
+    "remove_files",
+    "remove_log_files",
+    "remove_pycache_dirs",
+    "remove_egg_info_dirs",
+    "remove_rust_analyzer_dirs",
+    "clean_rust_artifacts",
+    "remove_virtual_environments",
+    "remove_auto_activation_scripts",
+    "remove_uv_lock",
+]

wl_cli/commands/clean/venv.py

@@ -0,0 +1,91 @@
+"""
+Virtual environment cleaning utilities for clean command.
+"""
+
+import os
+import shutil
+
+from wl_cli.utils.logging import log_info_pair
+
+
+def remove_virtual_environments(dry_run: bool = False) -> None:
+    """
+    Remove virtual environments
+    删除虚拟环境
+    """
+    venv_dirs = [".venv", "venv"]
+    for venv_dir in venv_dirs:
+        if os.path.exists(venv_dir):
+            try:
+                if dry_run:
+                    log_info_pair(
+                        f"Would remove virtual environment directory: {venv_dir}",
+                        f"将删除虚拟环境目录: {venv_dir}",
+                    )
+                else:
+                    shutil.rmtree(venv_dir)
+                    log_info_pair(
+                        f"Removed virtual environment directory: {venv_dir}",
+                        f"已删除虚拟环境目录: {venv_dir}",
+                    )
+            except Exception as e:
+                log_info_pair(
+                    f"Failed to remove virtual environment {venv_dir}: {e}",
+                    f"删除虚拟环境 {venv_dir} 失败: {e}",
+                )
+        else:
+            log_info_pair(
+                f"Virtual environment directory {venv_dir} does not exist, skipping...",
+                f"虚拟环境目录 {venv_dir} 不存在，跳过...",
+            )
+
+
+def remove_auto_activation_scripts(dry_run: bool = False) -> None:
+    """
+    Remove auto-activation scripts
+    删除自动激活脚本
+    """
+    auto_activate_scripts = ["auto_activate_venv.bat", "auto_activate_venv.sh"]
+    for script in auto_activate_scripts:
+        if os.path.exists(script):
+            try:
+                if dry_run:
+                    log_info_pair(
+                        f"Would remove auto-activation script: {script}",
+                        f"将删除自动激活脚本: {script}",
+                    )
+                else:
+                    os.remove(script)
+                    log_info_pair(
+                        f"Removed auto-activation script: {script}",
+                        f"已删除自动激活脚本: {script}",
+                    )
+            except Exception as e:
+                log_info_pair(
+                    f"Failed to remove auto-activation script {script}: {e}",
+                    f"删除自动激活脚本 {script} 失败: {e}",
+                )
+
+
+def remove_uv_lock(dry_run: bool = False) -> None:
+    """
+    Remove uv.lock file
+    删除uv.lock文件
+    """
+    uv_lock_file = "uv.lock"
+    if os.path.exists(uv_lock_file):
+        try:
+            if dry_run:
+                log_info_pair(
+                    f"Would remove {uv_lock_file} file", f"将删除 {uv_lock_file} 文件"
+                )
+            else:
+                os.remove(uv_lock_file)
+                log_info_pair(
+                    f"Removed {uv_lock_file} file", f"已删除 {uv_lock_file} 文件"
+                )
+        except Exception as e:
+            log_info_pair(
+                f"Failed to remove {uv_lock_file} file: {e}",
+                f"删除 {uv_lock_file} 文件失败: {e}",
+            )

wl_cli/commands/cleanup.py

@@ -0,0 +1,73 @@
+"""Shortcut command for dead code cleanup."""
+
+import sys
+from typing import Any, cast
+
+import click
+
+from wl_cli.commands import Command, validate_command_args
+from wl_cli.commands.clean.dead_code.dead_code_command import DeadCodeCommand
+
+
+class CleanupCommand(Command):
+    """Run dead code cleanup."""
+
+    @property
+    def name(self) -> str:
+        return "cleanup"
+
+    @property
+    def help(self) -> str:
+        return "Run dead-code cleanup"
+
+    @validate_command_args()
+    def execute(
+        self,
+        dry_run: bool = False,
+        scan_only: bool = False,
+        json: bool = False,
+        **kwargs: Any,
+    ) -> int:
+        _ = kwargs
+        command = DeadCodeCommand()
+        scan_without_fixing = dry_run or scan_only
+
+        return cast(
+            "int",
+            command.run(
+                dry_run=scan_without_fixing,
+                json=json,
+            ),
+        )
+
+
+@click.command()
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    help="Only scan without fixing",
+)
+@click.option(
+    "--scan-only",
+    is_flag=True,
+    help="Same as --dry-run",
+)
+@click.option(
+    "--json",
+    is_flag=True,
+    help="Output JSON format",
+)
+def cleanup_command(
+    dry_run: bool,
+    scan_only: bool,
+    json: bool,
+) -> None:
+    """Cleanup command Click wrapper."""
+    cmd = CleanupCommand()
+    result = cmd.execute(
+        dry_run=dry_run,
+        scan_only=scan_only,
+        json=json,
+    )
+    if result:
+        sys.exit(result)

wl_cli/commands/click_base.py

@@ -0,0 +1,79 @@
+"""Click-based command base class for WL Commands."""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class ClickCommandBase(ABC):
+    """Pure Click-style command base class.
+
+    Replaces argparse-style CommandBase with Click-native decorator pattern.
+    """
+
+    def __init__(self, **dependencies: Any) -> None:
+        """Initialize the command with dependencies.
+
+        Args:
+            **dependencies: Dependencies for the command
+        """
+        self._dependencies = dependencies
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Get the command name."""
+        pass
+
+    @property
+    def help(self) -> str:
+        """Get the command help text."""
+        return f"{self.name} command"
+
+    @property
+    def aliases(self) -> list[str]:
+        """Get command aliases."""
+        return []
+
+    @abstractmethod
+    def execute(self, **kwargs: Any) -> None:
+        """Execute the command with Click-passed kwargs."""
+        pass
+
+    def before_execute(self, **kwargs: Any) -> None:
+        """Lifecycle hook called before execution."""
+        return None
+
+    def after_execute(self, result: Any = None) -> None:
+        """Lifecycle hook called after execution."""
+        return None
+
+    def run(self, **kwargs: Any) -> Any:
+        """Run with lifecycle and error handling around execute."""
+        try:
+            validated_kwargs = self.validate_args(**kwargs)
+            self.before_execute(**validated_kwargs)
+            result = self.execute(**validated_kwargs)
+            self.after_execute(result)
+            return result
+        except Exception as error:
+            self.handle_error(error)
+            raise
+
+    def validate_args(self, **kwargs: Any) -> dict[str, Any]:
+        """Validate command arguments."""
+        return kwargs
+
+    def handle_error(self, error: Exception) -> None:
+        """Default error handler; override for custom behavior."""
+        raise error
+
+    def log_info(self, en_msg: str, zh_msg: str | None = None) -> None:
+        """Log messages in English and optionally Chinese."""
+        try:
+            from wl_cli.utils.logging import log_info
+
+            log_info(en_msg, lang="en")
+            if zh_msg is not None:
+                log_info(zh_msg, lang="zh")
+        except Exception:
+            pass

wl_cli/commands/config/__init__.py

@@ -0,0 +1 @@
+"""Config commands package."""

wl_cli/commands/config/config.py

@@ -0,0 +1,291 @@
+"""Config command using Click decorators.
+
+Examples:
+    wl config list
+    wl config get log_level
+    wl config set log_level DEBUG
+    wl config set log_console true
+    wl config set language en       # Only show English messages
+    wl config set language zh       # Only show Chinese messages
+    wl config set language auto     # Show messages based on system language (default)
+    wl config log get log_level
+    wl config log set log_level DEBUG
+    wl config log list
+    wl config log reset
+"""
+
+import click
+
+from ...utils.config import get_config_manager
+from ...utils.config.defaults import RUNTIME_DERIVED_KEYS
+from ...utils.logging import log_error_pair
+
+# CLI usage errors (``click.UsageError``, exit code 2) are deliberately
+# English-only, whatever the ``language`` setting says (#198). Click frames
+# them with its own English ``Usage:``/``Error:`` text, they are consumed by
+# scripts and terminals rather than by a reader, and Click's built-in errors
+# (unknown option, missing argument) are English too -- translating only the
+# messages below would leave a mixed-language error page. Operational
+# failures that carry advice still go through ``log_error_pair`` (see the
+# save-failure path), which honours ``WL_LANGUAGE``.
+
+
+class ConfigCommand:
+    """Implementation of the config command."""
+
+    @property
+    def name(self) -> str:
+        return "config"
+
+    @property
+    def help(self) -> str:
+        return "Manage wl configuration"
+
+    def _handle_get_action(self, config_manager, key: str | None):
+        """Handle the 'get' action."""
+        if not key:
+            # A validation failure is a failed command: click.UsageError exits
+            # non-zero and writes the message to stderr, like the save-failure
+            # path below (#194).
+            raise click.UsageError("key is required for get action")
+
+        value = config_manager.get(key)
+        if value is not None:
+            print(f"{key} = {value}")
+        else:
+            print(f"{key} is not set")
+
+    def _handle_set_action(self, config_manager, key: str | None, value: str | None):
+        """Handle the 'set' action."""
+        if not key or value is None:
+            raise click.UsageError("both key and value are required for set action")
+
+        if key == "language" and value not in ["en", "zh", "auto"]:
+            raise click.UsageError("language must be one of 'en', 'zh', or 'auto'")
+
+        converted_value = self._convert_value(value)
+        if not config_manager.set(key, converted_value):
+            # A failed write is a failed command: report it in both languages and
+            # exit non-zero instead of claiming "Set ..." (#177).
+            log_error_pair(
+                f"Failed to save configuration '{key}' to {config_manager.config_file}",
+                f"无法将配置 '{key}' 保存到 {config_manager.config_file}",
+            )
+            raise SystemExit(1)
+        print(f"Set {key} = {converted_value}")
+
+    def _handle_list_action(self, config_manager):
+        """Handle the 'list' action."""
+        all_config = config_manager.get_all()
+        if all_config:
+            print("Current configuration:")
+            for k, v in all_config.items():
+                print(f"  {k} = {v}")
+        else:
+            print("No configuration values set")
+
+    def _handle_reset_action(self, config_manager):
+        """Handle the 'reset' action.
+
+        Runtime-derived keys are *removed*, not reset to their default: the
+        default is a derivation of the running process, and writing it back
+        would re-freeze the value #208 keeps out of the file (#208).
+        """
+        default_config = config_manager._get_default_config()
+        saved = True
+        for key in config_manager.get_all():
+            if key not in default_config:
+                saved = config_manager.set(key, None) and saved
+
+        for key, value in default_config.items():
+            if key in RUNTIME_DERIVED_KEYS:
+                continue
+            saved = config_manager.set(key, value) and saved
+
+        for key in sorted(RUNTIME_DERIVED_KEYS):
+            saved = config_manager.unset(key) and saved
+
+        if not saved:
+            log_error_pair(
+                "Failed to reset configuration: some values could not be saved",
+                "重置配置失败：部分配置值无法保存",
+            )
+            raise SystemExit(1)
+
+        print("Configuration reset to default values")
+
+    def _handle_log_list_action(self, config_manager):
+        """Handle the 'log list' action."""
+        all_config = config_manager.get_all()
+        log_config = {k: v for k, v in all_config.items() if k.startswith("log_")}
+        if log_config:
+            print("Current log configuration:")
+            for k, v in log_config.items():
+                print(f"  {k} = {v}")
+        else:
+            print("No log configuration values set")
+
+    def _handle_log_reset_action(self, config_manager):
+        """Handle the 'log reset' action."""
+        default_config = config_manager._get_default_config()
+        saved = True
+        for key in config_manager.get_all():
+            if key.startswith("log_") and key not in default_config:
+                saved = config_manager.set(key, None) and saved
+
+        for key, value in default_config.items():
+            if key.startswith("log_"):
+                saved = config_manager.set(key, value) and saved
+
+        if not saved:
+            log_error_pair(
+                "Failed to reset log configuration: some values could not be saved",
+                "重置日志配置失败：部分配置值无法保存",
+            )
+            raise SystemExit(1)
+
+        print("Log configuration reset to default values")
+
+    def _convert_value(self, value: str):
+        """Convert string value to appropriate type."""
+        if value.lower() in ("none", "null"):
+            return None
+
+        if value.lower() in ("true", "false"):
+            return value.lower() == "true"
+
+        try:
+            return int(value)
+        except ValueError:
+            pass
+
+        try:
+            return float(value)
+        except ValueError:
+            pass
+
+        return value
+
+    def execute(
+        self,
+        config_action: str | None = None,
+        key: str | None = None,
+        value: str | None = None,
+        log_action: str | None = None,
+        **kwargs,
+    ) -> None:
+        """Execute config command."""
+        config_manager = get_config_manager()
+
+        if config_action == "get":
+            self._handle_get_action(config_manager, key)
+
+        elif config_action == "set":
+            self._handle_set_action(config_manager, key, value)
+
+        elif config_action == "list":
+            self._handle_list_action(config_manager)
+
+        elif config_action == "reset":
+            self._handle_reset_action(config_manager)
+
+        elif config_action == "log_list":
+            self._handle_log_list_action(config_manager)
+
+        elif config_action == "log_reset":
+            self._handle_log_reset_action(config_manager)
+
+        elif config_action == "log":
+            if log_action == "get":
+                self._handle_get_action(config_manager, key)
+            elif log_action == "set":
+                self._handle_set_action(config_manager, key, value)
+            elif log_action == "list":
+                self._handle_log_list_action(config_manager)
+            elif log_action == "reset":
+                self._handle_log_reset_action(config_manager)
+            else:
+                # Unreachable through Click: no subcommand passes a "log"
+                # config_action any more. Raised rather than printed into a
+                # wide-open exit 0, which would report failure as success
+                # (#198).
+                raise AssertionError(
+                    f"unreachable log action branch: log_action={log_action!r}"
+                )
+
+        else:
+            # Unreachable through Click: every subcommand passes one of the
+            # actions handled above. Same reasoning as the log branch (#198).
+            raise AssertionError(
+                f"unreachable config action branch: config_action={config_action!r}"
+            )
+
+
+@click.group()
+def config_command():
+    """Manage wl configuration."""
+    pass
+
+
+@config_command.command()
+@click.argument("key")
+def get(key: str):
+    """Get a configuration value."""
+    cmd = ConfigCommand()
+    cmd.execute(config_action="get", key=key)
+
+
+@config_command.command()
+@click.argument("key")
+@click.argument("value")
+def set(key: str, value: str):
+    """Set a configuration value."""
+    cmd = ConfigCommand()
+    cmd.execute(config_action="set", key=key, value=value)
+
+
+@config_command.command(name="list-config")
+@click.pass_context
+def list_config(ctx: click.Context):
+    """List all configuration values."""
+    cmd = ConfigCommand()
+    cmd.execute(config_action="list")
+
+
+@config_command.command()
+@click.pass_context
+def reset(ctx: click.Context):
+    """Reset configuration to default values."""
+    cmd = ConfigCommand()
+    cmd.execute(config_action="reset")
+
+
+@config_command.command()
+@click.argument("key")
+def log_get(key: str):
+    """Get a log configuration value."""
+    cmd = ConfigCommand()
+    cmd.execute(config_action="get", key=key)
+
+
+@config_command.command()
+@click.argument("key")
+@click.argument("value")
+def log_set(key: str, value: str):
+    """Set a log configuration value."""
+    cmd = ConfigCommand()
+    cmd.execute(config_action="set", key=key, value=value)
+
+
+@config_command.command(name="log-list")
+def log_list():
+    """List all log configuration values."""
+    cmd = ConfigCommand()
+    cmd.execute(config_action="log_list")
+
+
+@config_command.command(name="log-reset")
+def log_reset():
+    """Reset log configuration to default values."""
+    cmd = ConfigCommand()
+    cmd.execute(config_action="log_reset")

wl_cli/commands/debug/__init__.py

@@ -0,0 +1,6 @@
+"""wl-debug command module - code quality validation."""
+
+from .debug import DebugCommand, debug_command
+from .debug_subagent import DebugSubagent, ErrorInfo, FixResult
+
+__all__ = ["DebugCommand", "debug_command", "DebugSubagent", "ErrorInfo", "FixResult"]