@xynogen/pix-optimizer 1.1.18 → 1.1.19

package/src/rtk.test.ts

@@ -1,277 +0,0 @@
-import { describe, expect, it, mock } from "bun:test";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import {
-	applyRtkRewrite,
-	type BashCallEvent,
-	buildSudoBlockReason,
-	detectSudoSegments,
-	probeRtkAvailability,
-	rewriteChain,
-	splitChain,
-} from "./rtk.ts";
-
-/** Build a fresh bash tool_call event for hook tests. */
-function bashEvent(command: string): BashCallEvent {
-	return { toolName: "bash", input: { command } };
-}
-
-describe("probeRtkAvailability", () => {
-	it("probes rtk directly and accepts a successful version check", async () => {
-		const exec = mock(async () => ({
-			stdout: "rtk 0.1.0",
-			stderr: "",
-			code: 0,
-			killed: false,
-		}));
-
-		expect(await probeRtkAvailability({ exec } as Pick<ExtensionAPI, "exec">)).toBe(true);
-		expect(exec).toHaveBeenCalledWith("rtk", ["--version"], { timeout: 3000 });
-	});
-
-	it("rejects an unsuccessful version check", async () => {
-		const exec = mock(async () => ({ stdout: "", stderr: "missing", code: 1, killed: false }));
-
-		expect(await probeRtkAvailability({ exec } as Pick<ExtensionAPI, "exec">)).toBe(false);
-	});
-
-	it("treats a spawn failure as unavailable", async () => {
-		const exec = mock(async () => {
-			throw new Error("ENOENT");
-		});
-
-		expect(await probeRtkAvailability({ exec } as Pick<ExtensionAPI, "exec">)).toBe(false);
-	});
-});
-
-describe("splitChain", () => {
-	it("returns single segment for plain command", () => {
-		expect(splitChain("git status")).toEqual(["git status"]);
-	});
-
-	it("splits on && keeping operator", () => {
-		expect(splitChain("git add . && git push")).toEqual(["git add . ", "&&", " git push"]);
-	});
-
-	it("splits on ||, ;, |", () => {
-		expect(splitChain("a || b")).toEqual(["a ", "||", " b"]);
-		expect(splitChain("a ; b")).toEqual(["a ", ";", " b"]);
-		expect(splitChain("a | b")).toEqual(["a ", "|", " b"]);
-	});
-
-	it("ignores operators inside double quotes", () => {
-		expect(splitChain('git commit -m "a && b"')).toEqual(['git commit -m "a && b"']);
-	});
-
-	it("ignores operators inside single quotes", () => {
-		expect(splitChain("echo 'x | y'")).toEqual(["echo 'x | y'"]);
-	});
-
-	it("returns null on unbalanced quotes", () => {
-		expect(splitChain('git commit -m "oops')).toBeNull();
-	});
-});
-
-describe("rewriteChain", () => {
-	it("prefixes a single known command", () => {
-		expect(rewriteChain("git status")).toBe("rtk git status");
-	});
-
-	it("prefixes every segment in a chain", () => {
-		expect(rewriteChain("git add . && git commit -m x && git push")).toBe(
-			"rtk git add . && rtk git commit -m x && rtk git push",
-		);
-	});
-
-	it("prefixes mixed known commands", () => {
-		expect(rewriteChain("cargo build && npm test")).toBe("rtk cargo build && rtk npm test");
-	});
-
-	it("leaves unknown commands alone", () => {
-		expect(rewriteChain("echo hi && mkdir x")).toBe("echo hi && mkdir x");
-	});
-
-	it("does not prefix find (rtk find rejects -not/-exec)", () => {
-		const cmd = "find . -type f -not -path '*/node_modules/*'";
-		expect(rewriteChain(cmd)).toBe(cmd);
-	});
-
-	it("only prefixes known segments in a mixed chain", () => {
-		expect(rewriteChain("cd /tmp && git status")).toBe("cd /tmp && rtk git status");
-	});
-
-	it("does not double-prefix already-rtk commands", () => {
-		expect(rewriteChain("rtk git status")).toBe("rtk git status");
-		expect(rewriteChain("rtk git add . && git push")).toBe("rtk git add . && rtk git push");
-	});
-
-	it("does not touch operators inside quotes", () => {
-		expect(rewriteChain('git commit -m "a && b"')).toBe('rtk git commit -m "a && b"');
-	});
-
-	it("returns original on unbalanced quotes", () => {
-		const cmd = 'git commit -m "oops';
-		expect(rewriteChain(cmd)).toBe(cmd);
-	});
-
-	it("prefixes known commands across a pipe (ls, wc)", () => {
-		expect(rewriteChain("ls -la | wc -l")).toBe("rtk ls -la | rtk wc -l");
-	});
-
-	it("truly leaves a chain of only-unknown commands untouched", () => {
-		expect(rewriteChain("cd /tmp | sort | uniq")).toBe("cd /tmp | sort | uniq");
-	});
-
-	it("handles pipes between known commands", () => {
-		expect(rewriteChain("git log | grep fix")).toBe("rtk git log | rtk grep fix");
-	});
-});
-
-// ── detectSudoSegments ───────────────────────────────────────────────────────
-
-describe("detectSudoSegments", () => {
-	it("returns empty for command with no sudo", () => {
-		expect(detectSudoSegments(["git status"])).toEqual([]);
-	});
-
-	it("detects a plain sudo segment", () => {
-		expect(detectSudoSegments(["sudo apt-get install foo"])).toEqual(["sudo apt-get install foo"]);
-	});
-
-	it("detects sudo in a chain (operators excluded)", () => {
-		const parts = ["git status ", "&&", " sudo make install"];
-		expect(detectSudoSegments(parts)).toEqual(["sudo make install"]);
-	});
-
-	it("detects multiple sudo segments", () => {
-		const parts = ["sudo rm -rf /tmp ", ";", " sudo reboot"];
-		expect(detectSudoSegments(parts)).toEqual(["sudo rm -rf /tmp", "sudo reboot"]);
-	});
-
-	it("does not match 'sudoer' or 'pseudo'", () => {
-		expect(detectSudoSegments(["sudoers-check", "pseudo sudo"])).toEqual([]);
-	});
-
-	it("returns empty for operators-only parts", () => {
-		expect(detectSudoSegments(["&&", "||", ";"])).toEqual([]);
-	});
-});
-
-// ── buildSudoBlockReason ──────────────────────────────────────────────────────
-
-describe("buildSudoBlockReason", () => {
-	it("with sudo_run available: mentions sudo_run tool", () => {
-		const reason = buildSudoBlockReason(["sudo apt install curl"], true);
-		expect(reason).toContain("sudo_run");
-		expect(reason).toContain("sudo apt install curl");
-		expect(reason).not.toContain("not available");
-	});
-
-	it("with sudo_run available: instructs to strip sudo prefix", () => {
-		const reason = buildSudoBlockReason(["sudo make install"], true);
-		expect(reason).toContain("Strip the leading");
-	});
-
-	it("without sudo_run: explains restriction and asks user to run manually", () => {
-		const reason = buildSudoBlockReason(["sudo reboot"], false);
-		expect(reason).toContain("no sudo_run tool is available");
-		expect(reason).toContain("manually");
-		expect(reason).toContain("sudo reboot");
-	});
-
-	it("lists all blocked commands", () => {
-		const reason = buildSudoBlockReason(["sudo rm -rf /tmp", "sudo reboot"], true);
-		expect(reason).toContain("sudo rm -rf /tmp");
-		expect(reason).toContain("sudo reboot");
-	});
-});
-
-// Integration tests for the `tool_call` hook step. These guard the bug that
-// silently disabled rewriting: wrong event name + wrong field + wrong patch
-// mechanism. They assert on the IN-PLACE mutation contract the SDK requires.
-describe("applyRtkRewrite (tool_call hook step)", () => {
-	it("mutates event.input.command in place for a known bash command", () => {
-		const event = bashEvent("git status");
-		const changed = applyRtkRewrite(event, {
-			enabled: true,
-			rtkAvailable: true,
-		});
-		expect(changed).toBe(true);
-		expect(event.input.command).toBe("rtk git status");
-	});
-
-	it("rewrites every segment of a chain in place", () => {
-		const event = bashEvent("git add . && git push");
-		applyRtkRewrite(event, { enabled: true, rtkAvailable: true });
-		expect(event.input.command).toBe("rtk git add . && rtk git push");
-	});
-
-	it("does not mutate when disabled", () => {
-		const event = bashEvent("git status");
-		const changed = applyRtkRewrite(event, {
-			enabled: false,
-			rtkAvailable: true,
-		});
-		expect(changed).toBe(false);
-		expect(event.input.command).toBe("git status");
-	});
-
-	it("does not mutate when rtk binary is unavailable", () => {
-		const event = bashEvent("git status");
-		const changed = applyRtkRewrite(event, {
-			enabled: true,
-			rtkAvailable: false,
-		});
-		expect(changed).toBe(false);
-		expect(event.input.command).toBe("git status");
-	});
-
-	it("ignores non-bash tools", () => {
-		const event: BashCallEvent = {
-			toolName: "grep",
-			input: { command: "git status" },
-		};
-		const changed = applyRtkRewrite(event, {
-			enabled: true,
-			rtkAvailable: true,
-		});
-		expect(changed).toBe(false);
-		expect(event.input.command).toBe("git status");
-	});
-
-	it("leaves unknown commands untouched", () => {
-		const event = bashEvent("mkdir build && cd build");
-		const changed = applyRtkRewrite(event, {
-			enabled: true,
-			rtkAvailable: true,
-		});
-		expect(changed).toBe(false);
-		expect(event.input.command).toBe("mkdir build && cd build");
-	});
-
-	it("does not double-prefix an already-rtk command", () => {
-		const event = bashEvent("rtk git status");
-		const changed = applyRtkRewrite(event, {
-			enabled: true,
-			rtkAvailable: true,
-		});
-		expect(changed).toBe(false);
-		expect(event.input.command).toBe("rtk git status");
-	});
-
-	it("handles missing / non-string command safely", () => {
-		const event: BashCallEvent = { toolName: "bash", input: {} };
-		expect(applyRtkRewrite(event, { enabled: true, rtkAvailable: true })).toBe(false);
-		const event2: BashCallEvent = { toolName: "bash", input: { command: 123 } };
-		expect(applyRtkRewrite(event2, { enabled: true, rtkAvailable: true })).toBe(false);
-	});
-
-	it("leaves command unchanged on unbalanced quotes", () => {
-		const event = bashEvent('git commit -m "oops');
-		const changed = applyRtkRewrite(event, {
-			enabled: true,
-			rtkAvailable: true,
-		});
-		expect(changed).toBe(false);
-		expect(event.input.command).toBe('git commit -m "oops');
-	});
-});

