@miller-tech/uap 1.222.0 → 2.1.4

package/scripts/setup/install-rtk.sh

@@ -1,184 +0,0 @@
-#!/usr/bin/env bash
-# RTK (Rust Token Killer) Installation Script for UAP
-# Auto-detects OS and installs RTK via appropriate method
-
-set -euo pipefail
-
-echo "🔧 Installing RTK (Rust Token Killer)..."
-echo "   Reduces LLM token consumption by 60-90% on CLI commands"
-echo ""
-
-# Detect OS and architecture
-detect_os() {
-    if [[ "$(uname -s)" == "Darwin" ]]; then
-        echo "macOS"
-    elif [[ "$(uname -s)" == "Linux" ]]; then
-        echo "Linux"
-    elif [[ "$(uname -s)" =~ MINGW.* || "$(uname -s)" =~ MSYS* ]]; then
-        echo "Windows"
-    else
-        echo "Unknown"
-    fi
-}
-
-detect_arch() {
-    local arch=$(uname -m)
-    case $arch in
-        x86_64) echo "x86_64" ;;
-        arm64|aarch64) echo "arm64" ;;
-        *) echo "$arch" ;;
-    esac
-}
-
-OS=$(detect_os)
-ARCH=$(detect_arch)
-
-echo "Detected: $OS ($ARCH)"
-echo ""
-
-# Check if Homebrew is available (macOS/Linux)
-check_brew() {
-    command -v brew &> /dev/null && echo "yes" || echo "no"
-}
-
-# Check if cargo is installed
-check_cargo() {
-    command -v cargo &> /dev/null && echo "yes" || echo "no"
-}
-
-# Check if RTK is already installed
-check_rtk_installed() {
-    command -v rtk &> /dev/null && echo "yes" || echo "no"
-}
-
-RTK_INSTALLED=$(check_rtk_installed)
-
-if [[ "$RTK_INSTALLED" == "yes" ]]; then
-    CURRENT_VERSION=$(rtk --version 2>&1 | head -1)
-    echo "ℹ RTK is already installed: $CURRENT_VERSION"
-    echo ""
-    read -p "Do you want to upgrade to the latest version? [y/N] " -n 1 -r
-    echo ""
-    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
-        echo "Skipping installation."
-        exit 0
-    fi
-fi
-
-# Installation methods (in order of preference)
-install_methods=(
-    "homebrew"
-    "cargo"
-    "curl_install"
-)
-
-INSTALL_SUCCESS=false
-
-for method in "${install_methods[@]}"; do
-    echo "📦 Trying installation method: $method"
-    
-    case $method in
-        homebrew)
-            if [[ "$OS" == "macOS" ]] || (check_brew == "yes"); then
-                echo "   Installing via Homebrew..."
-                if brew install rtk &> /dev/null; then
-                    INSTALL_SUCCESS=true
-                    break
-                fi
-            fi
-            ;;
-            
-        cargo)
-            if check_cargo == "yes"; then
-                echo "   Installing via Cargo..."
-                if cargo install --git https://github.com/rtk-ai/rtk --quiet 2>&1; then
-                    INSTALL_SUCCESS=true
-                    break
-                fi
-            fi
-            ;;
-            
-        curl_install)
-            if [[ "$OS" == "macOS" ]] || [[ "$OS" == "Linux" ]]; then
-                echo "   Installing via curl..."
-                TEMP_DIR=$(mktemp -d)
-                cd "$TEMP_DIR"
-                
-                # Download appropriate binary based on OS/arch
-                if [[ "$ARCH" == "arm64" ]]; then
-                    BINARY="rtk-aarch64-apple-darwin.tar.gz"
-                else
-                    BINARY="rtk-x86_64-apple-darwin.tar.gz"
-                fi
-                
-                if [[ "$OS" == "Linux" ]]; then
-                    if [[ "$ARCH" == "arm64" ]]; then
-                        BINARY="rtk-aarch64-unknown-linux-gnu.tar.gz"
-                    else
-                        BINARY="rtk-x86_64-unknown-linux-musl.tar.gz"
-                    fi
-                fi
-                
-                echo "   Downloading: $BINARY"
-                
-                if curl -fsSL "https://github.com/rtk-ai/rtk/releases/latest/download/$BINARY" -o rtk.tar.gz 2>&1; then
-                    tar -xzf rtk.tar.gz
-                    chmod +x rtk
-                    
-                    # Move to local bin or PATH
-                    if [[ -d "$HOME/.local/bin" ]] || echo "$PATH" | grep -q "$HOME/.local/bin"; then
-                        mkdir -p "$HOME/.local/bin"
-                        mv rtk "$HOME/.local/bin/"
-                        echo "   Installed to: $HOME/.local/bin/rtk"
-                    else
-                        sudo mkdir -p /usr/local/bin
-                        sudo mv rtk /usr/local/bin/
-                        echo "   Installed to: /usr/local/bin/rtk"
-                    fi
-                    
-                    INSTALL_SUCCESS=true
-                    cd ..
-                    rm -rf "$TEMP_DIR"
-                    break
-                fi
-            fi
-            ;;
-    esac
-    
-    echo "   ✗ Failed: $method"
-done
-
-# Verify installation
-if [[ "$INSTALL_SUCCESS" == "true" ]]; then
-    if command -v rtk &> /dev/null; then
-        VERSION=$(rtk --version 2>&1 | head -1)
-        echo ""
-        echo "✅ RTK installed successfully!"
-        echo "   Version: $VERSION"
-        echo ""
-        echo "📚 Next steps:"
-        echo "   1. Initialize hook for Claude Code:"
-        echo "      rtk init --global"
-        echo ""
-        echo "   2. Verify installation:"
-        echo "      rtk gain"
-        echo ""
-        echo "   3. View token savings:"
-        echo "      rtk gain --graph"
-        echo ""
-    else
-        echo "❌ Installation completed but RTK binary not found in PATH"
-        echo "   Please ensure $HOME/.local/bin is in your PATH:"
-        echo '   echo '\''export PATH="$HOME/.local/bin:$PATH"'\'' >> ~/.bashrc'
-        exit 1
-    fi
-else
-    echo ""
-    echo "❌ All installation methods failed"
-    echo ""
-    echo "Manual installation options:"
-    echo "  1. Homebrew (macOS/Linux): brew install rtk"
-    echo "  2. Cargo: cargo install --git https://github.com/rtk-ai/rtk"
-    echo "  3. Pre-built binaries: https://github.com/rtk-ai/rtk/releases"
-    exit 1
-fi

