@tokenade/cli 0.8.10 → 0.8.12

package/README.md

@@ -108,7 +108,7 @@ When reporting, please include your OS, `tokenade --version`, your coding agent,
 | Command | What it does |
 |---|---|
 | `install` | Register Tokenade with your detected agent (hooks). Flags: `--only <agent>`, `--with-hook`, `--with-claude-md`, `--with-lsp-enforcement-hook`, `--with-brevity-skill`, `--dry-run`. |
-| `uninstall [aliases]` | Remove the integration. `uninstall aliases` removes only the shell proxy. `--dry-run` to preview. |
+| `uninstall` | Remove the integration (restores wrapped MCP servers). `--dry-run` to preview. |
 | `login` | Activate via browser device-flow — no key to type. |
 | `activate <key>` | Link this machine to a tokenade.net license (free or paid) with a key. |
 | `upgrade` | Self-update in place (aliases: `self-update`). `--on`/`--off` toggles the 24h background updater. |
@@ -141,24 +141,27 @@ When reporting, please include your OS, `tokenade --version`, your coding agent,
 | Command | What it does |
 |---|---|
 | `wrap <cmd>` | Run a command through the auto-detected compactor (default for noisy commands). |
-| `proxy <cmd...>` | Run a command and emit compressed output (logs savings). |
 | `raw <cmd...>` | Run a command **without** compaction (aliases: `bypass`, `noproxy`). |
 | `filter <cmd...>` | Filter stdin as if it were produced by `<cmd>`. |
 | `execute --lang L --script CODE` | Sandboxed "think-in-code" runner (bash/python/node/jq/awk/ruby/perl) — returns only stdout, redacted + compacted, keeps raw data out of context. |
 | `shell-init` | Print the shell proxy fragment for your shell (`--shell …`, `--all`). |
 | `shellwrap` | TTY-aware alias target for csh/tcsh + cmd.exe. |
 
-### Format compactors
+### Read & compact content
 
-`auto <file|->` auto-detects the format and dispatches to the right compactor — **the one to call** if unsure. Or target a format directly (all read `<file>` or `-` for stdin):
+`read <file|->` is the content entry point: it auto-detects a blob's format and
+dispatches to the right compactor. Point it at a file (or `-` for stdin) carrying
+JSON, YAML, CSV/TSV, NDJSON, logs, unified diffs, stack traces, env dumps,
+markdown, lockfiles, SQL, OpenAPI/GraphQL, build & CI output, and many more —
+the format is detected automatically. Live command output is compacted the same
+way through `wrap`.
 
-| Domain | Commands |
+| Command | What it does |
 |---|---|
-| **Data & config** | `json` · `csv` · `tsv` · `yaml` · `ndjson` · `lock` · `sql` · `env` · `md` · `openapi` · `graphql` · `sourcemap` |
-| **Logs & traces** | `logs` · `access` · `journal` · `container-logs` · `ghactions` · `stack` · `strace` · `tcpdump` · `metrics` |
-| **Build / VCS / infra** | `diff` · `gitlog` · `archive` · `cargo-bench` · `jvmbuild` (aliases `mvn`/`gradle`/`sbt`) · `pkginstall` · `terraform` · `ansible` · `k8s-manifest` · `describe` · `systemd` |
-| **System & network** | `table` · `disk` · `netstat` · `dns` · `vmstat` · `filelist` · `grep` |
-| **Web & docs** | `web` · `serp` (aliases `google`/`bing`/`ddg`) · `snapshot` · `stealth` · `curl` · `docs` · `pdf` · `notebook` |
+| `read <file\|->` | Auto-detect a blob's format and compact it (**the content entry point**). |
+| `web <file\|->` | Compact an HTML page → markdown (real web content). |
+| `serp <file\|->` | Compact raw SERP HTML (aliases: `google`/`bing`/`ddg`). |
+| `snapshot <file\|->` | Compact a Playwright accessibility-tree snapshot. |
 
 **Your own compactors.** `add-compactor --file <rules.toml>` teaches Tokenade to fold output from a command it doesn't cover yet (alias `add-filter`); `add-compactor --list` shows the ones you've added, and `add-compactor --help` prints the file format. Filters shipped INSIDE a repo (`.tokenade/filters/`) apply only after you approve them once with `trust-filters` — a cloned project can't silently rewrite your outputs.
 
@@ -210,7 +213,7 @@ When reporting, please include your OS, `tokenade --version`, your coding agent,
 
 ## Examples & recipes
 
-Real commands, real (trimmed) output — so both humans **and coding agents** know exactly what each command does and when to reach for it. Every compactor reads a file **or `-` for stdin**, so you can pipe: `some-noisy-cmd | tokenade auto -`.
+Real commands, real (trimmed) output — so both humans **and coding agents** know exactly what each command does and when to reach for it. `read` (and every format-aware entry point) reads a file **or `-` for stdin**, so you can pipe: `some-noisy-cmd | tokenade read -`.
 
 ### Setup & account
 
@@ -263,7 +266,7 @@ $ tokenade incompatibilities
 [redundant] rtk
   Output-filtering CLI proxy (filters/compresses bash output)
   → binary at ~/.cargo/bin/rtk
-  fix: Tokenade subsumes rtk: `tokenade proxy <cmd>` does the same AND
+  fix: Tokenade subsumes rtk: `tokenade wrap '<cmd>'` does the same AND
        auto-detects 48 formats — usually with better savings.
 
 Run `tokenade install` to interactively migrate & fix the [redundant] /
