anolisa-tokenless 0.7.14 → 0.8.0

package/adapters/tokenless/qwenpaw/scripts/detect.sh

@@ -0,0 +1,131 @@
+#!/usr/bin/env bash
+# detect.sh — Inspect tokenless QwenPaw integration. Read-only.
+#
+# Reports qwenpaw CLI, QwenPaw working directory, tokenless plugin install
+# state, and adapter resource availability. Exit codes:
+#   0 = installed and ready
+#   1 = not installed but installable
+#   2 = missing prerequisites
+set -euo pipefail
+
+AGENT="${ANOLISA_TARGET:-qwenpaw}"
+COMPONENT="${ANOLISA_COMPONENT:-tokenless}"
+ADAPTER_DIR="${ANOLISA_ADAPTER_DIR:-$(cd "$(dirname "$0")/../.." && pwd)}"
+# Resolve the working directory like QwenPaw: QWENPAW_WORKING_DIR, else
+# COPAW_WORKING_DIR, else a legacy ~/.copaw, else ~/.qwenpaw.
+PLUGIN_ID="tokenless"
+QWENPAW_WORKING_DIR="${QWENPAW_WORKING_DIR:-${COPAW_WORKING_DIR:-}}"
+if [ -z "$QWENPAW_WORKING_DIR" ]; then
+    if [ -d "$HOME/.copaw" ]; then QWENPAW_WORKING_DIR="$HOME/.copaw"; other="$HOME/.qwenpaw"; else QWENPAW_WORKING_DIR="$HOME/.qwenpaw"; other="$HOME/.copaw"; fi
+    # ~/.copaw may have appeared or vanished since the plugin was installed:
+    # prefer the default location that actually holds it.
+    if [ ! -d "$QWENPAW_WORKING_DIR/plugins/$PLUGIN_ID" ] && [ -d "$other/plugins/$PLUGIN_ID" ]; then
+        QWENPAW_WORKING_DIR="$other"
+    fi
+fi
+QWENPAW_BIN="${QWENPAW_BIN:-}"
+export PATH="${QWENPAW_HOME:-$HOME/.qwenpaw}/bin:$HOME/.local/bin:/usr/local/bin:$PATH"
+
+PLUGIN_SRC="$ADAPTER_DIR/qwenpaw"
+
+# QwenPaw installs requirements.txt with its own interpreter (the CLI's
+# shebang). On a platform without a matching wheel pip installs nothing and
+# still exits 0, and a released wheel may predate the SDK surface the plugin
+# imports, so prove the SDK imports there. QWENPAW_PYTHON overrides the
+# interpreter; a CLI without a Python shebang (frozen build) is left unverified.
+check_sdk() {
+    local python="${QWENPAW_PYTHON:-}"
+    if [ -z "$python" ]; then
+        python="$(sed -n '1s/^#![[:space:]]*//p' "$QWENPAW_BIN")"
+        case "$python" in
+            /usr/bin/env\ *) python="$(command -v "${python#/usr/bin/env }" 2>/dev/null || true)" ;;
+        esac
+    fi
+    if [ -z "$python" ] || [ ! -x "$python" ] || ! "$python" --version 2>&1 | grep -q '^Python '; then
+        return 2
+    fi
+    "$python" - <<'PY'
+import sys
+try:
+    import anolisa_tokenless as sdk
+except ImportError as error:
+    sys.exit(f"anolisa_tokenless is not importable by {sys.executable}: {error}")
+if not hasattr(sdk, "RecoveryMethod"):
+    sys.exit(f"anolisa_tokenless {sdk.__version__} predates the SDK surface the plugin needs")
+print(sdk.__version__)
+PY
+}
+
+line()  { printf '[%s] %s\n' "$COMPONENT" "$*"; }
+field() { printf '[%s]   %-26s %s\n' "$COMPONENT" "$1" "$2"; }
+
+PREREQ_MISSING=()
+INSTALL_MISSING=()
+note_prereq_missing() { PREREQ_MISSING+=("$1"); }
+note_install_missing() { INSTALL_MISSING+=("$1"); }
+
+if [ -z "$QWENPAW_BIN" ]; then
+    QWENPAW_BIN="$(command -v qwenpaw 2>/dev/null || true)"
+fi
+
+line "${AGENT} detect"
+if [ -n "$QWENPAW_BIN" ] && [ -x "$QWENPAW_BIN" ]; then
+    field "qwenpaw CLI" "present (${QWENPAW_BIN})"
+else
+    field "qwenpaw CLI" "missing"
+    note_prereq_missing "qwenpaw CLI"
+fi
+
+if [ -d "$QWENPAW_WORKING_DIR" ]; then
+    field "qwenpaw working dir" "present (${QWENPAW_WORKING_DIR})"
+else
+    field "qwenpaw working dir" "not initialized (${QWENPAW_WORKING_DIR})"
+    note_install_missing "qwenpaw working dir"
+fi
+
+if [ -f "$PLUGIN_SRC/plugin.json" ] && [ -f "$PLUGIN_SRC/plugin.py" ] && [ -f "$PLUGIN_SRC/requirements.txt" ]; then
+    field "plugin resource" "present (${PLUGIN_SRC})"
+else
+    field "plugin resource" "missing (${PLUGIN_SRC})"
+    note_prereq_missing "plugin resource"
+fi
+
+plugin_dst="${QWENPAW_WORKING_DIR%/}/plugins/${PLUGIN_ID}"
+if [ -f "$plugin_dst/plugin.json" ]; then
+    stale=""
+    for file in plugin.json plugin.py requirements.txt; do
+        cmp -s "$PLUGIN_SRC/$file" "$plugin_dst/$file" || stale="$file"
+    done
+    if [ -n "$stale" ]; then
+        field "${PLUGIN_ID} plugin" "stale (${plugin_dst}/${stale} differs from ${PLUGIN_SRC})"
+        note_install_missing "${PLUGIN_ID} plugin"
+    else
+        field "${PLUGIN_ID} plugin" "installed (${plugin_dst})"
+    fi
+else
+    field "${PLUGIN_ID} plugin" "missing (${plugin_dst})"
+    note_install_missing "${PLUGIN_ID} plugin"
+fi
+
+if [ -n "$QWENPAW_BIN" ] && [ -x "$QWENPAW_BIN" ]; then
+    sdk_version="$(check_sdk 2>/dev/null)" && sdk_status=0 || sdk_status=$?
+    case "$sdk_status" in
+        0) field "anolisa_tokenless SDK" "importable (${sdk_version})" ;;
+        2) field "anolisa_tokenless SDK" "unverified (no Python shebang in ${QWENPAW_BIN})" ;;
+        *)
+            field "anolisa_tokenless SDK" "not importable by QwenPaw's Python (${sdk_version})"
+            note_install_missing "anolisa_tokenless SDK"
+            ;;
+    esac
+fi
+
+if [ ${#PREREQ_MISSING[@]} -gt 0 ]; then
+    line "${AGENT}: missing prerequisites (${PREREQ_MISSING[*]})"
+    exit 2
+fi
+if [ ${#INSTALL_MISSING[@]} -gt 0 ]; then
+    line "${AGENT}: not installed (ready to install)"
+    exit 1
+fi
+line "${AGENT}: ready"
+exit 0

package/adapters/tokenless/qwenpaw/scripts/install.sh

@@ -0,0 +1,98 @@
+#!/usr/bin/env bash
+# install.sh — Install the tokenless plugin into QwenPaw through its own CLI.
+#
+# `qwenpaw plugin install` copies the bundle into the QwenPaw working
+# directory, validates plugin.py, installs requirements.txt into QwenPaw's
+# Python environment, and hot-loads when QwenPaw is running. It exits 0 even
+# when it fails, so the installed files are compared with the source afterwards.
+set -euo pipefail
+
+AGENT="${ANOLISA_TARGET:-qwenpaw}"
+COMPONENT="${ANOLISA_COMPONENT:-tokenless}"
+ADAPTER_DIR="${ANOLISA_ADAPTER_DIR:-$(cd "$(dirname "$0")/../.." && pwd)}"
+# Resolve the working directory like QwenPaw: QWENPAW_WORKING_DIR, else
+# COPAW_WORKING_DIR, else a legacy ~/.copaw, else ~/.qwenpaw.
+QWENPAW_WORKING_DIR="${QWENPAW_WORKING_DIR:-${COPAW_WORKING_DIR:-}}"
+if [ -z "$QWENPAW_WORKING_DIR" ]; then
+    if [ -d "$HOME/.copaw" ]; then QWENPAW_WORKING_DIR="$HOME/.copaw"; else QWENPAW_WORKING_DIR="$HOME/.qwenpaw"; fi
+fi
+QWENPAW_BIN="${QWENPAW_BIN:-}"
+DRY_RUN="${ANOLISA_DRY_RUN:-0}"
+export PATH="${QWENPAW_HOME:-$HOME/.qwenpaw}/bin:$HOME/.local/bin:/usr/local/bin:$PATH"
+
+PLUGIN_ID="tokenless"
+PLUGIN_SRC="$ADAPTER_DIR/qwenpaw"
+PLUGIN_DST="${QWENPAW_WORKING_DIR%/}/plugins/${PLUGIN_ID}"
+
+# QwenPaw installs requirements.txt with its own interpreter (the CLI's
+# shebang). On a platform without a matching wheel pip installs nothing and
+# still exits 0, and a released wheel may predate the SDK surface the plugin
+# imports, so prove the SDK imports there. QWENPAW_PYTHON overrides the
+# interpreter; a CLI without a Python shebang (frozen build) is left unverified.
+check_sdk() {
+    local python="${QWENPAW_PYTHON:-}"
+    if [ -z "$python" ]; then
+        python="$(sed -n '1s/^#![[:space:]]*//p' "$QWENPAW_BIN")"
+        case "$python" in
+            /usr/bin/env\ *) python="$(command -v "${python#/usr/bin/env }" 2>/dev/null || true)" ;;
+        esac
+    fi
+    if [ -z "$python" ] || [ ! -x "$python" ] || ! "$python" --version 2>&1 | grep -q '^Python '; then
+        return 2
+    fi
+    "$python" - <<'PY'
+import sys
+try:
+    import anolisa_tokenless as sdk
+except ImportError as error:
+    sys.exit(f"anolisa_tokenless is not importable by {sys.executable}: {error}")
+if not hasattr(sdk, "RecoveryMethod"):
+    sys.exit(f"anolisa_tokenless {sdk.__version__} predates the SDK surface the plugin needs")
+print(sdk.__version__)
+PY
+}
+
+echo "[${COMPONENT}] Installing ${AGENT} plugin..."
+
+if [ ! -f "$PLUGIN_SRC/plugin.json" ] || [ ! -f "$PLUGIN_SRC/plugin.py" ] || [ ! -f "$PLUGIN_SRC/requirements.txt" ]; then
+    echo "[${COMPONENT}] Missing plugin.json, plugin.py or requirements.txt in $PLUGIN_SRC" >&2
+    exit 1
+fi
+
+if [ -z "$QWENPAW_BIN" ]; then
+    QWENPAW_BIN="$(command -v qwenpaw 2>/dev/null || true)"
+fi
+if [ -z "$QWENPAW_BIN" ] || [ ! -x "$QWENPAW_BIN" ]; then
+    echo "[${COMPONENT}] qwenpaw CLI not found — skipping plugin installation."
+    echo "[${COMPONENT}] Install QwenPaw first (https://qwenpaw.agentscope.io/), then run this script again."
+    exit 0
+fi
+
+if [ "$DRY_RUN" = "1" ]; then
+    echo "DRY-RUN: QWENPAW_WORKING_DIR=${QWENPAW_WORKING_DIR%/} $QWENPAW_BIN plugin install $PLUGIN_SRC --force"
+    exit 0
+fi
+
+QWENPAW_WORKING_DIR="${QWENPAW_WORKING_DIR%/}" "$QWENPAW_BIN" plugin install "$PLUGIN_SRC" --force
+
+# A failed install may leave the previous bundle in place, so the installed
+# files must match the source bundle, not merely exist.
+for file in plugin.json plugin.py requirements.txt; do
+    if ! cmp -s "$PLUGIN_SRC/$file" "$PLUGIN_DST/$file"; then
+        echo "[${COMPONENT}] qwenpaw plugin install did not install $PLUGIN_SRC/$file into $PLUGIN_DST — see the output above." >&2
+        exit 1
+    fi
+done
+
+sdk_version="$(check_sdk)" && sdk_status=0 || sdk_status=$?
+case "$sdk_status" in
+    0) echo "[${COMPONENT}] anolisa_tokenless ${sdk_version} is importable by QwenPaw's Python." ;;
+    2) echo "[${COMPONENT}] Could not find QwenPaw's Python interpreter; anolisa_tokenless import left unverified." >&2 ;;
+    *)
+        echo "[${COMPONENT}] ${sdk_version}" >&2
+        echo "[${COMPONENT}] The plugin is copied but cannot run; install a matching anolisa_tokenless wheel into QwenPaw's Python environment (see $PLUGIN_SRC/requirements.txt for the supported platforms)." >&2
+        exit 1
+        ;;
+esac
+
+echo "[${COMPONENT}] ${AGENT} plugin installed to $PLUGIN_DST (from $PLUGIN_SRC)."

package/adapters/tokenless/qwenpaw/scripts/uninstall.sh

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+# uninstall.sh — Remove the tokenless plugin from QwenPaw.
+set -euo pipefail
+
+AGENT="${ANOLISA_TARGET:-qwenpaw}"
+COMPONENT="${ANOLISA_COMPONENT:-tokenless}"
+# Resolve the working directory like QwenPaw: QWENPAW_WORKING_DIR, else
+# COPAW_WORKING_DIR, else a legacy ~/.copaw, else ~/.qwenpaw.
+PLUGIN_ID="tokenless"
+QWENPAW_WORKING_DIR="${QWENPAW_WORKING_DIR:-${COPAW_WORKING_DIR:-}}"
+if [ -z "$QWENPAW_WORKING_DIR" ]; then
+    if [ -d "$HOME/.copaw" ]; then QWENPAW_WORKING_DIR="$HOME/.copaw"; other="$HOME/.qwenpaw"; else QWENPAW_WORKING_DIR="$HOME/.qwenpaw"; other="$HOME/.copaw"; fi
+    # ~/.copaw may have appeared or vanished since the plugin was installed:
+    # prefer the default location that actually holds it.
+    if [ ! -d "$QWENPAW_WORKING_DIR/plugins/$PLUGIN_ID" ] && [ -d "$other/plugins/$PLUGIN_ID" ]; then
+        QWENPAW_WORKING_DIR="$other"
+    fi
+fi
+QWENPAW_BIN="${QWENPAW_BIN:-}"
+DRY_RUN="${ANOLISA_DRY_RUN:-0}"
+export PATH="${QWENPAW_HOME:-$HOME/.qwenpaw}/bin:$HOME/.local/bin:/usr/local/bin:$PATH"
+
+PLUGIN_DST="${QWENPAW_WORKING_DIR%/}/plugins/${PLUGIN_ID}"
+
+echo "[${COMPONENT}] Uninstalling ${AGENT} plugin..."
+
+if [ -z "$QWENPAW_BIN" ]; then
+    QWENPAW_BIN="$(command -v qwenpaw 2>/dev/null || true)"
+fi
+
+if [ "$DRY_RUN" = "1" ]; then
+    if [ -n "$QWENPAW_BIN" ] && [ -x "$QWENPAW_BIN" ]; then
+        echo "DRY-RUN: QWENPAW_WORKING_DIR=${QWENPAW_WORKING_DIR%/} $QWENPAW_BIN plugin uninstall ${PLUGIN_ID}"
+    else
+        echo "DRY-RUN: qwenpaw CLI not found; skip CLI uninstall"
+    fi
+    echo "DRY-RUN: rm -rf $PLUGIN_DST"
+    exit 0
+fi
+
+if [ ! -d "$PLUGIN_DST" ]; then
+    echo "[${COMPONENT}] no ${PLUGIN_ID} plugin is installed in $PLUGIN_DST; set QWENPAW_WORKING_DIR if QwenPaw uses another working directory."
+    exit 0
+fi
+
+# The CLI hot-unloads a running QwenPaw, prompts for confirmation, removes
+# the plugin directory, and exits 0 even when it fails: the directory still
+# being there means the plugin may still be loaded in a running QwenPaw.
+if [ -n "$QWENPAW_BIN" ] && [ -x "$QWENPAW_BIN" ]; then
+    printf 'y\n' | QWENPAW_WORKING_DIR="${QWENPAW_WORKING_DIR%/}" "$QWENPAW_BIN" plugin uninstall "$PLUGIN_ID" || true
+    if [ -f "$PLUGIN_DST/plugin.json" ]; then
+        echo "[${COMPONENT}] qwenpaw plugin uninstall did not remove $PLUGIN_DST; a running QwenPaw may still have the plugin loaded. Restart QwenPaw and run this script again." >&2
+        exit 1
+    fi
+else
+    echo "[${COMPONENT}] qwenpaw CLI not found; removing $PLUGIN_DST without hot-unloading. Restart QwenPaw if it is running." >&2
+fi
+
+rm -rf "$PLUGIN_DST"
+
+echo "[${COMPONENT}] ${AGENT} plugin uninstalled."

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "anolisa-tokenless",
   "type": "module",
-  "version": "0.7.14",
+  "version": "0.8.0",
   "description": "Token-Less — LLM token optimization toolkit (schema/response compression, command rewriting, tool readiness)",
   "license": "Apache-2.0",
   "repository": {
@@ -44,10 +44,10 @@
     "arm64"
   ],
   "optionalDependencies": {
-    "@anolisa/tokenless-linux-x64": "0.7.14",
-    "@anolisa/tokenless-linux-arm64": "0.7.14",
-    "@anolisa/tokenless-darwin-x64": "0.7.14",
-    "@anolisa/tokenless-darwin-arm64": "0.7.14"
+    "@anolisa/tokenless-linux-x64": "0.8.0",
+    "@anolisa/tokenless-linux-arm64": "0.8.0",
+    "@anolisa/tokenless-darwin-x64": "0.8.0",
+    "@anolisa/tokenless-darwin-arm64": "0.8.0"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",

package/adapters/tokenless/common/hooks/compress_toon_hook.py

@@ -1,174 +0,0 @@
-#!/usr/bin/env python3
-"""Tokenless standalone TOON encoding hook.
-
-Reads a PostToolUse JSON from stdin, encodes the tool response
-to TOON format via ``tokenless compress-toon``, and writes a
-HookOutput JSON to stdout.
-
-This is a standalone TOON-only hook for users who want pure TOON
-encoding without response compression.  The combined pipeline
-(response compression + TOON) is in compress_response_hook.py.
-
-Hook point: **PostToolUse**
-
-The agent ID is read from the TOKENLESS_AGENT_ID environment variable
-(set by the install action script).
-"""
-
-import json
-import os
-import subprocess
-import sys
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-
-from hook_utils import (
-    _TOKENLESS_FALLBACK,
-    _TOKENLESS_LOCAL_LIB,
-    _TOKENLESS_LOCAL_SHARE,
-    CONTENT_RETRIEVAL_TOOLS,
-    is_skill_file,
-    resolve_agent_id,
-    resolve_binary,
-    skip,
-    try_parse_json,
-    unwrap_string_json,
-    warn,
-)
-
-# -- constants ---------------------------------------------------------------
-
-_AGENT_ID = resolve_agent_id()
-
-# Minimum payload size for TOON encoding. TOON on small JSON saves only a
-# few characters (observed ~0.3% below ~500 chars) while the per-event
-# encode cost stays the same, so smaller responses pass through untouched.
-# This early check avoids the subprocess spawn; the compress-toon CLI
-# enforces the same threshold by default (tokenless-runtime MIN_TOON_CHARS),
-# so keep the two values in sync.
-_MIN_TOON_CHARS = 500
-
-
-# -- main --------------------------------------------------------------------
-
-
-def main() -> None:
-    # 1. Resolve binaries
-    tokenless_bin = resolve_binary(
-        "tokenless",
-        _TOKENLESS_FALLBACK,
-        _TOKENLESS_LOCAL_SHARE,
-        _TOKENLESS_LOCAL_LIB,
-    )
-    if not tokenless_bin:
-        warn("tokenless is not installed. TOON compression hook disabled.")
-        skip()
-
-    # 2. Read stdin JSON
-    try:
-        input_data = json.load(sys.stdin)
-    except (json.JSONDecodeError, EOFError, ValueError):
-        warn("failed to read PostToolUse payload. Passing through unchanged.")
-        skip()
-
-    # 3. Skip content-retrieval tools (preserve integrity)
-    tool_name = input_data.get("tool_name", "unknown")
-    if tool_name in CONTENT_RETRIEVAL_TOOLS:
-        skip()
-
-    # 4. Extract tool_response
-    tool_response_raw = input_data.get("tool_response", "")
-    if not tool_response_raw or tool_response_raw == "{}":
-        skip()
-
-    # 5. Skip skill files (YAML frontmatter)
-    if isinstance(tool_response_raw, str) and is_skill_file(tool_response_raw):
-        skip()
-
-    # 6. Normalize: unwrap string-wrapped JSON
-    if isinstance(tool_response_raw, str):
-        tool_response = unwrap_string_json(tool_response_raw)
-        if tool_response is None:
-            skip()  # Plain text, not JSON
-    elif isinstance(tool_response_raw, (dict, list)):
-        # ensure_ascii=False: the threshold below counts Unicode
-        # characters (code points), not \uXXXX escape sequences, so
-        # structured payloads are measured the same way as JSON string
-        # inputs and the OpenClaw adapter.
-        tool_response = json.dumps(
-            tool_response_raw, separators=(",", ":"), ensure_ascii=False
-        )
-    else:
-        skip()
-
-    if not tool_response:
-        skip()
-
-    # 7. Skip payloads below the TOON minimum threshold (character count,
-    # not byte length): TOON savings on small JSON are near-zero
-    if len(tool_response) < _MIN_TOON_CHARS:
-        skip()
-
-    # 8. Validate it's JSON
-    parsed = try_parse_json(tool_response)
-    if parsed is None:
-        skip()
-
-    # 9. Extract caller context
-    session_id = input_data.get("session_id", "")
-    tool_use_id = input_data.get("tool_use_id") or input_data.get(
-        "toolCallId", ""
-    )
-
-    # 10. Encode to TOON via tokenless compress-toon
-    cmd = [tokenless_bin, "compress-toon", "--agent-id", _AGENT_ID]
-    if session_id:
-        cmd.extend(["--session-id", session_id])
-    if tool_use_id:
-        cmd.extend(["--tool-use-id", tool_use_id])
-
-    try:
-        proc = subprocess.run(
-            cmd,
-            input=tool_response,
-            capture_output=True,
-            text=True,
-            timeout=10,
-        )
-    except Exception as e:
-        warn(f"TOON encoding failed: {e}. Passing through unchanged.")
-        skip()
-
-    if proc.returncode != 0:
-        detail = (proc.stderr or "").strip()[:200]
-        warn(
-            f"TOON encoding exited with code {proc.returncode}: {detail}"
-            if detail
-            else f"TOON encoding exited with code {proc.returncode}. Passing through unchanged."
-        )
-        skip()
-
-    toon_output = proc.stdout.strip()
-    if not toon_output:
-        warn("TOON encoding returned empty output. Passing through unchanged.")
-        skip()
-
-    # 11. Size guard — skip if TOON output is not smaller
-    before_chars = len(tool_response)
-    after_chars = len(toon_output)
-    if after_chars >= before_chars:
-        skip()
-
-    # 12. Build response
-    output = {
-        "suppressOutput": True,
-        "hookSpecificOutput": {
-            "hookEventName": "PostToolUse",
-            "additionalContext": toon_output,
-        },
-    }
-    print(json.dumps(output, ensure_ascii=False))
-
-
-if __name__ == "__main__":
-    main()