py-wlcli 0.8.0__py3-none-any.whl

wl_cli/__main__.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+
+"""
+Main entry point for WL Commands.
+"""
+
+import io
+import os
+import sys
+
+
+def _setup_stdio_encoding() -> None:
+    """Ensure stdout/stderr use UTF-8 encoding on Windows.
+
+    On Windows with Chinese locale (GBK), emoji and other non-ASCII
+    characters crash print(). This wraps stdout/stderr with explicit
+    UTF-8 encoding so all output works regardless of terminal locale.
+    """
+    # Imported here (with a script-execution fallback, matching the cli_click
+    # import below) so this module stays runnable as a plain script.
+    try:
+        from .utils import platform_adapter
+    except ImportError:  # pragma: no cover - direct script execution
+        from wl_cli.utils import platform_adapter  # type: ignore[no-redef]
+
+    if not platform_adapter.PlatformAdapter.is_windows():
+        return
+    # PYTHONIOENCODING also helps subprocess pipe encoding
+    os.environ.setdefault("PYTHONIOENCODING", "utf-8")
+    for stream_name in ("stdout", "stderr"):
+        stream = getattr(sys, stream_name, None)
+        if stream is None:
+            continue
+        encoding = getattr(stream, "encoding", None)
+        if encoding and encoding.upper() not in ("UTF-8", "UTF8"):
+            buffer = getattr(stream, "buffer", None)
+            if buffer is not None:
+                setattr(
+                    sys,
+                    stream_name,
+                    io.TextIOWrapper(
+                        buffer, encoding="utf-8", errors="replace", line_buffering=True
+                    ),
+                )
+
+
+# Fix stdio encoding on Windows before any output
+_setup_stdio_encoding()
+
+
+def check_installation() -> bool:
+    """Check if wl_cli is properly installed.
+
+    Returns:
+        True if installed correctly, False otherwise.
+    """
+    try:
+        import wl_cli  # noqa: F401  # availability probe: import must succeed
+
+        return True
+    except ImportError:
+        return False
+
+
+def print_installation_guide() -> None:
+    """Print installation guide when module is not installed."""
+    red = "\033[0;31m"
+    yellow = "\033[1;33m"
+    blue = "\033[0;34m"
+    nc = "\033[0m"  # No Color
+
+    print(f"{red}ERROR:{nc} wl_cli is not installed or not properly configured.")
+    print()
+    print(f"{blue}Installation Guide:{nc}")
+    print("-" * 50)
+    print()
+    print("To automatically install wl_cli, run:")
+    print()
+    print(f"  {yellow}./install-wl-cli.sh{nc}")
+    print()
+    print("To install a specific version:")
+    print()
+    print(f"  {yellow}./install-wl-cli.sh 0.1.0{nc}")
+    print()
+    print("If you are in the git repository, this script will:")
+    print("  1. Auto-detect your Python environment")
+    print("  2. Check if wl_cli is already installed")
+    print("  3. Install from local source (development mode)")
+    print("  4. Fallback to PyPI if local installation fails")
+    print("  5. Verify installation after completion")
+    print()
+    print("After installation completes, you can use 'wl' commands normally.")
+    print()
+
+
+# 使用新的Click CLI
+try:
+    # Local import to avoid import issues
+    from .cli_click import main as cli_main
+except ImportError:
+    try:
+        # Fallback for cases where relative imports don't work
+        from wl_cli.cli_click import main as cli_main  # type: ignore[no-redef]
+    except ImportError:
+        # Module not properly installed
+        if not check_installation():
+            print_installation_guide()
+            sys.exit(1)
+        else:
+            # Re-raise if installation check passed but import still fails
+            raise
+
+
+def main() -> None:
+    """Main entry point for WL Commands.
+
+    ``cli_click.main`` returns the process exit code (0 on success, 1 when a
+    command raises), so the entry point must hand that value to the
+    interpreter instead of discarding it. Without the ``SystemExit`` every
+    ``return 1`` path inside ``cli_click.main`` exited 0 (#186).
+    """
+    raise SystemExit(cli_main())
+
+
+# Alias for compatibility with tests
+main_entry = main
+
+
+if __name__ == "__main__":
+    main()