@@ -345,20 +348,20 @@ $ tokenade execute --lang python --script 'print(sum(range(101)))'
 5050
 ```
 
-**`proxy <cmd…>`** — like `wrap`, logs savings to your ledger. **`raw <cmd…>`** — run *without* compaction (escape hatch). **`filter <cmd…>`** — treat stdin as if produced by `<cmd>`. **`shell-init`** — print the shell fragment that auto-wraps noisy commands:
+**`raw <cmd…>`** — run *without* compaction (escape hatch). **`filter <cmd…>`** — treat stdin as if produced by `<cmd>`. **`shell-init`** — print the shell fragment that auto-wraps noisy commands:
 ```text
 $ eval "$(tokenade shell-init)"   # add to ~/.zshrc — git/cargo/kubectl/… auto-compact
 ```
 
-### Format & output compactors
+### Read & compact content
 
-Tokenade includes a family of format-aware compactors — the full list is in
-the [CLI reference](#-cli-reference--every-command) above. Each reads a file or
-`-` (stdin); when unsure, let Tokenade pick:
+`read` auto-detects a blob's format and dispatches to the right compactor.
+It reads a file or `-` (stdin); live command output is folded the same way
+through `wrap`:
 
 ```sh
-tokenade auto <file>      # auto-detect and compact
-some-noisy-cmd | tokenade auto -   # …or pipe stdin
+tokenade read <file>      # auto-detect and compact
+some-noisy-cmd | tokenade read -   # …or pipe stdin
 
 tokenade add-compactor --file my-rules.toml   # teach Tokenade a new compactor
 tokenade add-compactor --list                 # list the ones you've added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tokenade/cli",
-  "version": "0.8.10",
+  "version": "0.8.12",
   "description": "Tokenade \u2014 cut your AI coding agent's token bill. Installs the Tokenade CLI (a local, paid token-reduction tool; activate via your browser).",
   "homepage": "https://tokenade.net",
   "license": "UNLICENSED",
@@ -8,7 +8,8 @@
     "tokenade": "bin/tokenade.js"
   },
   "scripts": {
-    "postinstall": "node install.js"
+    "postinstall": "node install.js",
+    "preuninstall": "node uninstall.js"
   },
   "dependencies": {
     "tar": "^7.5.16"
@@ -16,6 +17,7 @@
   "files": [
     "bin/",
     "install.js",
+    "uninstall.js",
     "README.md"
   ],
   "engines": {

package/uninstall.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+/**
+ * preuninstall — run tokenade's own cleanup BEFORE npm deletes the package
+ * files, so that `npm uninstall -g @tokenade/cli` actually restores the
+ * machine (unwraps MCPs, strips hooks/CLAUDE.md/shell-proxy, and wipes
+ * ~/.tokenade + ~/.cache/tokenade) instead of orphaning integration that then
+ * spawns a missing binary on every tool call.
+ *
+ * We locate the SAME vendored binary that install.js (postinstall) dropped in
+ * ./vendor and invoke it as `tokenade uninstall --headless`:
+ *   --headless → no banner, no next-step guidance, and it does NOT touch the
+ *                binary itself (npm removes ./vendor right after this script).
+ *
+ * FAIL-OPEN by construction: every failure path (missing binary, spawn error,
+ * timeout, non-zero exit) is swallowed and we ALWAYS `process.exit(0)`. A
+ * cleanup that can't run must never block `npm uninstall` or leave the user
+ * unable to remove the package.
+ *
+ * npm lifecycle note: `preuninstall` runs on `npm uninstall` / `npm rm` /
+ * `npm remove` (local AND `-g`), and fires while the package files still
+ * exist. Caveats we accept: it is skipped when the user passes
+ * `--ignore-scripts` (or sets that config), and yarn/pnpm do not guarantee it.
+ * In those cases the binary is simply gone and its self-heal / a future
+ * `tokenade uninstall` covers the leftover integration.
+ */
+
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+
+// Bound the child so a wedged cleanup can never hang `npm uninstall`.
+const CLEANUP_TIMEOUT_MS =
+	Number(process.env.TOKENADE_UNINSTALL_TIMEOUT_MS) || 20000;
+
+function binaryPath() {
+	const name = process.platform === "win32" ? "tokenade.exe" : "tokenade";
+	return path.join(__dirname, "vendor", name);
+}
+
+function main() {
+	const bin = binaryPath();
+	// Missing binary (never installed, --ignore-scripts, half-install) → nothing
+	// to run; npm still removes the package. Not an error.
+	if (!fs.existsSync(bin)) {
+		return;
+	}
+	try {
+		const res = spawnSync(bin, ["uninstall", "--headless"], {
+			stdio: "inherit",
+			timeout: CLEANUP_TIMEOUT_MS,
+			// A cleanup crash must not surface as a throw here.
+			windowsHide: true,
+		});
+		if (res.error) {
+			console.error(
+				`  tokenade cleanup skipped (${res.error.message}); ` +
+					"run `tokenade uninstall` manually if any integration lingers.",
+			);
+		}
+	} catch (e) {
+		console.error(`  tokenade cleanup skipped (${e && e.message});`);
+	}
+}
+
+try {
+	main();
+} catch (e) {
+	// Absolute backstop — nothing above should throw, but never let it matter.
+	try {
+		console.error(`  tokenade cleanup skipped (${e && e.message});`);
+	} catch {}
+}
+// ALWAYS succeed: npm must be free to remove the package.
+process.exit(0);