@xynogen/pix-optimizer 1.0.0

package/src/rtk.ts

@@ -0,0 +1,285 @@
+/**
+ * Simple RTK Integration
+ * 
+ * 1. Injects RTK system prompt (tells model to prefix commands with rtk)
+ * 2. Rewrites bash commands to add rtk prefix when model forgets
+ * 3. Falls back gracefully if rtk binary is missing
+ */
+
+import type {
+	ExtensionAPI,
+	ExtensionCommandContext,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import type { OptimizerHandle, OptimizerStatus } from "./status.ts";
+
+/**
+ * Minimal structural shape of the SDK `tool_call` event we care about.
+ * Mirrors `BashToolCallEvent` from the SDK without importing it, so the
+ * rewrite logic stays unit-testable with plain objects.
+ */
+export interface BashCallEvent {
+	toolName: string;
+	input: { command?: unknown; [k: string]: unknown };
+}
+
+/**
+ * Pure decision + mutation step for the `tool_call` hook.
+ *
+ * Given a tool-call event and whether RTK is available, mutate `event.input`
+ * in place (the SDK's only supported way to patch tool args) when the command
+ * is a rewritable bash command. Returns true if the command was rewritten.
+ *
+ * Extracted from the hook closure so the integration is directly testable
+ * without a live ExtensionAPI.
+ */
+export function applyRtkRewrite(
+	event: BashCallEvent,
+	opts: { enabled: boolean; rtkAvailable: boolean },
+): boolean {
+	if (!opts.enabled) return false;
+	if (!opts.rtkAvailable) return false;
+	if (event.toolName !== "bash") return false;
+
+	const command = event.input?.command;
+	if (typeof command !== "string" || !command) return false;
+
+	const rewritten = rewriteChain(command);
+	if (rewritten === command) return false;
+
+	event.input.command = rewritten;
+	return true;
+}
+
+const RTK_SYSTEM_PROMPT = `# RTK — token-optimized command wrapper
+
+Prefix shell commands with \`rtk\` (e.g. \`rtk git status\`). RTK compacts output for git, gh, cargo, npm/pnpm/yarn/bun, tsc, lint, vitest/jest/playwright, docker, kubectl, ls, grep, find, prisma — and passes anything else through unchanged, so it's always safe.
+
+Prefix EVERY segment in a chain, not just the first:
+\`rtk git add . && rtk git commit -m "msg" && rtk git push\`
+
+RTK also has filtering subcommands the auto-rewriter won't add — reach for these yourself when useful: \`rtk err <cmd>\` (errors only), \`rtk summary <cmd>\`, \`rtk log <file>\` (dedup), \`rtk json <file>\` (structure), \`rtk test <cmd>\` (failures only), \`rtk gain\` (savings stats).`;
+
+// Commands that should be prefixed with rtk
+const RTK_COMMANDS = new Set([
+	"git", "gh", "ls", "tree", "find", "grep", "cat", "head", "tail",
+	"tsc", "lint", "eslint", "prettier", "next", "cargo", "rustc",
+	"vitest", "playwright", "jest", "test",
+	"pnpm", "npm", "npx", "yarn", "bun",
+	"docker", "kubectl", "aws", "psql",
+	"curl", "wget", "wc",
+	"prisma", "dotnet"
+]);
+
+interface RtkStatus {
+	available: boolean;
+	checkedAt: number;
+	path?: string;
+}
+
+/**
+ * Split a command line into segments at top-level shell operators
+ * (&&, ||, ;, |), keeping the operators as their own tokens. Operators
+ * inside single/double quotes are ignored.
+ *
+ * Returns null if the parser hits something it can't safely reason about
+ * (unbalanced quotes), so the caller can skip rewriting.
+ */
+export function splitChain(command: string): string[] | null {
+	const out: string[] = [];
+	let buf = "";
+	let quote: "'" | '"' | null = null;
+
+	for (let i = 0; i < command.length; i++) {
+		const c = command[i]!;
+		const next = command[i + 1];
+
+		if (quote) {
+			buf += c;
+			if (c === quote) quote = null;
+			continue;
+		}
+
+		if (c === "'" || c === '"') {
+			quote = c;
+			buf += c;
+			continue;
+		}
+
+		// two-char operators
+		if ((c === "&" && next === "&") || (c === "|" && next === "|")) {
+			out.push(buf, c + c);
+			buf = "";
+			i++;
+			continue;
+		}
+
+		// single-char operators
+		if (c === ";" || c === "|") {
+			out.push(buf, c);
+			buf = "";
+			continue;
+		}
+
+		buf += c;
+	}
+
+	if (quote) return null; // unbalanced quote — bail out
+	out.push(buf);
+	return out;
+}
+
+const CHAIN_OPERATORS = new Set(["&&", "||", ";", "|"]);
+
+/**
+ * Prefix each command segment with `rtk` when its first word is a known
+ * RTK command and it is not already prefixed. Operators are preserved.
+ * Returns the rewritten command, or the original if nothing changed.
+ */
+export function rewriteChain(command: string): string {
+	const parts = splitChain(command);
+	if (!parts) return command; // unparseable — leave untouched
+
+	let changed = false;
+	const rewritten = parts.map((part) => {
+		if (CHAIN_OPERATORS.has(part.trim())) return part;
+
+		const leading = part.match(/^\s*/)?.[0] ?? "";
+		const body = part.slice(leading.length);
+		if (!body) return part;
+
+		const firstWord = body.split(/\s+/)[0]!;
+		if (firstWord === "rtk") return part;
+		if (!RTK_COMMANDS.has(firstWord)) return part;
+
+		changed = true;
+		return `${leading}rtk ${body}`;
+	});
+
+	return changed ? rewritten.join("") : command;
+}
+
+export function rtk(pi: ExtensionAPI, status: OptimizerStatus): OptimizerHandle {
+	let rtkStatus: RtkStatus | null = null;
+	let warnedMissing = false;
+	let enabled = true;
+
+	// Report into the shared optimizer indicator. RTK counts as "on" only when
+	// enabled AND the binary is actually available.
+	function syncStatus(ctx: Pick<ExtensionContext, "ui">) {
+		status.set("rtk", enabled && rtkStatus?.available === true, ctx);
+	}
+
+	// Check if rtk binary is available
+	const checkRtkAvailability = async (): Promise<RtkStatus> => {
+		// Cache for 60 seconds
+		if (rtkStatus && Date.now() - rtkStatus.checkedAt < 60000) {
+			return rtkStatus;
+		}
+
+		try {
+			const result = await pi.exec("which", ["rtk"], { timeout: 1000 });
+			if (result.code === 0 && result.stdout?.trim()) {
+				rtkStatus = {
+					available: true,
+					checkedAt: Date.now(),
+					path: result.stdout.trim()
+				};
+				warnedMissing = false;
+				return rtkStatus;
+			}
+		} catch (error) {
+			// which command failed
+		}
+
+		rtkStatus = {
+			available: false,
+			checkedAt: Date.now()
+		};
+		return rtkStatus;
+	};
+
+	// Inject RTK system prompt
+	pi.on("before_agent_start", async (event) => {
+		if (!enabled) return undefined;
+		const existing = event.systemPrompt ?? "";
+		return { systemPrompt: RTK_SYSTEM_PROMPT + "\n\n" + existing };
+	});
+
+	// Keep the status indicator in sync across the agent lifecycle. Probe
+	// availability on session start so the icon reflects reality immediately.
+	pi.on("session_start", async (_event, ctx) => {
+		await checkRtkAvailability();
+		syncStatus(ctx);
+	});
+	pi.on("agent_start", async (_event, ctx) => { syncStatus(ctx); });
+	pi.on("agent_end", async (_event, ctx) => { syncStatus(ctx); });
+
+	// -- Subcommand handler (dispatched by the merged /opt router) --
+
+	async function run(args: string, ctx: ExtensionCommandContext): Promise<void> {
+		const arg = args.trim().toLowerCase();
+		if (arg === "on") enabled = true;
+		else if (arg === "off") enabled = false;
+		else enabled = !enabled; // bare toggles
+
+		await checkRtkAvailability();
+		syncStatus(ctx);
+		ctx.ui.notify(`RTK rewriting ${enabled ? "on" : "off"}.`, "info");
+	}
+
+	function complete(prefix: string) {
+		const items = [
+			{ value: "on", label: "on", description: "Force RTK rewriting on" },
+			{ value: "off", label: "off", description: "Force RTK rewriting off" },
+		];
+		const n = prefix.trim().toLowerCase();
+		const filtered = items.filter((i) => i.value.startsWith(n));
+		return filtered.length > 0 ? filtered : null;
+	}
+
+	// Rewrite bash commands to add rtk prefix.
+	//
+	// The SDK fires a single `tool_call` event for every tool. The bash variant
+	// carries `event.toolName === "bash"` and a mutable `event.input` of shape
+	// `{ command: string; timeout?: number }`. Arguments are patched by mutating
+	// `event.input` IN PLACE — returning `{ toolInput: ... }` does nothing.
+	pi.on("tool_call", async (event, ctx) => {
+		if (!enabled) {
+			return undefined;
+		}
+
+		if (event.toolName !== "bash") {
+			return undefined;
+		}
+
+		const probe = await checkRtkAvailability();
+
+		if (!probe.available) {
+			if (!warnedMissing) {
+				ctx.ui.notify(
+					"RTK binary not found. Install: cargo install rtk-ai",
+					"warning"
+				);
+				warnedMissing = true;
+			}
+			return undefined; // Don't rewrite if rtk not available
+		}
+
+		// First confirmed-available probe may have flipped state — refresh icon.
+		syncStatus(ctx);
+
+		// Rewrite every segment in the command chain that uses a known RTK
+		// command (e.g. `git add . && git push` -> `rtk git add . && rtk git push`).
+		// Mutates `event.input.command` in place — the SDK's supported patch path.
+		applyRtkRewrite(event, { enabled, rtkAvailable: probe.available });
+		return undefined;
+	});
+
+	return {
+		name: "rtk",
+		help: "rtk [on|off] — prefix shell commands with rtk (token-optimized)",
+		run,
+		complete,
+	};
+}

package/src/skills/toon-json/SKILL.md

@@ -0,0 +1,101 @@
+---
+name: toon-json
+description: Manipulate information-dense JSON efficiently with jq + TOON. Use when fetching/reading large or repetitive JSON (LLM schemas, OpenAPI specs, API responses, datasets, config dumps) into context. Query/reshape with jq, compress to TOON to cut tokens, decode back to JSON only when a strict contract needs it.
+---
+
+# TOON + jq: Dense JSON Workflow
+
+## Goal
+Carry only the JSON slice you need, in the cheapest encoding. Query with `jq`,
+compress with `toon`, and round-trip back to JSON **only** when a contract
+requires strict JSON.
+
+TOON (Token-Oriented Object Notation, https://github.com/toon-format/spec) is a
+line-oriented encoding of the JSON data model. Uniform arrays of objects declare
+their keys once and stream bare rows, so token cost drops sharply on tabular and
+dense data.
+
+## The pipeline
+
+```bash
+# Fetch → reshape → compress (most common)
+curl -s https://api.example.com/models | jq '.data' | toon
+
+# Local file, show token savings
+cat openapi.json | jq '.paths' | toon --stats
+
+# Just compress, no query
+cat data.json | toon
+
+# Convert TOON back to JSON (strict contract / downstream parser)
+echo "$TOON_BLOB" | toon -d
+cat data.toon | toon --decode
+```
+
+`toon` auto-detects direction from input. Force it with `-e` (encode JSON→TOON)
+or `-d` (decode TOON→JSON).
+
+### Useful flags
+- `--stats` — print token/byte statistics for the conversion
+- `--delimiter=,|\t|"|"` — array delimiter (comma default; tab/pipe can tokenize better)
+- `--keyFolding=safe` — collapse single-key nesting chains
+- `--no-strict` — lenient decode
+
+## Decide before you compress
+
+TOON is not always smaller. Pick based on shape:
+
+| Shape | Action | Why |
+|---|---|---|
+| Uniform array of objects (same keys, primitive values) | **TOON** | Sweet spot — keys declared once, rows streamed; savings scale with rows × fields |
+| Flat object / primitive array | **TOON** | Drops quotes and braces |
+| Shallow nesting | **TOON** | Indentation cheaper than braces at low depth |
+| Deeply nested / non-uniform | **JSON** | Indentation cost grows; compact JSON can win |
+| Array of arrays | **JSON** | TOON's one structurally-worse case (explicit list markers + inner headers) |
+| API contract / payload to send or store | **JSON** | Must stay valid JSON for the consumer |
+
+Rule of thumb: **TOON for reading dense data into context. JSON for contracts.**
+
+## When NOT to use TOON
+- Anything sent to or stored by an API that expects JSON.
+- Data a downstream tool/parser must consume as strict JSON.
+- Deeply nested config trees or highly irregular structures.
+- Tiny payloads where the conversion overhead isn't worth it.
+
+In those cases, still use `jq` to slice down to what you need — just skip the
+`| toon` step.
+
+## Worked examples
+
+LLM model list (uniform array → great TOON candidate):
+
+```bash
+curl -s https://api.example.com/v1/models | jq '.data | map({id, owned_by, context})' | toon
+```
+```
+[3]{id,owned_by,context}:
+  gpt-x,acme,128000
+  gpt-y,acme,200000
+  gpt-z,acme,1000000
+```
+
+OpenAPI paths summary (reshape first, then compress):
+
+```bash
+cat openapi.json \
+  | jq '[.paths | to_entries[] | {path: .key, methods: (.value | keys)}]' \
+  | toon --stats
+```
+
+Round-trip back to JSON for an API call:
+
+```bash
+RESHAPED=$(cat payload.toon | toon -d)
+curl -s -X POST https://api.example.com/ingest -d "$RESHAPED"
+```
+
+## Checklist
+1. **Query** — narrow with `jq` to the exact slice needed.
+2. **Decide** — uniform/tabular/shallow → TOON; nested/array-of-arrays/contract → JSON.
+3. **Compress** — `| toon` (add `--stats` to confirm savings).
+4. **Round-trip** — `toon -d` only when strict JSON is required downstream.

package/src/status.test.ts

@@ -0,0 +1,85 @@
+import { describe, it, expect } from "bun:test";
+import {
+	OptimizerStatus,
+	STATUS_KEY,
+	TOOL_ICONS,
+	renderStatus,
+} from "./status.ts";
+
+/** Tagging colorizer: <accent>X</accent> / <dim>X</dim> for assertions. */
+const tag = (c: string, t: string) => `<${c}>${t}</${c}>`;
+
+describe("renderStatus", () => {
+	it("shows ALL icons in order, accent when enabled", () => {
+		expect(renderStatus({ caveman: true, rtk: true, toon: true }, tag)).toBe(
+			`<accent>${TOOL_ICONS.caveman}</accent>  <accent>${TOOL_ICONS.rtk}</accent>  <accent>${TOOL_ICONS.toon}</accent> `,
+		);
+	});
+
+	it("dims disabled tools but still shows them", () => {
+		expect(renderStatus({ caveman: false, rtk: true, toon: true }, tag)).toBe(
+			`<dim>${TOOL_ICONS.caveman}</dim>  <accent>${TOOL_ICONS.rtk}</accent>  <accent>${TOOL_ICONS.toon}</accent> `,
+		);
+	});
+
+	it("all dim when nothing enabled (cell never empty)", () => {
+		expect(renderStatus({}, tag)).toBe(
+			`<dim>${TOOL_ICONS.caveman}</dim>  <dim>${TOOL_ICONS.rtk}</dim>  <dim>${TOOL_ICONS.toon}</dim> `,
+		);
+	});
+
+	it("preserves fixed order regardless of insertion order", () => {
+		expect(renderStatus({ toon: true, caveman: true }, tag)).toBe(
+			`<accent>${TOOL_ICONS.caveman}</accent>  <dim>${TOOL_ICONS.rtk}</dim>  <accent>${TOOL_ICONS.toon}</accent> `,
+		);
+	});
+});
+
+describe("OptimizerStatus", () => {
+	/** Minimal ui stub capturing setStatus calls. */
+	function fakeCtx() {
+		const calls: { key: string; text: string }[] = [];
+		return {
+			calls,
+			ui: {
+				setStatus: (key: string, text: string | undefined) =>
+					calls.push({ key, text: text ?? "" }),
+				theme: { fg: (c: string, t: string) => `<${c}>${t}</${c}>` },
+			},
+		} as const;
+	}
+
+	it("paints the shared key with per-icon accent/dim", () => {
+		const status = new OptimizerStatus();
+		const ctx = fakeCtx();
+		status.set("rtk", true, ctx as never);
+		const last = ctx.calls.at(-1)!;
+		expect(last.key).toBe(STATUS_KEY);
+		// caveman + toon still unset (dim), rtk accent.
+		expect(last.text).toBe(
+			`<dim>${TOOL_ICONS.caveman}</dim>  <accent>${TOOL_ICONS.rtk}</accent>  <dim>${TOOL_ICONS.toon}</dim> `,
+		);
+	});
+
+	it("accumulates state across tools", () => {
+		const status = new OptimizerStatus();
+		const ctx = fakeCtx();
+		status.set("caveman", true, ctx as never);
+		status.set("toon", true, ctx as never);
+		const last = ctx.calls.at(-1)!;
+		expect(last.text).toBe(
+			`<accent>${TOOL_ICONS.caveman}</accent>  <dim>${TOOL_ICONS.rtk}</dim>  <accent>${TOOL_ICONS.toon}</accent> `,
+		);
+	});
+
+	it("dims an icon when its tool toggles off (cell stays populated)", () => {
+		const status = new OptimizerStatus();
+		const ctx = fakeCtx();
+		status.set("rtk", true, ctx as never);
+		status.set("rtk", false, ctx as never);
+		const last = ctx.calls.at(-1)!;
+		expect(last.text).toBe(
+			`<dim>${TOOL_ICONS.caveman}</dim>  <dim>${TOOL_ICONS.rtk}</dim>  <dim>${TOOL_ICONS.toon}</dim> `,
+		);
+	});
+});

package/src/status.ts

@@ -0,0 +1,102 @@
+/**
+ * status.ts — shared status-bar indicator for the optimizer suite.
+ *
+ * caveman / rtk / json each toggle independently, but they're all the same
+ * class of thing (token-optimization tools), so they share ONE status cell
+ * instead of three. Each tool reports its on/off state into a single registry;
+ * the cell renders only the icons whose tool is currently enabled, in a fixed
+ * order, accent-colored. When everything is off the cell is empty.
+ *
+ *   all on:        ⛏ ⚔ ✂
+ *   caveman off:   ⚔ ✂
+ *   all off:       (empty)
+ */
+
+import type {
+	ExtensionCommandContext,
+	ExtensionContext,
+	ThemeColor,
+} from "@earendil-works/pi-coding-agent";
+
+/** Argument-completion item shape used by the merged /opt command. */
+export interface CompletionItem {
+	value: string;
+	label: string;
+	description: string;
+}
+
+/**
+ * Each optimizer tool (caveman/rtk/json) exposes a handle so the single `/opt`
+ * router can dispatch subcommands to it without knowing its internals.
+ */
+export interface OptimizerHandle {
+	/** Subcommand name, e.g. "caveman" / "rtk" / "toon". */
+	name: OptimizerTool;
+	/** One-line help shown by `/opt` with no args. */
+	help: string;
+	/** Handle `/opt <name> <args>`. `args` is everything after the name. */
+	run(args: string, ctx: ExtensionCommandContext): Promise<void> | void;
+	/** Completions for the second token (`/opt <name> <prefix>`). */
+	complete(prefix: string): CompletionItem[] | null;
+}
+
+/** Stable status-bar key shared by every optimizer tool. */
+export const STATUS_KEY = "pix-optimizer";
+
+/** Tools that participate in the shared indicator, in render order. */
+export type OptimizerTool = "caveman" | "rtk" | "toon";
+
+export const TOOL_ICONS: Record<OptimizerTool, string> = {
+	caveman: "⛏",
+	rtk: "⚔",
+	toon: "✂",
+};
+
+/** Fixed left-to-right order of icons in the cell. */
+export const TOOL_ORDER: readonly OptimizerTool[] = ["caveman", "rtk", "toon"];
+
+/** Theme color for enabled icons. */
+export const ENABLED_COLOR: ThemeColor = "accent";
+/** Theme color for disabled icons. */
+export const DISABLED_COLOR: ThemeColor = "dim";
+
+/** Colorizer: maps a (theme color, text) pair to a rendered string. */
+export type Colorize = (color: ThemeColor, text: string) => string;
+
+/**
+ * Build the colored status string for a set of tool states. ALL tool icons are
+ * always shown, in TOOL_ORDER; each is accent-colored when its tool is enabled
+ * and dim when disabled. `color` applies the theme color (e.g. theme.fg).
+ *
+ * Pure + exported for tests (pass a tagging colorizer to assert per-icon color).
+ * A trailing space separates the cell from the next status segment.
+ */
+export function renderStatus(
+	states: Partial<Record<OptimizerTool, boolean>>,
+	color: Colorize,
+): string {
+	return `${TOOL_ORDER.map((t) =>
+		color(states[t] === true ? ENABLED_COLOR : DISABLED_COLOR, TOOL_ICONS[t]),
+	).join("  ")} `;
+}
+
+/**
+ * Shared registry: each tool calls `set(tool, enabled)` whenever its state
+ * changes, then the combined cell is re-rendered. A single registry instance
+ * is created per extension load and passed to caveman/rtk/json.
+ */
+export class OptimizerStatus {
+	private states: Partial<Record<OptimizerTool, boolean>> = {};
+
+	/** Update one tool's enabled state and repaint the shared cell. */
+	set(tool: OptimizerTool, enabled: boolean, ctx: Pick<ExtensionContext, "ui">): void {
+		this.states[tool] = enabled;
+		this.paint(ctx);
+	}
+
+	/** Repaint the shared cell from current states. */
+	paint(ctx: Pick<ExtensionContext, "ui">): void {
+		const text = renderStatus(this.states, (c, t) => ctx.ui.theme.fg(c, t));
+		ctx.ui.setStatus(STATUS_KEY, text);
+	}
+}