py-wlcli 0.8.0__py3-none-any.whl

wl_cli/cli_click.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+"""Command line interface entry point based on Click."""
+
+import importlib
+import sys
+
+import click
+
+from . import __version__
+from .commands.registry import COMMAND_TABLE
+from .utils.logging import log_error
+from .utils.wl_dir_updater import check_and_update_wl_dir
+
+#: Command prefixes that own their stdout stream (JSON / JSON-RPC).
+#: The startup ``.wl`` self-sync logs INFO lines on stdout, which would corrupt
+#: those payloads, so the dispatcher skips the sync for these commands (#220).
+#: The ``cc`` write commands are listed individually: ``cc init --json`` and
+#: friends emit one envelope line just like ``cc check`` (#223).
+_SYNC_SKIP_PREFIXES: tuple[tuple[str, ...], ...] = (
+    ("env", "check"),
+    ("cc", "check"),
+    ("cc", "init"),
+    ("cc", "repair"),
+    ("cc", "upgrade"),
+    ("cc", "plugins"),
+    ("cc", "mcp"),
+    ("cc", "settings"),
+    ("cc", "statusline"),
+    ("cc", "hooks"),
+    ("cc", "stamps"),
+    ("self", "capabilities"),
+    ("mcp", "serve"),
+)
+
+#: Raw argv of the current :func:`main` invocation. Click resolves and consumes
+#: the subcommand tokens before the group callback runs (``ctx.args`` is empty),
+#: so ``main`` records them here for :func:`should_skip_wl_sync`. Direct ``wl``
+#: invocations (tests) leave this empty, which means "run the sync".
+_INVOCATION_ARGV: list[str] = []
+
+
+def should_skip_wl_sync(argv: list[str]) -> bool:
+    """Return True when the startup ``.wl`` self-sync must be skipped.
+
+    Read-only commands that emit machine-readable output on stdout
+    (``wl env check --json``, ``wl self capabilities``, ``wl mcp serve``)
+    cannot tolerate the sync's INFO logging on the same stream. This is a
+    pure argv predicate: no command business logic belongs here.
+
+    Args:
+        argv: Raw argv handed to ``wl``, without the program name.
+
+    Returns:
+        True if ``argv`` starts with one of the read-only command prefixes.
+    """
+    return any(tuple(argv[: len(prefix)]) == prefix for prefix in _SYNC_SKIP_PREFIXES)
+
+
+@click.group(
+    invoke_without_command=True,
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+@click.option("--version", "-v", is_flag=True, help="Show version information")
+def wl(version):
+    """WL Commands - A command-line tool for project management."""
+    ctx = click.get_current_context()
+
+    if version:
+        click.echo(f"wl {__version__}")
+        ctx.exit(0)
+
+    if not should_skip_wl_sync(_INVOCATION_ARGV):
+        check_and_update_wl_dir()
+
+    if ctx.invoked_subcommand is None:
+        click.echo(ctx.get_help())
+
+
+def _register_click_command(
+    name: str, click_func, aliases: list[str] | None = None
+) -> None:
+    """Register a Click command function with the wl group.
+
+    Aliases register the *same* Click object under a second name (Click keeps
+    the object's own ``name`` untouched), so an alias accepts exactly the
+    canonical command's options, arguments and subcommands. A zero-option
+    wrapper shell would reject every parameter an alias was given (#194).
+
+    Args:
+        name: Command name
+        click_func: Click command function
+        aliases: List of command aliases
+    """
+    wl.add_command(click_func, name=name)
+    for alias in aliases or ():
+        wl.add_command(click_func, name=alias)
+
+
+def setup_commands():
+    """Register every command on the ``wl`` group from COMMAND_TABLE.
+
+    Each module in the table is imported exactly once; the symbol named by the
+    spec is fetched and, when the spec asks for it, instantiated. The command is
+    then registered under its canonical name plus any live aliases.
+    """
+    try:
+        if not hasattr(wl, "_commands_setup") or not wl._commands_setup:
+            for name, spec in COMMAND_TABLE.items():
+                module = importlib.import_module(f"{spec.package}.{spec.module_path}")
+                click_func = getattr(module, spec.symbol)
+                if spec.instantiate:
+                    click_func = click_func()
+                _register_click_command(name, click_func, aliases=list(spec.aliases))
+
+            wl._commands_setup = True
+    except Exception as e:
+        log_error(f"Error setting up commands: {e}")
+        raise
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Main entry point for the CLI.
+
+    Args:
+        argv: Command line arguments
+
+    Returns:
+        int: Exit code, 0 for success, 1 for failure
+    """
+    global _INVOCATION_ARGV
+
+    if argv is None:
+        argv = sys.argv[1:]
+
+    if argv and (argv[0] == "--version" or argv[0] == "-v"):
+        click.echo(f"wl {__version__}")
+        raise SystemExit(0)
+
+    _INVOCATION_ARGV = list(argv)
+    try:
+        setup_commands()
+        wl.main(args=argv, standalone_mode=True)
+        return 0
+    except click.ClickException as e:
+        log_error(str(e))
+        return 1
+    except Exception as e:
+        log_error(str(e))
+        return 1
+    finally:
+        # Never leak one invocation's argv into a later in-process invocation.
+        _INVOCATION_ARGV = []
+
+
+if __name__ == "__main__":
+    sys.exit(main())

wl_cli/commands/__init__.py

@@ -0,0 +1,84 @@
+"""Command registration and management module."""
+
+import functools
+from collections.abc import Callable
+from typing import Any
+
+from ..exceptions import ErrorCode
+from .base import CommandBase
+from .registry import get_command, list_commands
+
+
+class Command(CommandBase):
+    """
+    Base class for all commands.
+    """
+
+    def __init__(self, **dependencies: Any) -> None:
+        super().__init__(**dependencies)
+
+    @property
+    def name(self) -> str:
+        """
+        Get the command name.
+
+        Returns:
+            str: The command name
+        """
+        raise NotImplementedError("Command subclasses must implement name property")
+
+    @property
+    def help(self) -> str:
+        """
+        Get the command help text.
+
+        Returns:
+            str: The command help text
+        """
+        raise NotImplementedError("Command subclasses must implement help property")
+
+    def execute(self, *_: Any, **kwargs: Any) -> Any:
+        """
+        Execute the command.
+
+        Args:
+            *args: Positional arguments
+            **kwargs: Keyword arguments
+        """
+        raise NotImplementedError("Command subclasses must implement execute method")
+
+
+def validate_command_args(**validators: Callable[[Any], bool]) -> Callable:
+    """
+    Decorator to validate command arguments.
+
+    Args:
+        **validators: A dictionary of argument names and validation functions
+
+    Returns:
+        Callable: The decorator function
+    """
+
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            for arg_name, validator in validators.items():
+                if arg_name in kwargs:
+                    if not validator(kwargs[arg_name]):
+                        raise ValueError(f"Invalid value for {arg_name}")
+
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+__all__ = [
+    "Command",
+    "CommandBase",
+    "ErrorCode",
+    "get_command",
+    "list_commands",
+    "validate_command_args",
+]

wl_cli/commands/base.py

@@ -0,0 +1,80 @@
+"""Unified command base class for WL Commands."""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class CommandBase(ABC):
+    """
+    Abstract base class for all commands, providing lifecycle and logging utilities.
+    """
+
+    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
+    @abstractmethod
+    def help(self) -> str:
+        """Get the command help text."""
+        pass
+
+    @abstractmethod
+    def execute(self, *_: Any, **kwargs: Any) -> Any:
+        """Execute the command."""
+        pass
+
+    def before_execute(self, *args: Any, **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, *args: Any, **kwargs: Any) -> Any:
+        """Run with lifecycle and error handling around execute."""
+        try:
+            # Validate arguments and use the validated kwargs
+            validated_kwargs = self.validate_args(**kwargs)
+            self.before_execute(*args, **validated_kwargs)
+            result = self.execute(*args, **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:
+            # Logging utility may not be available in certain contexts; ignore
+            pass
+
+
+# Backward compatibility alias
+BaseCommand = CommandBase

wl_cli/commands/buildcommands/__init__.py

@@ -0,0 +1 @@
+"""Build commands package (registered lazily via COMMAND_TABLE)."""

wl_cli/commands/buildcommands/build.py

@@ -0,0 +1,71 @@
+"""Build command for WL Commands."""
+
+from typing import Any
+
+import click
+
+from .. import Command
+from .build_utils import build_project, build_project_full
+
+
+class BuildCommand(Command):
+    """Command to build the project"""
+
+    @property
+    def name(self) -> str:
+        """Return command name"""
+        return "build"
+
+    @property
+    def help(self) -> str:
+        """Get command help text"""
+        return "Build the project"
+
+    def execute(self, *_: Any, **kwargs: Any) -> None:
+        """Execute the build command."""
+        unknown_args = kwargs.get("unknown_args", [])
+        if unknown_args and unknown_args[0] == "dist":
+            build_project_full()
+        else:
+            build_project()
+
+
+class BuildCommandImpl:
+    """Implementation of the build command."""
+
+    @property
+    def name(self) -> str:
+        return "build"
+
+    @property
+    def help(self) -> str:
+        return "Build the project"
+
+    @property
+    def aliases(self) -> list[str]:
+        return []
+
+    def execute(self, dist: bool = False) -> None:
+        """Execute the build command.
+
+        Args:
+            dist: If True, perform full compilation (build_project_full).
+                  If False, perform regular build (build_project).
+        """
+        if dist:
+            build_project_full()
+        else:
+            build_project()
+
+
+@click.command()
+@click.option(
+    "-d",
+    "--dist",
+    is_flag=True,
+    help="Perform full compilation including all outputs",
+)
+def build_command(dist: bool) -> None:
+    """Build command Click wrapper."""
+    cmd = BuildCommandImpl()
+    cmd.execute(dist=dist)

wl_cli/commands/buildcommands/build_utils.py

@@ -0,0 +1,47 @@
+"""Build utilities for WL Commands.
+
+This module serves as the entry point for the modularized build functionality.
+主要功能委托给专门的模块以获得更好的组织结构。
+"""
+
+from .builders.cleanup import CleanupManager
+from .builders.coordinator import BuildCoordinator
+from .builders.environment import EnvironmentDetector
+from .builders.rust_builder import RustBuilder
+from .builders.stubs import StubsManager
+
+
+# Backward compatibility: re-export all the main functions
+def is_rust_enabled() -> bool:
+    """Check if Rust is enabled for this project."""
+    return EnvironmentDetector.is_rust_enabled()
+
+
+def build_project_full() -> None:
+    """Perform a full project build."""
+    coordinator = BuildCoordinator()
+    coordinator.build_project_full()
+
+
+def build_project() -> None:
+    """Build the project based on the current platform."""
+    try:
+        coordinator = BuildCoordinator()
+        coordinator.build_project()
+    except Exception as e:
+        from wl_cli.exceptions import CommandError
+
+        raise CommandError(f"Build failed: {e}")
+
+
+# Re-export classes for advanced usage
+__all__ = [
+    "is_rust_enabled",
+    "build_project_full",
+    "build_project",
+    "EnvironmentDetector",
+    "StubsManager",
+    "RustBuilder",
+    "CleanupManager",
+    "BuildCoordinator",
+]

wl_cli/commands/buildcommands/builders/__init__.py

@@ -0,0 +1,18 @@
+"""Build command modules for specialized functionality.
+
+This package contains modularized build utilities for better code organization.
+"""
+
+from .cleanup import CleanupManager
+from .coordinator import BuildCoordinator
+from .environment import EnvironmentDetector
+from .rust_builder import RustBuilder
+from .stubs import StubsManager
+
+__all__ = [
+    "EnvironmentDetector",
+    "StubsManager",
+    "RustBuilder",
+    "CleanupManager",
+    "BuildCoordinator",
+]

wl_cli/commands/buildcommands/builders/cleanup.py

@@ -0,0 +1,35 @@
+"""Build cleanup utilities."""
+
+import shutil
+from pathlib import Path
+
+from ....utils.logging import log_error, log_info
+
+
+class CleanupManager:
+    """Handle post-build cleanup operations."""
+
+    @staticmethod
+    def cleanup_after_build(is_workspace: bool) -> None:
+        """Clean up temporary files and directories after build."""
+        try:
+            root = Path.cwd()
+            typings_path = root / "typings"
+            if typings_path.exists():
+                shutil.rmtree(typings_path, ignore_errors=True)
+                log_info("✓ typings directory removed")
+
+            src_path = root / "src"
+            if src_path.exists():
+                removed = 0
+                for p in src_path.rglob("*.pyi"):
+                    try:
+                        p.unlink()
+                        removed += 1
+                    except Exception:
+                        pass
+                if removed:
+                    log_info(f"✓ Removed {removed} .pyi files from src")
+
+        except Exception as e:
+            log_error(f"Failed to cleanup stubs: {e}")

wl_cli/commands/buildcommands/builders/coordinator.py

@@ -0,0 +1,122 @@
+"""Build coordination logic for different platforms and scenarios."""
+
+from ....exceptions import CommandError
+from ....utils.logging import (
+    log_error_pair,
+    log_info,
+    log_info_pair,
+)
+from ....utils.subprocess import run_command
+from .cleanup import CleanupManager
+from .environment import EnvironmentDetector
+from .rust_builder import RustBuilder
+from .stubs import StubsManager
+
+
+class BuildCoordinator:
+    """Coordinate build operations across different platforms and scenarios."""
+
+    def __init__(self):
+        self.environment_detector = EnvironmentDetector()
+        self.stubs_manager = StubsManager()
+        self.rust_builder = RustBuilder()
+        self.cleanup_manager = CleanupManager()
+
+    def build_project_full(self) -> None:
+        """Perform a full project build."""
+        rust_enabled = self.environment_detector.is_rust_enabled()
+
+        try:
+            if rust_enabled:
+                log_info_pair(
+                    "Using maturin build for full compilation...",
+                    "使用 maturin build 进行完整编译...",
+                )
+
+                python_executable, is_workspace = (
+                    self.environment_detector.resolve_python_executable()
+                )
+                self.stubs_manager.generate_and_copy_stubs()
+                self.rust_builder.build_full(python_executable)
+                self.cleanup_manager.cleanup_after_build(is_workspace)
+            else:
+                log_info_pair(
+                    "Pure Python project, using uv build to generate distribution packages...",
+                    "纯 Python 项目，使用 uv build 生成分发包...",
+                )
+                run_command(
+                    ["uv", "build"],
+                    capture_output=False,
+                )
+
+            log_info_pair(
+                "✓ Full build completed successfully",
+                "✓ 完整构建成功完成",
+            )
+
+            # List files in dist directory for verification
+            from pathlib import Path
+
+            dist_dir = Path("dist")
+            if dist_dir.exists():
+                dist_files = list(dist_dir.iterdir())
+                if dist_files:
+                    log_info_pair(
+                        "Generated distribution packages in dist directory:",
+                        "在 dist 目录中生成的分发包:",
+                    )
+                    for f in dist_files:
+                        log_info(f"  - {f.name}")
+                else:
+                    log_info_pair(
+                        "No distribution packages generated in dist directory",
+                        "在 dist 目录中没有生成分发包",
+                    )
+        except Exception as e:
+            log_error_pair(
+                f"Full build failed: {e}",
+                f"完整构建失败: {e}",
+            )
+            raise CommandError(f"Full build failed: {e}")
+
+    def build(self) -> None:
+        """Build the project in place, on any platform.
+
+        The former ``build_windows`` and ``build_unix`` bodies were
+        byte-identical, so the platform branch collapsed away.
+        """
+        rust_enabled = self.environment_detector.is_rust_enabled()
+
+        try:
+            if rust_enabled:
+                self.rust_builder.build_incremental()
+            else:
+                log_info_pair(
+                    "Pure Python project, using uv pip install -e . for installation...",
+                    "纯 Python 项目，使用 uv pip install -e . 进行安装...",
+                )
+                run_command(
+                    ["uv", "pip", "install", "--link-mode=copy", "-e", "."],
+                    capture_output=False,
+                )
+
+            log_info_pair(
+                "✓ Build completed successfully",
+                "✓ 构建成功完成",
+            )
+        except CommandError as e:
+            log_error_pair(
+                f"Build failed: {e}",
+                f"构建失败: {e}",
+            )
+            raise
+        except Exception as e:
+            log_error_pair(
+                f"Unexpected error during build: {e}",
+                f"构建过程中出现意外错误: {e}",
+            )
+            raise CommandError(f"Build failed: {e}")
+
+    def build_project(self) -> None:
+        """Build the project."""
+        self.build()