py-wlcli 0.8.0__py3-none-any.whl

wl_cli/vendors/hooks/unix/fsmonitor-watchman.sample

@@ -0,0 +1,174 @@
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+use IPC::Open2;
+
+# An example hook script to integrate Watchman
+# (https://facebook.github.io/watchman/) with git to speed up detecting
+# new and modified files.
+#
+# The hook is passed a version (currently 2) and last update token
+# formatted as a string and outputs to stdout a new update token and
+# all files that have been modified since the update token. Paths must
+# be relative to the root of the working tree and separated by a single NUL.
+#
+# To enable this hook, rename this file to "query-watchman" and set
+# 'git config core.fsmonitor .git/hooks/query-watchman'
+#
+my ($version, $last_update_token) = @ARGV;
+
+# Uncomment for debugging
+# print STDERR "$0 $version $last_update_token\n";
+
+# Check the hook interface version
+if ($version ne 2) {
+	die "Unsupported query-fsmonitor hook version '$version'.\n" .
+	    "Falling back to scanning...\n";
+}
+
+my $git_work_tree = get_working_dir();
+
+my $retry = 1;
+
+my $json_pkg;
+eval {
+	require JSON::XS;
+	$json_pkg = "JSON::XS";
+	1;
+} or do {
+	require JSON::PP;
+	$json_pkg = "JSON::PP";
+};
+
+launch_watchman();
+
+sub launch_watchman {
+	my $o = watchman_query();
+	if (is_work_tree_watched($o)) {
+		output_result($o->{clock}, @{$o->{files}});
+	}
+}
+
+sub output_result {
+	my ($clockid, @files) = @_;
+
+	# Uncomment for debugging watchman output
+	# open (my $fh, ">", ".git/watchman-output.out");
+	# binmode $fh, ":utf8";
+	# print $fh "$clockid\n@files\n";
+	# close $fh;
+
+	binmode STDOUT, ":utf8";
+	print $clockid;
+	print "\0";
+	local $, = "\0";
+	print @files;
+}
+
+sub watchman_clock {
+	my $response = qx/watchman clock "$git_work_tree"/;
+	die "Failed to get clock id on '$git_work_tree'.\n" .
+		"Falling back to scanning...\n" if $? != 0;
+
+	return $json_pkg->new->utf8->decode($response);
+}
+
+sub watchman_query {
+	my $pid = open2(\*CHLD_OUT, \*CHLD_IN, 'watchman -j --no-pretty')
+	or die "open2() failed: $!\n" .
+	"Falling back to scanning...\n";
+
+	# In the query expression below we're asking for names of files that
+	# changed since $last_update_token but not from the .git folder.
+	#
+	# To accomplish this, we're using the "since" generator to use the
+	# recency index to select candidate nodes and "fields" to limit the
+	# output to file names only. Then we're using the "expression" term to
+	# further constrain the results.
+	my $last_update_line = "";
+	if (substr($last_update_token, 0, 1) eq "c") {
+		$last_update_token = "\"$last_update_token\"";
+		$last_update_line = qq[\n"since": $last_update_token,];
+	}
+	my $query = <<"	END";
+		["query", "$git_work_tree", {$last_update_line
+			"fields": ["name"],
+			"expression": ["not", ["dirname", ".git"]]
+		}]
+	END
+
+	# Uncomment for debugging the watchman query
+	# open (my $fh, ">", ".git/watchman-query.json");
+	# print $fh $query;
+	# close $fh;
+
+	print CHLD_IN $query;
+	close CHLD_IN;
+	my $response = do {local $/; <CHLD_OUT>};
+
+	# Uncomment for debugging the watch response
+	# open ($fh, ">", ".git/watchman-response.json");
+	# print $fh $response;
+	# close $fh;
+
+	die "Watchman: command returned no output.\n" .
+	"Falling back to scanning...\n" if $response eq "";
+	die "Watchman: command returned invalid output: $response\n" .
+	"Falling back to scanning...\n" unless $response =~ /^\{/;
+
+	return $json_pkg->new->utf8->decode($response);
+}
+
+sub is_work_tree_watched {
+	my ($output) = @_;
+	my $error = $output->{error};
+	if ($retry > 0 and $error and $error =~ m/unable to resolve root .* directory (.*) is not watched/) {
+		$retry--;
+		my $response = qx/watchman watch "$git_work_tree"/;
+		die "Failed to make watchman watch '$git_work_tree'.\n" .
+		    "Falling back to scanning...\n" if $? != 0;
+		$output = $json_pkg->new->utf8->decode($response);
+		$error = $output->{error};
+		die "Watchman: $error.\n" .
+		"Falling back to scanning...\n" if $error;
+
+		# Uncomment for debugging watchman output
+		# open (my $fh, ">", ".git/watchman-output.out");
+		# close $fh;
+
+		# Watchman will always return all files on the first query so
+		# return the fast "everything is dirty" flag to git and do the
+		# Watchman query just to get it over with now so we won't pay
+		# the cost in git to look up each individual file.
+		my $o = watchman_clock();
+		$error = $output->{error};
+
+		die "Watchman: $error.\n" .
+		"Falling back to scanning...\n" if $error;
+
+		output_result($o->{clock}, ("/"));
+		$last_update_token = $o->{clock};
+
+		eval { launch_watchman() };
+		return 0;
+	}
+
+	die "Watchman: $error.\n" .
+	"Falling back to scanning...\n" if $error;
+
+	return 1;
+}
+
+sub get_working_dir {
+	my $working_dir;
+	if ($^O =~ 'msys' || $^O =~ 'cygwin') {
+		$working_dir = Win32::GetCwd();
+		$working_dir =~ tr/\\/\//;
+	} else {
+		require Cwd;
+		$working_dir = Cwd::cwd();
+	}
+
+	return $working_dir;
+}

wl_cli/vendors/hooks/unix/post-update.sample

@@ -0,0 +1,8 @@
+#!/bin/sh
+#
+# An example hook script to prepare a packed repository for use over
+# dumb transports.
+#
+# To enable this hook, rename this file to "post-update".
+
+exec git update-server-info

wl_cli/vendors/hooks/unix/pre-applypatch.sample

@@ -0,0 +1,14 @@
+#!/bin/sh
+#
+# An example hook script to verify what is about to be committed
+# by applypatch from an e-mail message.
+#
+# The hook should exit with non-zero status after issuing an
+# appropriate message if it wants to stop the commit.
+#
+# To enable this hook, rename this file to "pre-applypatch".
+
+. git-sh-setup
+precommit="$(git rev-parse --git-path hooks/pre-commit)"
+test -x "$precommit" && exec "$precommit" ${1+"$@"}
+:

wl_cli/vendors/hooks/unix/pre-commit

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+# File generated by pre-commit: https://pre-commit.com
+# ID: 138fd403232d2ddd5efb44317e38bf03
+# Modified to be a Python script for cross-platform compatibility
+# Added Git Flow hint display
+
+import os
+import shutil
+import subprocess
+import sys
+
+
+def run_git_flow_check():
+    """Run git-flow check and display hint information.
+
+    This is a pure hint: the return code is discarded by the caller and the
+    check never gates the commit. Resolution order:
+      1. In-process call to the git-flow check core when ``wl_cli`` is
+         importable under the current interpreter (no subprocess spawned).
+      2. Fall back to ``wl git-flow check`` when ``wl`` is on PATH.
+      3. If neither is available, silently skip and return 0.
+    """
+    banner_lines = []
+
+    # 1. Prefer the in-process core so we do not spawn uv/wl.
+    try:
+        from wl_cli.commands.git.git_flow import run_git_flow_check_text
+
+        banner_lines = run_git_flow_check_text().splitlines()
+    except ImportError:
+        # wl_cli is not importable under pre-commit's python -> CLI fallback.
+        banner_lines = _run_wl_cli_check()
+    except Exception:
+        # The in-process core failed for another reason (e.g. not a git repo,
+        # missing PyYAML). Still a pure hint: fall back to the wl CLI, and if
+        # that is also unavailable, skip silently.
+        banner_lines = _run_wl_cli_check()
+
+    if banner_lines:
+        _print_git_flow_banner(banner_lines)
+
+    return 0
+
+
+def _run_wl_cli_check():
+    """Fall back to ``wl git-flow check`` on PATH; return banner lines or []."""
+    wl_exe = shutil.which("wl")
+    if wl_exe is None:
+        return []
+    try:
+        result = subprocess.run(
+            [wl_exe, "git-flow", "check"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+    except (FileNotFoundError, OSError):
+        return []
+
+    stdout = result.stdout.strip()
+    return stdout.split("\n") if stdout else []
+
+
+def _print_git_flow_banner(lines):
+    """Print the key git-flow status lines under the bilingual banner."""
+    print("\n=== Git Flow Status ===")
+    print("=== Git Flow 状态 ===")
+    for line in lines:
+        # Only show key information (not the full agent hint)
+        if line.startswith(
+            (
+                "Git Flow check:",
+                "Branch:",
+                "Type:",
+                "Source:",
+                "Target:",
+                "Rule:",
+                "Fix:",
+            )
+        ):
+            print(line)
+    print("=" * 50)
+
+
+def main():
+    """Main function to execute pre-commit hook."""
+    print("✓ Pre-commit hook is running...")
+    print("✓ Pre-commit钩子正在运行...")
+
+    # Run Git Flow check and display hint
+    run_git_flow_check()
+
+    # Get the directory where this script is located
+    here = os.path.dirname(os.path.abspath(__file__))
+
+    # Generate arguments
+    args = [
+        "hook-impl",
+        "--config=.wl/.pre-commit-config.yaml",
+        "--hook-type=pre-commit",
+        "--hook-dir",
+        here,
+        "--",
+    ] + sys.argv[1:]
+
+    # Resolve a Python that has `pre_commit` installed.
+    #
+    # `pre_commit` is a runtime dependency of the wl tool (wl-cli), living
+    # in the uv tool environment — NOT in generated projects' `.venv` (workspace
+    # `dependencies = []`). Running `python -m pre_commit` against the project
+    # venv fails with "No module named pre_commit". Resolve the wl tool env first.
+    python_exe = None
+    use_uv_tool = False
+
+    # 1. Fast path: the python inside the wl tool env (UV_TOOL_DIR or default)
+    tool_dir = os.environ.get("UV_TOOL_DIR") or os.path.join(
+        os.path.expanduser("~"), ".local", "share", "uv", "tools"
+    )
+    # 发行名是 `py-wlcli`（uv tool 环境目录名同）。这里曾写短名 `wlcli`——那是包改名时
+    # 漏掉的另一半，且是唯一**不会被 import 报错暴露**的位置：只在 hook 真跑时才炸。
+    for candidate in (
+        os.path.join(tool_dir, "py-wlcli", "bin", "python"),
+        os.path.join(tool_dir, "py-wlcli", "bin", "python3"),
+        os.path.join(tool_dir, "py-wlcli", "Scripts", "python.exe"),
+        os.path.join(tool_dir, "py-wlcli", "Scripts", "python3.exe"),
+    ):
+        if os.path.exists(candidate):
+            python_exe = candidate
+            break
+
+    # 2. Fallback: run inside the tool env via uv (robust to layout changes)
+    if not python_exe:
+        try:
+            probe = subprocess.run(
+                [
+                    "uv",
+                    "tool",
+                    "run",
+                    "--from",
+                    "py-wlcli",
+                    "python",
+                    "-c",
+                    "import pre_commit",
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+                timeout=30,
+            )
+            if probe.returncode == 0:
+                use_uv_tool = True
+        except (subprocess.SubprocessError, FileNotFoundError):
+            use_uv_tool = False
+
+    # 3. Last resort: project `.venv` (only has pre_commit in repos that install
+    #    it explicitly, e.g. wl-cli's own dev checkout)
+    if not python_exe and not use_uv_tool:
+        for path in (
+            os.path.join(".venv", "bin", "python"),
+            os.path.join(".venv", "bin", "python3"),
+            os.path.join(".venv", "Scripts", "python.exe"),
+        ):
+            abs_path = os.path.join(os.getcwd(), path)
+            if os.path.exists(abs_path):
+                python_exe = abs_path
+                break
+
+    if not python_exe and not use_uv_tool:
+        print(
+            "`pre-commit` not found in the wl tool environment. "
+            "Install it with: uv tool install py-wlcli",
+            file=sys.stderr,
+        )
+        return 1
+
+    # Execute pre_commit
+    if use_uv_tool:
+        result = subprocess.run(
+            ["uv", "tool", "run", "--from", "py-wlcli", "python", "-m", "pre_commit"]
+            + args,
+            check=False,
+        )
+    else:
+        result = subprocess.run([python_exe, "-m", "pre_commit"] + args, check=False)
+
+    return result.returncode
+
+
+if __name__ == "__main__":
+    sys.exit(main())

wl_cli/vendors/hooks/unix/pre-commit.legacy

@@ -0,0 +1,31 @@
+#!/bin/bash
+
+# Pre-commit hook that prevents commits to main and develop branches and runs wl lint
+
+# Check current branch
+echo "Checking current branch..."
+current_branch=$(git branch --show-current)
+
+# Prevent commits to main and develop branches
+if [[ "$current_branch" == "main" || "$current_branch" == "develop" ]]; then
+    echo "❌ ERROR: Direct commits to $current_branch branch are not allowed."
+    echo "Please create a feature/fix branch and submit a Pull Request instead."
+    exit 1
+fi
+
+echo "Running pre-commit checks..."
+echo "执行预提交检查..."
+
+# Run wl lint command with custom pre-commit config
+uv run wl lint --pre-commit-config config/.pre-commit-config.yaml
+
+# Check exit code
+if [ $? -ne 0 ]; then
+    echo "❌ Pre-commit checks failed. Please fix the issues and try again."
+    echo "❌ 预提交检查失败。请修复问题后重试。"
+    exit 1
+fi
+
+echo "✅ Pre-commit checks passed."
+echo "✅ 预提交检查通过。"
+exit 0

wl_cli/vendors/hooks/unix/pre-commit.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""
+Python wrapper for pre-commit hook.
+"""
+
+import os
+import subprocess
+import sys
+
+
+def main():
+    """Main function to execute pre-commit hook."""
+    print("✓ Pre-commit hook is running...")
+    print("✓ Pre-commit钩子正在运行...")
+
+    # Get the directory where this script is located
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+
+    # Try to find uv Python interpreter
+    uv_python = None
+
+    # Try direct uv call first
+    try:
+        uv_python = subprocess.check_output(
+            ["uv", "python", "--print-path"], text=True
+        ).strip()
+    except subprocess.CalledProcessError:
+        pass
+
+    # If uv Python not found, try common virtual environment paths
+    if not uv_python:
+        venv_paths = [
+            "./.venv/bin/python",
+            "./.venv/bin/python3",
+            "../.venv/bin/python",
+            "../.venv/bin/python3",
+            ".venv/Scripts/python.exe",
+            ".venv/Scripts/python3.exe",
+            "../.venv/Scripts/python.exe",
+            "../.venv/Scripts/python3.exe",
+        ]
+
+        for path in venv_paths:
+            abs_path = os.path.join(os.getcwd(), path)
+            if os.path.exists(abs_path):
+                uv_python = abs_path
+                break
+
+    if not uv_python:
+        print(
+            "Error: Could not find Python interpreter. Please ensure uv is installed.",
+            file=sys.stderr,
+        )
+        return 1
+
+    # Execute the original shell hook with uv Python
+    result = subprocess.run(
+        [
+            uv_python,
+            "-m",
+            "pre_commit",
+            "hook-impl",
+            "--config=.wl/.pre-commit-config.yaml",
+            "--hook-type=pre-commit",
+            "--hook-dir",
+            script_dir,
+            "--",
+        ]
+        + sys.argv[1:],
+        capture_output=True,
+        text=True,
+    )
+
+    print(result.stdout, end="")
+    print(result.stderr, end="", file=sys.stderr)
+
+    return result.returncode
+
+
+if __name__ == "__main__":
+    sys.exit(main())

wl_cli/vendors/hooks/unix/pre-commit.sample

@@ -0,0 +1,49 @@
+#!/bin/sh
+#
+# An example hook script to verify what is about to be committed.
+# Called by "git commit" with no arguments.  The hook should
+# exit with non-zero status after issuing an appropriate message if
+# it wants to stop the commit.
+#
+# To enable this hook, rename this file to "pre-commit".
+
+if git rev-parse --verify HEAD >/dev/null 2>&1
+then
+	against=HEAD
+else
+	# Initial commit: diff against an empty tree object
+	against=$(git hash-object -t tree /dev/null)
+fi
+
+# If you want to allow non-ASCII filenames set this variable to true.
+allownonascii=$(git config --type=bool hooks.allownonascii)
+
+# Redirect output to stderr.
+exec 1>&2
+
+# Cross platform projects tend to avoid non-ASCII filenames; prevent
+# them from being added to the repository. We exploit the fact that the
+# printable range starts at the space character and ends with tilde.
+if [ "$allownonascii" != "true" ] &&
+	# Note that the use of brackets around a tr range is ok here, (it's
+	# even required, for portability to Solaris 10's /usr/bin/tr), since
+	# the square bracket bytes happen to fall in the designated range.
+	test $(git diff-index --cached --name-only --diff-filter=A -z $against |
+	  LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0
+then
+	cat <<\EOF
+Error: Attempt to add a non-ASCII file name.
+
+This can cause problems if you want to work with people on other platforms.
+
+To be portable it is advisable to rename the file.
+
+If you know what you are doing you can disable this check using:
+
+  git config hooks.allownonascii true
+EOF
+	exit 1
+fi
+
+# If there are whitespace errors, print the offending file names and fail.
+exec git diff-index --check --cached $against --

wl_cli/vendors/hooks/unix/pre-merge-commit.sample

@@ -0,0 +1,13 @@
+#!/bin/sh
+#
+# An example hook script to verify what is about to be committed.
+# Called by "git merge" with no arguments.  The hook should
+# exit with non-zero status after issuing an appropriate message to
+# stderr if it wants to stop the merge commit.
+#
+# To enable this hook, rename this file to "pre-merge-commit".
+
+. git-sh-setup
+test -x "$GIT_DIR/hooks/pre-commit" &&
+        exec "$GIT_DIR/hooks/pre-commit"
+: