@xynogen/pix-optimizer 1.1.4 → 1.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-optimizer",
-	"version": "1.1.4",
+	"version": "1.1.6",
 	"description": "Performance optimization suite for Pi Coding Agent - caveman mode + RTK tool rewriting + jq/TOON JSON compression + ponytail lazy-dev mode",
 	"type": "module",
 	"main": "src/index.ts",
@@ -47,6 +47,9 @@
 	"publishConfig": {
 		"access": "public"
 	},
+	"dependencies": {
+		"@xynogen/pix-pretty": "*"
+	},
 	"peerDependencies": {
 		"@earendil-works/pi-coding-agent": "*",
 		"@earendil-works/pi-tui": "*"

package/src/caveman.test.ts

@@ -2,11 +2,9 @@ import { describe, expect, it } from "bun:test";
 import {
 	buildHelp,
 	buildPrompt,
-	DEFAULT_CONFIG,
 	LEVEL_NUMBERS,
 	LEVELS,
 	type Level,
-	parseConfig,
 	resolveLevel,
 	STATUS_LABELS,
 	STOP_ALIASES,
@@ -203,38 +201,3 @@ describe("buildPrompt", () => {
 		expect(lite).not.toContain("Abbreviate");
 	});
 });
-
-// ── parseConfig ───────────────────────────────────────────────────────────────
-
-describe("parseConfig", () => {
-	it("parses valid config", () => {
-		const cfg = parseConfig({ defaultLevel: "ultra", showStatus: false });
-		expect(cfg.defaultLevel).toBe("ultra");
-		expect(cfg.showStatus).toBe(false);
-	});
-
-	it("falls back to defaults for invalid defaultLevel", () => {
-		const cfg = parseConfig({ defaultLevel: "invalid", showStatus: true });
-		expect(cfg.defaultLevel).toBe(DEFAULT_CONFIG.defaultLevel);
-	});
-
-	it("falls back to defaults for missing fields", () => {
-		const cfg = parseConfig({});
-		expect(cfg.defaultLevel).toBe(DEFAULT_CONFIG.defaultLevel);
-		expect(cfg.showStatus).toBe(DEFAULT_CONFIG.showStatus);
-	});
-
-	it("falls back to defaults for null/undefined", () => {
-		const cfg = parseConfig(null);
-		expect(cfg.defaultLevel).toBe(DEFAULT_CONFIG.defaultLevel);
-		expect(cfg.showStatus).toBe(DEFAULT_CONFIG.showStatus);
-	});
-
-	it("accepts all valid levels as defaultLevel", () => {
-		for (const l of LEVELS) {
-			expect(
-				parseConfig({ defaultLevel: l, showStatus: true }).defaultLevel,
-			).toBe(l);
-		}
-	});
-});

package/src/caveman.ts

@@ -5,21 +5,11 @@
  * called by index.ts alongside rtk(pi).
  */
 
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
 import type {
 	ExtensionAPI,
 	ExtensionCommandContext,
 	ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
-import { getSettingsListTheme } from "@earendil-works/pi-coding-agent";
-import {
-	Container,
-	type SettingItem,
-	SettingsList,
-	Text,
-} from "@earendil-works/pi-tui";
 import type { OptimizerHandle, OptimizerStatus } from "./status.ts";
 
 // ── Levels ────────────────────────────────────────────────────────────────────
@@ -37,24 +27,6 @@ export const LEVEL_NUMBERS: Record<string, Level> = {
 	"3": "ultra",
 };
 
-const CAVEMAN_COMMAND_OPTIONS = [
-	{ value: "1", label: "1 (lite)", description: "Professional, no fluff" },
-	{ value: "2", label: "2 (full)", description: "Classic caveman" },
-	{ value: "3", label: "3 (ultra)", description: "Maximum compression" },
-	{ value: "lite", label: "lite", description: "Professional, no fluff" },
-	{ value: "full", label: "full", description: "Classic caveman" },
-	{ value: "ultra", label: "ultra", description: "Maximum compression" },
-	{
-		value: "micro",
-		label: "micro",
-		description: "Experimental prompt-minimized mode",
-	},
-	{ value: "off", label: "off", description: "Disable caveman mode" },
-	{ value: "stop", label: "stop", description: "Disable caveman mode" },
-	{ value: "quit", label: "quit", description: "Disable caveman mode" },
-	{ value: "config", label: "config", description: "Open settings dialog" },
-] as const;
-
 // ── Status labels ─────────────────────────────────────────────────────────────
 
 export const STATUS_LABELS: Record<Exclude<Level, "off">, string> = {
@@ -158,55 +130,6 @@ export function toggleLevel(current: Level): Level {
 	return current === "off" ? "full" : "off";
 }
 
-// ── Config ────────────────────────────────────────────────────────────────────
-
-export interface CavemanConfig {
-	/** Level to apply on new sessions. "off" means don't auto-enable. */
-	defaultLevel: Level;
-	/** Whether to show the status bar indicator. */
-	showStatus: boolean;
-}
-
-export const DEFAULT_CONFIG: CavemanConfig = {
-	defaultLevel: "full",
-	showStatus: true,
-};
-
-const CONFIG_PATH = join(homedir(), ".pi", "agent", "caveman.json");
-
-export function parseConfig(raw: unknown): CavemanConfig {
-	const parsed = raw as Record<string, unknown>;
-	return {
-		defaultLevel: LEVELS.includes(parsed?.defaultLevel as Level)
-			? (parsed.defaultLevel as Level)
-			: DEFAULT_CONFIG.defaultLevel,
-		showStatus:
-			typeof parsed?.showStatus === "boolean"
-				? parsed.showStatus
-				: DEFAULT_CONFIG.showStatus,
-	};
-}
-
-let _saveQueue: Promise<void> = Promise.resolve();
-
-async function loadConfig(): Promise<CavemanConfig> {
-	try {
-		const raw = await readFile(CONFIG_PATH, "utf8");
-		return parseConfig(JSON.parse(raw));
-	} catch {
-		return { ...DEFAULT_CONFIG };
-	}
-}
-
-async function saveConfig(config: CavemanConfig): Promise<void> {
-	const snapshot = `${JSON.stringify(config, null, 2)}\n`;
-	_saveQueue = _saveQueue.then(async () => {
-		await mkdir(join(homedir(), ".pi", "agent"), { recursive: true });
-		await writeFile(CONFIG_PATH, snapshot, "utf8");
-	});
-	return _saveQueue;
-}
-
 // ── Pi extension ────────────────────────────────────────────────────────────
 
 export function caveman(
@@ -214,26 +137,11 @@ export function caveman(
 	status: OptimizerStatus,
 ): OptimizerHandle {
 	let level: Level = "off";
-	let config: CavemanConfig = { ...DEFAULT_CONFIG };
-	let configLoadPromise: Promise<void> | null = null;
-
-	const ensureConfigLoaded = async () => {
-		if (!configLoadPromise) {
-			configLoadPromise = (async () => {
-				config = await loadConfig();
-				if (level === "off" && config.defaultLevel !== "off") {
-					level = config.defaultLevel;
-				}
-			})();
-		}
-		await configLoadPromise;
-	};
 
 	// -- Status: report into the shared optimizer indicator. --
 
 	function syncStatus(ctx: Pick<ExtensionContext, "ui">) {
-		const on = level !== "off" && config.showStatus;
-		status.set("caveman", on, ctx);
+		status.set("caveman", level !== "off", ctx);
 	}
 
 	// Inject caveman prompt via before_agent_start
@@ -244,25 +152,14 @@ export function caveman(
 		return { systemPrompt: `${prompt}\n\n${existing}` };
 	});
 
-	// -- Restore state on session load --
+	// -- Restore live level from the session log on load --
 
 	pi.on("session_start", async (_event, ctx) => {
-		await ensureConfigLoaded();
-
-		let sessionLevel: Level | null = null;
 		for (const entry of ctx.sessionManager.getEntries()) {
 			if (entry.type === "custom" && entry.customType === "caveman-level") {
-				sessionLevel = (entry.data as { level: Level })?.level ?? null;
+				level = (entry.data as { level: Level })?.level ?? level;
 			}
 		}
-
-		if (sessionLevel !== null) {
-			level = sessionLevel;
-		} else if (config.defaultLevel !== "off") {
-			level = config.defaultLevel;
-			pi.appendEntry("caveman-level", { level });
-		}
-
 		syncStatus(ctx);
 	});
 
@@ -274,33 +171,14 @@ export function caveman(
 	});
 	pi.on("session_shutdown", async () => {});
 
-	// -- Subcommand handler (dispatched by the merged /opt router) --
+	// -- Overlay value handler (called by the /optimizer overlay) --
 
 	async function run(
-		args: string,
+		value: string,
 		ctx: ExtensionCommandContext,
 	): Promise<void> {
-		const arg = args.trim().toLowerCase();
-
-		// No argument → show help
-		if (!arg) {
-			ctx.ui.notify(buildHelp(level), "info");
-			return;
-		}
-
-		if (arg === "config") {
-			await openConfig(ctx);
-			return;
-		}
-
-		const resolved = resolveLevel(arg);
-		if (resolved === null) {
-			ctx.ui.notify(
-				`Unknown: "${arg}". Use 1/2/3, ${LEVELS.join(", ")}, stop, quit, or config`,
-				"error",
-			);
-			return;
-		}
+		const resolved = resolveLevel(value);
+		if (resolved === null) return;
 		level = resolved;
 
 		pi.appendEntry("caveman-level", { level });
@@ -314,131 +192,11 @@ export function caveman(
 		);
 	}
 
-	function complete(prefix: string) {
-		const normalized = prefix.trim().toLowerCase();
-		const items = CAVEMAN_COMMAND_OPTIONS.filter((item) =>
-			item.value.startsWith(normalized),
-		);
-		return items.length > 0 ? items.map((i) => ({ ...i })) : null;
-	}
-
-	// -- /caveman config: interactive SettingsList --
-
-	async function openConfig(ctx: ExtensionContext) {
-		await ensureConfigLoaded();
-
-		await ctx.ui.custom((_tui, theme, _kb, done) => {
-			const items: SettingItem[] = [
-				{
-					id: "defaultLevel",
-					label: "Default level for new sessions",
-					currentValue: config.defaultLevel,
-					values: [...LEVELS],
-				},
-				{
-					id: "showStatus",
-					label: "Show status bar",
-					currentValue: config.showStatus ? "on" : "off",
-					values: ["on", "off"],
-				},
-			];
-
-			const container = new Container();
-			container.addChild(
-				new Text(theme.fg("accent", theme.bold(" Caveman Config")), 0, 0),
-			);
-			container.addChild(
-				new Text(theme.fg("dim", " Saved to ~/.pi/agent/caveman.json"), 0, 0),
-			);
-			container.addChild(
-				new Text(
-					theme.fg("dim", " Default level applies to future sessions."),
-					0,
-					0,
-				),
-			);
-			container.addChild(new Text("", 0, 0));
-
-			const applySettingChange = (id: string, newValue: string) => {
-				if (id === "defaultLevel" && LEVELS.includes(newValue as Level)) {
-					config.defaultLevel = newValue as Level;
-				} else if (id === "showStatus") {
-					config.showStatus = newValue === "on";
-				}
-				saveConfig(config);
-				syncStatus(ctx);
-			};
-
-			const settingsList = new SettingsList(
-				items,
-				Math.min(items.length + 2, 10),
-				getSettingsListTheme(),
-				applySettingChange,
-				() => done(undefined),
-			);
-
-			container.addChild(settingsList);
-			container.addChild(
-				new Text(
-					theme.fg("dim", " ←→/hl/tab change • ↑↓/jk move • esc close"),
-					0,
-					0,
-				),
-			);
-
-			const cycleSelectedValue = (direction: -1 | 1) => {
-				const selectedIndex = (
-					settingsList as unknown as { selectedIndex: number }
-				).selectedIndex;
-				const item = items[selectedIndex];
-				if (!item?.values?.length) return;
-				const currentIndex = item.values.indexOf(item.currentValue);
-				const nextIndex =
-					(currentIndex + direction + item.values.length) % item.values.length;
-				const newValue = item.values[nextIndex]!;
-				item.currentValue = newValue;
-				settingsList.updateValue(item.id, newValue);
-				applySettingChange(item.id, newValue);
-			};
-
-			return {
-				render: (w: number) => container.render(w),
-				invalidate: () => container.invalidate(),
-				handleInput: (data: string) => {
-					if (data === "j") data = "\u001b[B";
-					else if (data === "k") data = "\u001b[A";
-					else if (data === "h") {
-						cycleSelectedValue(-1);
-						_tui.requestRender();
-						return;
-					} else if (data === "l" || data === "\u001b[C" || data === "\t") {
-						cycleSelectedValue(1);
-						_tui.requestRender();
-						return;
-					} else if (data === "\u001b[D") {
-						cycleSelectedValue(-1);
-						_tui.requestRender();
-						return;
-					} else if (data === "\u001b" || data === "q") {
-						done(undefined);
-						return;
-					}
-
-					// SettingsList.handleInput now returns void; completion/cancel is
-					// signalled through the onChange/onCancel callbacks passed to the
-					// constructor (onCancel -> done(undefined)). Just forward input and
-					// re-render.
-					settingsList.handleInput(data);
-					_tui.requestRender();
-				},
-			};
-		});
-	}
-
 	return {
 		name: "caveman",
-		help: "caveman <1|2|3|lite|full|ultra|micro|off|config> — terse output",
+		help: "caveman — terse output",
+		values: LEVELS,
+		current: () => level,
 		run,
-		complete,
 	};
 }

package/src/index.ts

@@ -8,8 +8,8 @@
  *   - ponytail: lazy-senior-dev system prompt (minimal code, YAGNI)
  *
  * They share ONE status-bar cell (󰜐 󰓥 󰗀 󰆐, only enabled tools shown) and ONE
- * command (/opt <tool> [args]). index.ts wires lifecycle hooks via each
- * module, then registers the merged command from their handles.
+ * command (/optimizer — an interactive overlay). index.ts wires lifecycle hooks
+ * via each module, then registers the overlay command from their handles.
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
@@ -29,7 +29,7 @@ export default function optimizer(pi: ExtensionAPI) {
 	const status = new OptimizerStatus();
 
 	// Each module registers its own lifecycle hooks and returns a handle the
-	// merged /opt command dispatches to.
+	// /optimizer overlay renders + drives.
 	const handles: Record<OptimizerTool, OptimizerHandle> = {
 		caveman: caveman(pi, status),
 		rtk: rtk(pi, status),
@@ -37,7 +37,7 @@ export default function optimizer(pi: ExtensionAPI) {
 		ponytail: ponytail(pi, status),
 	};
 
-	registerOptCommand(pi, handles);
+	registerOptCommand(pi, handles, status);
 
 	// Strip model-guidance warnings injected by pi-lens into tool_result content.
 	// These strings (BLIND WRITE, THRASHING) are directives for the LLM, not

package/src/json.ts

@@ -270,41 +270,23 @@ export function json(
 		return { systemPrompt: `${JSON_SYSTEM_PROMPT}\n\n${existing}` };
 	});
 
-	// -- Subcommand handler (dispatched by the merged /opt router) --
-
-	function complete(prefix: string) {
-		const items = [
-			{ value: "on", label: "on", description: "Force JSON/TOON guidance on" },
-			{
-				value: "off",
-				label: "off",
-				description: "Force JSON/TOON guidance off",
-			},
-		];
-		const n = prefix.trim().toLowerCase();
-		const filtered = items.filter((i) => i.value.startsWith(n));
-		return filtered.length > 0 ? filtered : null;
-	}
+	// -- Overlay value handler (called by the /optimizer overlay) --
 
 	async function run(
-		args: string,
+		value: 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
+		enabled = value === "on";
 
-			syncStatus(ctx);
-			ctx.ui.notify(`JSON/TOON guidance ${enabled ? "on" : "off"}.`, "info");
-		}
+		syncStatus(ctx);
+		ctx.ui.notify(`JSON/TOON guidance ${enabled ? "on" : "off"}.`, "info");
 	}
 
 	return {
 		name: "toon",
-		help: "toon [on|off] — jq+TOON guidance for dense JSON",
+		help: "toon — jq+TOON guidance for dense JSON",
+		values: ["off", "on"],
+		current: () => (enabled ? "on" : "off"),
 		run,
-		complete,
 	};
 }

package/src/opt.test.ts

@@ -1,103 +1,60 @@
 import { describe, expect, it } from "bun:test";
-import { buildOptHelp, completeInvocation, parseInvocation } from "./opt.ts";
+import { buildOptHelp, levelBar } from "./opt.ts";
 import type { OptimizerHandle, OptimizerTool } from "./status.ts";
 
-/** Build a handle set with spy-able run/complete. */
+/** Build a handle set with fixed current values + value lists. */
 function fakeHandles(): Record<OptimizerTool, OptimizerHandle> {
-	const mk = (name: OptimizerTool): OptimizerHandle => ({
+	const mk = (
+		name: OptimizerTool,
+		current: string,
+		values: string[],
+	): OptimizerHandle => ({
 		name,
-		help: `${name} help`,
+		help: `${name} — ${name} help`,
+		values,
+		current: () => current,
 		run: () => {},
-		complete: (prefix: string) =>
-			["on", "off"]
-				.filter((v) => v.startsWith(prefix.trim().toLowerCase()))
-				.map((v) => ({ value: v, label: v, description: v })),
 	});
 	return {
-		caveman: mk("caveman"),
-		rtk: mk("rtk"),
-		toon: mk("toon"),
-		ponytail: mk("ponytail"),
+		caveman: mk("caveman", "full", ["off", "lite", "full", "ultra", "micro"]),
+		rtk: mk("rtk", "on", ["off", "on"]),
+		toon: mk("toon", "off", ["off", "on"]),
+		ponytail: mk("ponytail", "off", ["off", "lite", "full", "ultra"]),
 	};
 }
 
-describe("parseInvocation", () => {
-	it("empty args → empty name", () => {
-		expect(parseInvocation("")).toEqual({ name: "", rest: "" });
-		expect(parseInvocation("   ")).toEqual({ name: "", rest: "" });
-	});
+describe("levelBar", () => {
+	const PONYTAIL = ["off", "lite", "full", "ultra"];
+	const BINARY = ["off", "on"];
 
-	it("single token → name only", () => {
-		expect(parseInvocation("rtk")).toEqual({ name: "rtk", rest: "" });
-		expect(parseInvocation("  RTK  ")).toEqual({ name: "rtk", rest: "" });
+	it("fills segments by value position in a multi-step ladder", () => {
+		expect(levelBar("off", PONYTAIL)).toBe("▱▱▱");
+		expect(levelBar("lite", PONYTAIL)).toBe("▰▱▱");
+		expect(levelBar("full", PONYTAIL)).toBe("▰▰▱");
+		expect(levelBar("ultra", PONYTAIL)).toBe("▰▰▰");
 	});
 
-	it("splits name from rest", () => {
-		expect(parseInvocation("caveman ultra")).toEqual({
-			name: "caveman",
-			rest: "ultra",
-		});
-		expect(parseInvocation("rtk on extra")).toEqual({
-			name: "rtk",
-			rest: "on extra",
-		});
+	it("renders a single segment for binary tools", () => {
+		expect(levelBar("off", BINARY)).toBe("▱");
+		expect(levelBar("on", BINARY)).toBe("▰");
 	});
-});
 
-describe("completeInvocation", () => {
-	it("completes tool names before any space", () => {
-		const handles = fakeHandles();
-		const out = completeInvocation("r", handles);
-		expect(out?.map((i) => i.value)).toEqual(["rtk"]);
+	it("treats an unknown value as off (no fill)", () => {
+		expect(levelBar("???", PONYTAIL)).toBe("▱▱▱");
 	});
 
-	it("returns all tool names for empty prefix", () => {
-		const handles = fakeHandles();
-		const out = completeInvocation("", handles);
-		expect(out?.map((i) => i.value)).toEqual([
-			"caveman",
-			"rtk",
-			"toon",
-			"ponytail",
-		]);
-	});
-
-	it("delegates to the tool completer after the name", () => {
-		const handles = fakeHandles();
-		const out = completeInvocation("rtk o", handles);
-		expect(out?.map((i) => i.value)).toEqual(["on", "off"]);
-	});
-
-	it("null for unknown tool", () => {
-		const handles = fakeHandles();
-		expect(completeInvocation("nope x", handles)).toBeNull();
+	it("returns empty string when there are no non-off steps", () => {
+		expect(levelBar("off", ["off"])).toBe("");
 	});
 });
 
 describe("buildOptHelp", () => {
-	it("lists every tool's help line", () => {
+	it("lists every tool with its current value", () => {
 		const help = buildOptHelp(fakeHandles());
-		expect(help).toContain("/opt caveman help");
-		expect(help).toContain("/opt rtk help");
-		expect(help).toContain("/opt toon help");
-		expect(help).toContain("/opt ponytail help");
-		expect(help).toContain("Usage: /opt <tool> [args]");
-	});
-});
-
-describe("dispatch via run", () => {
-	it("routes rest to the matching handle", () => {
-		const handles = fakeHandles();
-		let received: string | null = null;
-		handles.rtk.run = (args: string) => {
-			received = args;
-		};
-		const { name, rest } = parseInvocation("rtk off");
-		expect(name).toBe("rtk");
-		void handles[name as OptimizerTool].run(rest, {} as never);
-		// `received` is mutated inside the run() callback above; TS narrows it to
-		// `null` here since it can't see the side effect, so read it through an
-		// untyped cast before asserting.
-		expect(received as string | null).toBe("off");
+		expect(help).toContain("caveman: full");
+		expect(help).toContain("rtk: on");
+		expect(help).toContain("toon: off");
+		expect(help).toContain("ponytail: off");
+		expect(help).toContain("caveman help");
 	});
 });