wl_cli/capabilities.py

@@ -0,0 +1,79 @@
+"""The shared capability registry for the ``wl`` CLI (issues #270, #221).
+
+Capabilities are the stable, dotted names a consumer (wlcc) probes instead of
+grepping ``--help`` for an implementation flag (wlcc ADR-0010, decision 6):
+``test.clean_cache`` says *what wl can do*; ``--clean-cache`` is only how it is
+spelled today. The dotted names are the interface -- treat them as stable.
+
+The registry lives in the shared layer rather than under ``wl_cli.env`` or
+``wl_cli.commands`` because two commands in different domains must serve the
+same names: ``wl env check`` (``wl_cli.env``) and the deprecated
+``wl self capabilities`` alias (``wl_cli.commands``). The quality domain may
+not import the env domain (#220), so one shared data owner is the only
+arrangement that does not fork the answer.
+
+Adding a capability is a data change here plus an entry in the surface table
+of ``tests/test_self_capabilities_270.py`` proving some CLI surface still
+backs it, so a name cannot outlive its implementation.
+
+A domain may keep a domain-local view of its own entries
+(``wl_cli.mcp.capabilities.CAPABILITIES``, #224) derived from this mapping;
+the data itself lives here only, and ``tests/test_capability_registry.py``
+pins that the view cannot drift.
+"""
+
+from __future__ import annotations
+
+#: Bump only when the payload *shape* changes -- never when a capability is
+#: added. Consumers key off this; adding a capability is backwards compatible.
+SCHEMA_VERSION = 1
+
+#: Capability name -> first release that ships its implementation. Adding an
+#: entry is a data change; ``since`` must never be newer than the release this
+#: data ships in (the release bump happens outside this change).
+CAPABILITY_SINCE: dict[str, str] = {
+    "cc.check": "0.8.0",
+    "cc.hooks": "0.8.0",
+    "cc.init": "0.8.0",
+    "cc.mcp": "0.8.0",
+    "cc.plugins": "0.8.0",
+    "cc.repair": "0.8.0",
+    "cc.settings": "0.8.0",
+    "cc.stamps": "0.8.0",
+    "cc.statusline": "0.8.0",
+    "cc.upgrade": "0.8.0",
+    "env.check": "0.8.0",
+    "env.repair": "0.8.0",
+    "mcp.gitlab": "0.8.0",
+    "mcp.k8s": "0.8.0",
+    "test.clean_cache": "0.7.0",
+}
+
+#: The advertised names, sorted for stable output. Derived from the mapping so
+#: there is exactly one source of truth.
+CAPABILITIES: tuple[str, ...] = tuple(sorted(CAPABILITY_SINCE))
+
+
+def capability_names() -> list[str]:
+    """Return the advertised capability names, sorted for stable output."""
+    return list(CAPABILITIES)
+
+
+def capability_details() -> list[dict[str, str]]:
+    """Return ``[{"name": ..., "since": ...}, ...]`` in sorted-name order."""
+    return [{"name": name, "since": CAPABILITY_SINCE[name]} for name in CAPABILITIES]
+
+
+def capability_since() -> dict[str, str]:
+    """Return ``{name: since}`` in sorted-name order."""
+    return {name: CAPABILITY_SINCE[name] for name in CAPABILITIES}
+
+
+def capabilities_payload() -> dict[str, object]:
+    """Return the legacy ``wl self capabilities --json`` payload (#270).
+
+    ``wl self capabilities`` is a deprecated alias since #221 and emits the
+    ``wl env check`` envelope instead, but the old shape stays importable so a
+    library consumer does not break in the same release that deprecates it.
+    """
+    return {"schema": SCHEMA_VERSION, "capabilities": capability_names()}

wl_cli/cc/__init__.py

@@ -0,0 +1,5 @@
+"""Claude Code integration domain (may depend on ``wl_cli.env``, never the reverse)."""
+
+from .cli import cc_group
+
+__all__ = ["cc_group"]