package/src/status.test.ts

@@ -1,93 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { OptimizerStatus, renderStatus, STATUS_KEY, toolIcon } from "./status.ts";
-
-/** Tagging colorizer: <accent>X</accent> / <dim>X</dim> for assertions. */
-const tag = (c: string, t: string) => `<${c}>${t}</${c}>`;
-
-// Icons resolve against the global pix-pretty mode (default "nerd" in tests).
-const CV = toolIcon("caveman");
-const RK = toolIcon("rtk");
-const TN = toolIcon("toon");
-const PT = toolIcon("ponytail");
-
-describe("renderStatus", () => {
-	it("shows ALL icons in order, accent when enabled", () => {
-		expect(renderStatus({ caveman: true, rtk: true, toon: true, ponytail: true }, tag)).toBe(
-			`<accent>${CV}</accent>  <accent>${RK}</accent>  <accent>${TN}</accent>  <accent>${PT}</accent> `,
-		);
-	});
-
-	it("dims disabled tools but still shows them", () => {
-		expect(renderStatus({ caveman: false, rtk: true, toon: true, ponytail: true }, tag)).toBe(
-			`<dim>${CV}</dim>  <accent>${RK}</accent>  <accent>${TN}</accent>  <accent>${PT}</accent> `,
-		);
-	});
-
-	it("all dim when nothing enabled (cell never empty)", () => {
-		expect(renderStatus({}, tag)).toBe(
-			`<dim>${CV}</dim>  <dim>${RK}</dim>  <dim>${TN}</dim>  <dim>${PT}</dim> `,
-		);
-	});
-
-	it("preserves fixed order regardless of insertion order", () => {
-		expect(renderStatus({ toon: true, caveman: true }, tag)).toBe(
-			`<accent>${CV}</accent>  <dim>${RK}</dim>  <accent>${TN}</accent>  <dim>${PT}</dim> `,
-		);
-	});
-
-	it("resolves icons via the shared catalog (non-empty glyphs)", () => {
-		// toolIcon delegates to pix-pretty's icon(); every tool has a glyph.
-		expect([CV, RK, TN, PT].every((g) => g.length > 0)).toBe(true);
-	});
-});
-
-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);
-		if (!last) throw new Error("no calls");
-		expect(last.key).toBe(STATUS_KEY);
-		// caveman + toon + ponytail still unset (dim), rtk accent.
-		expect(last.text).toBe(
-			`<dim>${CV}</dim>  <accent>${RK}</accent>  <dim>${TN}</dim>  <dim>${PT}</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);
-		if (!last) throw new Error("no calls");
-		expect(last.text).toBe(
-			`<accent>${CV}</accent>  <dim>${RK}</dim>  <accent>${TN}</accent>  <dim>${PT}</dim> `,
-		);
-	});
-
-	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);
-		if (!last) throw new Error("no calls");
-		expect(last.text).toBe(
-			`<dim>${CV}</dim>  <dim>${RK}</dim>  <dim>${TN}</dim>  <dim>${PT}</dim> `,
-		);
-	});
-});

package/src/tool-result-filter.test.ts

@@ -1,96 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { filterModelWarnings, stripModelWarningParagraphs } from "./tool-result-filter.ts";
-
-// ── stripModelWarningParagraphs ───────────────────────────────────────────────
-
-describe("stripModelWarningParagraphs", () => {
-	it("passes through text with no warnings", () => {
-		const text = "Exit code: 0\n\nsome output here";
-		expect(stripModelWarningParagraphs(text)).toBe(text);
-	});
-
-	it("strips a BLIND WRITE paragraph", () => {
-		const text =
-			"Exit code: 0\n\nsome output\n\n⚠ BLIND WRITE — editing `foo.ts` without reading in the last 5 tool calls. Read the file first to avoid assumptions.";
-		const result = stripModelWarningParagraphs(text);
-		expect(result).not.toContain("BLIND WRITE");
-		expect(result).toContain("some output");
-	});
-
-	it("strips a THRASHING paragraph", () => {
-		const text =
-			"ok\n\n🔴 THRASHING — 3 consecutive `edit` calls on foo.ts. Consider reading first.";
-		const result = stripModelWarningParagraphs(text);
-		expect(result).not.toContain("THRASHING");
-		expect(result).toContain("ok");
-	});
-
-	it("strips multiple warning paragraphs", () => {
-		const text = "output\n\n⚠ BLIND WRITE — foo\n\n🔴 THRASHING — bar\n\nmore output";
-		const result = stripModelWarningParagraphs(text);
-		expect(result).not.toContain("BLIND WRITE");
-		expect(result).not.toContain("THRASHING");
-		expect(result).toContain("output");
-		expect(result).toContain("more output");
-	});
-
-	it("returns original reference when nothing stripped", () => {
-		const text = "no warnings here";
-		expect(stripModelWarningParagraphs(text)).toBe(text);
-	});
-
-	it("trims trailing whitespace after stripping", () => {
-		const text = "output\n\n⚠ BLIND WRITE — foo";
-		const result = stripModelWarningParagraphs(text);
-		expect(result).toBe("output");
-	});
-
-	it("does not strip mid-paragraph BLIND WRITE mentions", () => {
-		// Only strips when the paragraph *starts* with the prefix
-		const text = "The BLIND WRITE check is a feature.\n\nsome output";
-		expect(stripModelWarningParagraphs(text)).toBe(text);
-	});
-});
-
-// ── filterModelWarnings ───────────────────────────────────────────────────────
-
-describe("filterModelWarnings", () => {
-	it("returns original array when no warnings present", () => {
-		const content = [{ type: "text" as const, text: "clean output" }];
-		expect(filterModelWarnings(content)).toBe(content);
-	});
-
-	it("filters BLIND WRITE from text block", () => {
-		const content = [
-			{
-				type: "text" as const,
-				text: "Exit code: 0\n\nok\n\n⚠ BLIND WRITE — editing `x.ts` without reading.",
-			},
-		];
-		const result = filterModelWarnings(content);
-		expect(result).not.toBe(content);
-		expect(result[0]?.type).toBe("text");
-		if (result[0]?.type === "text") {
-			expect((result[0] as { type: string; text: string }).text).not.toContain("BLIND WRITE");
-		}
-	});
-
-	it("leaves image blocks untouched", () => {
-		const img = { type: "image", source: { type: "base64", data: "abc" } };
-		const content = [img] as never[];
-		expect(filterModelWarnings(content)).toBe(content);
-	});
-
-	it("only modifies affected blocks, keeps others by reference", () => {
-		const clean = { type: "text" as const, text: "clean" };
-		const dirty = {
-			type: "text" as const,
-			text: "output\n\n⚠ BLIND WRITE — foo",
-		};
-		const content = [clean, dirty];
-		const result = filterModelWarnings(content);
-		// The array is new but clean block is the same reference
-		expect(result[0]).toBe(clean);
-		expect(result[1]).not.toBe(dirty);
-	});
-});