package/src/policies/enforcers/rtk_wrap.py

@@ -1,205 +0,0 @@
-#!/usr/bin/env python3
-"""rtk-wrap enforcer: heavy CLIs must be invoked via rtk."""
-from __future__ import annotations
-import re
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).parent))
-from _common import emit, parse_cli  # noqa: E402
-
-WRAPPED = ("git", "kubectl", "docker", "docker-compose", "npm", "pnpm", "yarn", "helm", "terraform")
-RTK_META = re.compile(r"^\s*rtk\s+(gain|discover|proxy|--version|-V|--help)\b")
-ALREADY_WRAPPED = re.compile(r"^\s*rtk\s+\S+")
-
-
-# `rtk npm`/`rtk pnpm`/`rtk yarn` map to `<pm> run` (filtered script output). The
-# subcommands below are NOT script runners, so `rtk npm view` would mangle to
-# `npm run view`. Route them through `rtk proxy` instead (still tracked).
-PM_BUILTINS = {
-    "install", "i", "ci", "add", "view", "info", "show", "publish", "pack",
-    "audit", "outdated", "ls", "list", "link", "unlink", "dedupe", "prune",
-    "exec", "dlx", "init", "create", "ping", "whoami", "login", "logout",
-    "version", "deprecate", "dist-tag", "owner", "access", "search", "update",
-    "uninstall", "remove", "rm", "rebuild", "root", "bin", "config", "cache",
-    "doctor", "fund", "why", "store", "set", "get",
-}
-PMS = ("npm", "pnpm", "yarn")
-
-
-# Flags that say "I am going to PARSE this". rtk rewrites output for human
-# reading and does not notice these, so the caller gets prose where it asked
-# for records. Verified against real git in this repo:
-#   worktree list --porcelain  46 entries -> 0 through rtk
-#   branch --format=...        55 refs    -> 142 lines, wrong set
-#   diff --name-only           3 paths    -> 3 paths + a "--- Changes ---" block
-#   status --porcelain         12 lines   -> 11
-# `rtk proxy` runs it unfiltered and is byte-exact on every one.
-MACHINE_FLAGS = (
-    "--porcelain",
-    "--format",
-    "--pretty",
-    "--name-only",
-    "--name-status",
-    "--numstat",
-    "--raw",
-    "-z",
-)
-# NOT --oneline: it is a reading convenience, not a parse signal, and
-# test/rtk-wrap.test.ts contracts it as accepted. Anything meaning to parse log
-# output uses --format or --pretty, which are covered above. rtk does reformat
-# `log --oneline`, so a caller that parses it gets altered text -- a narrow
-# residual, accepted rather than taxing one of the most common human git calls.
-
-# Subcommand forms rtk restructures even without one of those flags. Kept to
-# what was actually measured rather than guessed, because every entry here is
-# friction for a human-readable call that would have been fine.
-MACHINE_FORMS = {
-    "branch": ("-r", "-a", "--merged", "--no-merged"),
-    "worktree": ("list",),
-    "stash": ("list",),
-}
-
-# rtk's docker handlers only recognise the BARE subcommand. Any flag on
-# `docker ps` or `docker logs` makes rtk print "[rtk: parse failed, running
-# raw]" ahead of otherwise-correct raw output. The DATA is fine -- but that
-# line reads as a tool error, and a model that cannot act on it retries: it
-# drove a live ERROR-LOOP on 2026-08-25 ("same failure x3,
-# sig='[rtk: parse failed, running raw]'"). `rtk proxy` runs the same command
-# unfiltered with no such line, and is still counted in the savings ledger.
-#
-# Measured against rtk 0.27.0 on 2026-08-25 -- listed rather than guessed,
-# because every entry here is friction for a call that would have been fine:
-#   docker ps                        ok
-#   docker ps -a                     parse failed
-#   docker ps --filter name=uap      parse failed
-#   docker ps --format '{{.Names}}'  parse failed
-#   docker images                    ok
-#   docker logs --tail 1 <id>        parse failed
-#   docker inspect <id>              ok
-# So the trigger is the SUBCOMMAND plus any flag at all, not a specific flag.
-DOCKER_FLAG_INTOLERANT = ("ps", "logs")
-
-
-def docker_wants_proxy(tokens: list[str]) -> bool:
-    """Is this a docker call rtk will fail to parse (bare form only)?"""
-    args = [t for t in tokens if t.split("/")[-1] != "docker"]
-    sub_cmd = next((t for t in args if not t.startswith("-")), "")
-    if sub_cmd not in DOCKER_FLAG_INTOLERANT:
-        return False
-    return any(t.startswith("-") for t in args)
-
-
-def wants_machine_output(tokens: list[str]) -> bool:
-    """Is this git invocation asking for output something will parse?"""
-    args = [t for t in tokens if t != "git"]
-    for tok in args:
-        if tok in MACHINE_FLAGS or tok.split("=")[0] in MACHINE_FLAGS:
-            return True
-    sub_cmd = next((t for t in args if not t.startswith("-")), "")
-    return any(t in MACHINE_FORMS.get(sub_cmd, ()) for t in args)
-
-
-# A command is a sequence of STATEMENTS; each one invokes its own binary.
-_STATEMENT_SPLIT_RE = re.compile(r"&&|\|\||[;|&\n]")
-
-
-def _leading_binary(statement: str) -> tuple[str, list[str]] | None:
-    """The binary a statement invokes, plus its tokens — or None.
-
-    Skips env assignments (`FOO=bar cmd`) and shell grouping, then reads the
-    FIRST real word. That word is what the shell executes; a wrapped CLI
-    appearing later is an argument, not an invocation.
-    """
-    tokens = statement.replace("(", " ").replace("{", " ").split()
-    idx = 0
-    while idx < len(tokens) and "=" in tokens[idx].split("/")[0]:
-        idx += 1  # env assignment prefix
-    if idx >= len(tokens):
-        return None
-    return tokens[idx].split("/")[-1], tokens[idx:]
-
-
-def main() -> None:
-    op, args = parse_cli()
-    cmd = (args.get("command") or args.get("cmd") or "").strip()
-    if not cmd or op.lower() != "bash":
-        emit(True, "not a Bash command")
-
-    # Evaluate each statement on its own.
-    #
-    # Whole-command matching got this wrong in BOTH directions. It only accepted
-    # `rtk` at the very start, so `cd /srv/app && rtk git log` — already wrapped —
-    # was refused, with a suggestion that prefixed rtk to the entire line and
-    # produced nonsense like `rtk cd /srv/app; git log`. And it scanned only the
-    # first three tokens, so `cd /srv/app && git log` slipped through entirely:
-    # `git` sat at index 3. That is a bypass, not just noise — any bare invocation
-    # could be hidden behind a `cd`. Reading the leading binary of each statement
-    # fixes both, because that is what the shell actually runs.
-    for raw in _STATEMENT_SPLIT_RE.split(cmd):
-        statement = raw.strip()
-        if not statement:
-            continue
-        found = _leading_binary(statement)
-        if not found:
-            continue
-        bin_name, tokens = found
-
-        # A statement led by `rtk` is normally fine: in `rtk git log` the
-        # leading binary is rtk and `git` is its argument. One exception --
-        # `rtk git <machine-readable>` is the corrupting combination, and
-        # skipping every rtk-led statement is what let it through the gate.
-        if bin_name == "rtk":
-            rest = [t for t in tokens[1:] if not t.startswith("-")]
-            if rest[:1] == ["docker"] and docker_wants_proxy(tokens[1:]):
-                emit(
-                    False,
-                    "rtk-wrap: rtk only parses the bare form of this docker "
-                    "subcommand; with any flag it prefixes "
-                    "'[rtk: parse failed, running raw]' to the output, which "
-                    "reads as an error and has driven retry loops. Use: "
-                    "rtk proxy " + " ".join(tokens[1:]),
-                    bin="rtk",
-                )
-            if rest[:1] == ["git"] and wants_machine_output(tokens[1:]):
-                emit(
-                    False,
-                    "rtk-wrap: rtk reformats output for reading, so a git command "
-                    "that asked for machine-readable output comes back as prose "
-                    "(measured: `worktree list --porcelain` returns 0 entries "
-                    "through rtk, 46 through git). Use: rtk proxy "
-                    + " ".join(tokens[1:]),
-                    bin="rtk",
-                )
-            continue
-
-        if bin_name not in WRAPPED:
-            continue
-
-        wrapper = "rtk"
-        if bin_name == "git" and wants_machine_output(tokens):
-            # Still through rtk, so the call is still tracked -- just unfiltered.
-            wrapper = "rtk proxy"
-        elif bin_name == "docker" and docker_wants_proxy(tokens):
-            wrapper = "rtk proxy"
-        if bin_name in PMS:
-            sub = ""
-            for nxt in tokens[1:]:
-                if not nxt.startswith("-"):
-                    sub = nxt.split("/")[-1]
-                    break
-            if sub in PM_BUILTINS:
-                wrapper = "rtk proxy"
-        # Suggest fixing THIS statement, not the whole line.
-        emit(
-            False,
-            f"rtk-wrap: '{bin_name}' must be invoked via rtk. "
-            f"Use: {wrapper} {statement}",
-            bin=bin_name,
-        )
-
-    emit(True, "no unwrapped CLI in any statement")
-
-
-if __name__ == "__main__":
-    main()

package/src/policies/schemas/policies/rtk-wrap.md

@@ -1,50 +0,0 @@
-# rtk-wrap
-
-**Category**: custom
-**Level**: RECOMMENDED
-**Default**: off
-**Enforcement Stage**: pre-exec
-**Tags**: rtk, tokens, efficiency
-
-## Rule
-
-Opt-in. Enable with `uap policy enable <id>`; disable with `uap policy disable <id>`.
-
-When enabled, these commands SHOULD be invoked via the `rtk` wrapper rather than directly: `git`, `kubectl`, `docker`, `docker-compose`, `npm`, `pnpm`, `yarn`, `helm`, `terraform`.
-
-Exceptions: `rtk` meta-commands (`rtk gain`, `rtk discover`, `rtk proxy`, `rtk --version`), and any invocation whose output will be PARSED — those must use `rtk proxy` (see below).
-
-## Why
-
-RTK delivers 60–90% token reduction on dev ops (`~/.claude/RTK.md`). Missing the wrap = proportional context waste.
-
-## Why it is off by default
-
-rtk rewrites command output for reading, and does not detect when the caller
-asked for machine-readable output. Measured against real git in this repo:
-
-| command | git | via rtk |
-|---|---|---|
-| `worktree list --porcelain` | 46 entries | **0 entries** |
-| `branch --format='%(refname:short)'` | 55 refs | 142 lines, wrong set |
-| `diff --name-only HEAD` | 3 paths | 3 paths + a `--- Changes ---` block |
-| `status --porcelain` | 12 lines | 11 |
-
-`rtk proxy git ...` is byte-exact on all of them.
-
-While this policy was REQUIRED, that mangled output was what every agent read.
-An agent parsing `^worktree ` out of `rtk git worktree list --porcelain` sees
-nothing and concludes there are no worktrees — during a prune, the difference
-between "skip" and "delete". The enforcer now routes parsed invocations to
-`rtk proxy`, but the underlying trade is a judgement call, so it is offered
-rather than imposed.
-
-## Enforcement
-
-Python enforcer `rtk_wrap.py` inspects the Bash command string and blocks if a wrapped binary is invoked without the `rtk ` prefix.
-
-```rules
-- title: "Wrap heavy CLIs with rtk"
-  keywords: [bash, shell, git, kubectl, docker, npm, pnpm, yarn, helm, terraform]
-  antiPatterns: [raw-kubectl, raw-git, raw-docker, raw-npm]
-```

package/tools/agents/tests/test_rtk_wrap.py

@@ -1,151 +0,0 @@
-"""rtk-wrap: heavy CLIs go through rtk, but PARSED output must not.
-
-rtk rewrites command output for token savings and does not notice when the
-caller asked for machine-readable output. Measured against real git in this
-repo:
-
-    git worktree list --porcelain    46 entries  ->  rtk: 0 entries
-    git branch --format='%(refname:short)'  55 refs -> rtk: 142 lines, wrong set
-    git diff --name-only HEAD        3 paths     ->  rtk: 3 paths + "--- Changes ---"
-    git status --porcelain           12 lines    ->  rtk: 11
-    git branch -r / --merged, stash list, log --oneline : all differ
-
-`rtk proxy` runs the command unfiltered and was byte-exact on all eight.
-
-This matters because the policy makes rtk mandatory, so the mangled output is
-what every agent in this repo reads. Parsing `^worktree ` out of
-`rtk git worktree list --porcelain` yields NOTHING, and an agent pruning
-worktrees on that basis concludes there are none to protect.
-
-The enforcer had no tests before this file, which is how `rtk git
-<machine-readable>` -- the corrupting combination -- stayed invisible: every
-statement led by `rtk` was skipped without looking at what followed.
-"""
-
-from __future__ import annotations
-
-import json
-import subprocess
-import sys
-import unittest
-from pathlib import Path
-
-REPO = Path(__file__).resolve().parents[3]
-ENFORCER = REPO / "src" / "policies" / "enforcers" / "rtk_wrap.py"
-
-
-def gate(command: str) -> tuple[bool, str]:
-    r = subprocess.run(
-        [sys.executable, str(ENFORCER), "--operation", "Bash",
-         "--args", json.dumps({"command": command})],
-        capture_output=True, text=True, timeout=60,
-    )
-    try:
-        payload = json.loads(r.stdout or "{}")
-    except json.JSONDecodeError:
-        return True, f"unparseable: {r.stdout[:120]}"
-    return payload.get("allowed", True), payload.get("reason", "")
-
-
-class MachineReadableGitMustBypassTheFilter(unittest.TestCase):
-    """The verdicts that stop an agent reading prose as records."""
-
-    MACHINE = [
-        "git worktree list --porcelain",
-        "git status --porcelain",
-        "git branch --format='%(refname:short)'",
-        "git diff --name-only HEAD",
-        "git log --pretty=%H",
-        # NOT `log --oneline`: a reading convenience, not a parse signal.
-        # test/rtk-wrap.test.ts contracts it as accepted, and anything that
-        # means to parse log output uses --format or --pretty.
-        "git diff --numstat HEAD",
-        "git ls-files -z",
-        "git branch -r",
-        "git branch --merged origin/master",
-        "git stash list",
-    ]
-
-    def test_bare_git_asking_for_records_is_sent_to_rtk_proxy(self):
-        for cmd in self.MACHINE:
-            with self.subTest(cmd=cmd):
-                allowed, reason = gate(cmd)
-                self.assertFalse(allowed, cmd)
-                self.assertIn("rtk proxy", reason, f"{cmd}: must name the unfiltered form")
-
-    def test_rtk_git_asking_for_records_is_refused(self):
-        """The combination that used to sail through.
-
-        Statements led by `rtk` were skipped without inspecting the rest, so
-        the one form that actually corrupts data was the one the gate ignored.
-        """
-        for cmd in self.MACHINE:
-            with self.subTest(cmd=cmd):
-                allowed, reason = gate("rtk " + cmd)
-                self.assertFalse(allowed, f"rtk {cmd} returns mangled output")
-                self.assertIn("rtk proxy", reason)
-
-    def test_rtk_proxy_is_accepted(self):
-        for cmd in self.MACHINE:
-            with self.subTest(cmd=cmd):
-                allowed, _ = gate("rtk proxy " + cmd)
-                self.assertTrue(allowed, f"rtk proxy {cmd} is the correct form")
-
-
-class HumanReadableGitIsUnaffected(unittest.TestCase):
-    """rtk's entire purpose is these, and the rule must not tax them."""
-
-    def test_ordinary_git_still_wants_plain_rtk(self):
-        for cmd in ("git status", "git log -5", "git diff", "git branch", "git show HEAD"):
-            with self.subTest(cmd=cmd):
-                allowed, reason = gate(cmd)
-                self.assertFalse(allowed, cmd)
-                self.assertIn("rtk", reason)
-                self.assertNotIn(
-                    "rtk proxy", reason,
-                    f"{cmd} is human-readable; sending it to proxy forfeits the token saving",
-                )
-
-    def test_already_wrapped_human_forms_pass(self):
-        for cmd in ("rtk git status", "rtk git log -5", "rtk git diff", "rtk git branch"):
-            with self.subTest(cmd=cmd):
-                allowed, _ = gate(cmd)
-                self.assertTrue(allowed, cmd)
-
-
-class ExistingBehaviourIsPreserved(unittest.TestCase):
-    """The regressions this enforcer already carries scars from."""
-
-    def test_a_wrapped_cli_behind_a_cd_is_still_caught(self):
-        allowed, _ = gate("cd /srv/app && git log")
-        self.assertFalse(allowed, "a bare invocation hidden behind cd is a bypass")
-
-    def test_an_already_wrapped_statement_behind_a_cd_passes(self):
-        allowed, _ = gate("cd /srv/app && rtk git log")
-        self.assertTrue(allowed)
-
-    def test_npm_builtins_still_route_to_proxy(self):
-        allowed, reason = gate("npm view lodash")
-        self.assertFalse(allowed)
-        self.assertIn("rtk proxy", reason, "rtk npm view would mangle to `npm run view`")
-
-    def test_npm_scripts_still_route_to_plain_rtk(self):
-        allowed, reason = gate("npm test")
-        self.assertFalse(allowed)
-        self.assertNotIn("rtk proxy", reason)
-
-    def test_a_wrapped_cli_as_an_argument_is_not_an_invocation(self):
-        allowed, _ = gate("echo git status")
-        self.assertTrue(allowed, "git here is an argument to echo, not a command")
-
-    def test_non_bash_operations_are_ignored(self):
-        r = subprocess.run(
-            [sys.executable, str(ENFORCER), "--operation", "Edit",
-             "--args", json.dumps({"command": "git status --porcelain"})],
-            capture_output=True, text=True, timeout=60,
-        )
-        self.assertTrue(json.loads(r.stdout)["allowed"])
-
-
-if __name__ == "__main__":
-    unittest.main()