@xynogen/pix-optimizer 1.1.4 → 1.1.7

package/src/opt.ts

@@ -1,108 +1,215 @@
 /**
- * opt.ts — the single `/opt` command that fronts every optimizer tool.
+ * opt.ts — the single `/optimizer` command: an interactive overlay that fronts
+ * every optimizer tool.
  *
- * caveman / rtk / json each register their own lifecycle hooks but expose an
- * OptimizerHandle for command dispatch. This router wires them under one
- * command so there's exactly one entry point:
+ * caveman / rtk / toon / ponytail each register their own lifecycle hooks but
+ * expose an OptimizerHandle (name · values · current() · run()). This overlay
+ * renders one SettingsList row per tool:
  *
- *   /opt                  → status + help
- *   /opt caveman <level>  → caveman subcommand
- *   /opt rtk [on|off]     → rtk subcommand
- *   /opt toon [on|off]    → toon subcommand
+ *   ↑↓  move between tools
+ *   ←→  cycle the selected tool's value (off → level/on → …)
+ *   esc close
+ *
+ * Selecting a value calls the handle's run(), which persists + repaints the
+ * shared status cell. There is no text-arg form — the overlay is the only UI.
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import type {
-	CompletionItem,
-	OptimizerHandle,
-	OptimizerTool,
+import { frameLines } from "@xynogen/pix-pretty/modal-frame";
+import {
+	type OptimizerHandle,
+	type OptimizerStatus,
+	type OptimizerTool,
+	TOOL_ICONS,
 } from "./status.ts";
 
-/** Split raw args into the subcommand name and the rest. */
-export function parseInvocation(args: string): { name: string; rest: string } {
-	const trimmed = args.trim();
-	if (!trimmed) return { name: "", rest: "" };
-	const idx = trimmed.search(/\s/);
-	if (idx === -1) return { name: trimmed.toLowerCase(), rest: "" };
-	return {
-		name: trimmed.slice(0, idx).toLowerCase(),
-		rest: trimmed.slice(idx + 1),
-	};
+/** Min/max content width for the overlay box (excludes 4 cols of chrome). */
+const MIN_CONTENT = 28;
+const MAX_CONTENT = 60;
+
+/** Fixed render order — matches the status-bar cell. */
+const TOOL_ORDER: readonly OptimizerTool[] = [
+	"caveman",
+	"rtk",
+	"toon",
+	"ponytail",
+];
+
+/** Strip the leading "name [args] — " prefix from a handle's help string. */
+function helpSummary(help: string): string {
+	const dash = help.indexOf("—");
+	return dash === -1 ? help : help.slice(dash + 1).trim();
 }
 
+/** Filled / empty bar segment glyphs. */
+const BAR_FILLED = "▰";
+const BAR_EMPTY = "▱";
+
 /**
- * Compute completions for `/opt ...`:
- *   - first token → tool names (filtered by prefix)
- *   - after a known tool name → delegate to that tool's complete()
+ * Render an intensity bar for a tool's current value. One segment per
+ * non-"off" step in `values`; segments up to and including the current value's
+ * position are filled, the rest empty. "off" → all empty.
+ *
+ *   ponytail [off,lite,full,ultra]: off=▱▱▱ lite=▰▱▱ full=▰▰▱ ultra=▰▰▰
+ *   rtk      [off,on]:               off=▱   on=▰
  *
  * Pure + exported for tests.
  */
-export function completeInvocation(
-	args: string,
-	handles: Record<OptimizerTool, OptimizerHandle>,
-): CompletionItem[] | null {
-	// No space yet → still completing the tool name.
-	if (!/\s/.test(args.trimStart())) {
-		const prefix = args.trim().toLowerCase();
-		const names = (Object.keys(handles) as OptimizerTool[])
-			.filter((n) => n.startsWith(prefix))
-			.map((n) => ({
-				value: n,
-				label: n,
-				description: handles[n].help,
-			}));
-		return names.length > 0 ? names : null;
-	}
-
-	// Past the tool name → delegate to the tool's own completer.
-	const { name, rest } = parseInvocation(args);
-	const handle = handles[name as OptimizerTool];
-	if (!handle) return null;
-	return handle.complete(rest);
+export function levelBar(current: string, values: readonly string[]): string {
+	const segments = values.length - 1; // exclude "off"
+	if (segments < 1) return "";
+	const idx = values.indexOf(current); // 0 = off → 0 filled
+	const filled = Math.max(0, idx);
+	return BAR_FILLED.repeat(filled) + BAR_EMPTY.repeat(segments - filled);
 }
 
-/** Build the `/opt` help text listing every tool. */
+/** Plain-text status fallback when there's no custom-UI host (headless/tests). */
 export function buildOptHelp(
 	handles: Record<OptimizerTool, OptimizerHandle>,
 ): string {
-	const lines = (Object.keys(handles) as OptimizerTool[]).map(
-		(n) => `  /opt ${handles[n].help}`,
+	const lines = TOOL_ORDER.map(
+		(n) => `  ${n}: ${handles[n].current()}  — ${helpSummary(handles[n].help)}`,
 	);
-	return [
-		"pix-optimizer — token tools",
-		"",
-		"Usage: /opt <tool> [args]",
-		...lines,
-	].join("\n");
+	return ["pix-optimizer — token tools", "", ...lines].join("\n");
 }
 
 export function registerOptCommand(
 	pi: ExtensionAPI,
 	handles: Record<OptimizerTool, OptimizerHandle>,
+	_status: OptimizerStatus,
 ): void {
-	pi.registerCommand("opt", {
+	pi.registerCommand("optimizer", {
 		description: "pix-optimizer: caveman / rtk / toon / ponytail tools",
-		getArgumentCompletions: (prefix: string) =>
-			completeInvocation(prefix, handles),
-		handler: async (args, ctx) => {
-			const { name, rest } = parseInvocation(args ?? "");
+		handler: async (_args, ctx) => {
+			const ui = ctx.ui as unknown as {
+				theme: {
+					fg(c: string, t: string): string;
+					bg(c: string, t: string): string;
+					bold(t: string): string;
+				};
+				custom?: <T>(
+					f: unknown,
+					opts?: {
+						overlay?: boolean;
+						overlayOptions?: {
+							anchor?: string;
+							width?: number;
+							maxHeight?: string;
+						};
+					},
+				) => Promise<T>;
+				notify(m: string, t?: "info" | "warning" | "error"): void;
+			};
 
-			// No subcommand → show help.
-			if (!name) {
-				ctx.ui.notify(buildOptHelp(handles), "info");
+			// No custom-UI host (headless/tests) → plain status text.
+			if (typeof ui.custom !== "function") {
+				ui.notify(buildOptHelp(handles), "info");
 				return;
 			}
 
-			const handle = handles[name as OptimizerTool];
-			if (!handle) {
-				ctx.ui.notify(
-					`Unknown tool: "${name}". Try: ${Object.keys(handles).join(", ")}`,
-					"error",
-				);
-				return;
-			}
+			const nameWidth = Math.max(...TOOL_ORDER.map((n) => n.length));
+			// Widest value across all tools, so value columns line up.
+			const valueWidth = Math.max(
+				...TOOL_ORDER.flatMap((t) => handles[t].values.map((v) => v.length)),
+			);
+			// Fixed content width: widest help summary (the box's longest line) vs
+			// title, clamped. Fixed so the box doesn't resize as values/selection
+			// change and so the overlay can be centered at exactly this width.
+			const widestHelp = Math.max(
+				...TOOL_ORDER.map((t) => helpSummary(handles[t].help).length),
+				"󱎫  Optimizer".length,
+			);
+			const content = Math.min(MAX_CONTENT, Math.max(MIN_CONTENT, widestHelp));
+			const boxW = content + 4; // + chrome (2 border + 2 padding)
+
+			await ui.custom<null>(
+				(
+					tui: { requestRender(): void },
+					theme: typeof ui.theme,
+					_kb: unknown,
+					done: (v: null) => void,
+				) => {
+					let selected = 0;
+
+					const cycle = (direction: -1 | 1) => {
+						const tool = TOOL_ORDER[selected]!;
+						const values = handles[tool].values;
+						const cur = values.indexOf(handles[tool].current());
+						const next = (cur + direction + values.length) % values.length;
+						handles[tool].run(values[next]!, ctx);
+					};
+
+					const move = (direction: -1 | 1) => {
+						selected =
+							(selected + direction + TOOL_ORDER.length) % TOOL_ORDER.length;
+					};
 
-			await handle.run(rest, ctx);
+					return {
+						render: () => {
+							const rows = TOOL_ORDER.map((tool, i) => {
+								const on = handles[tool].current() !== "off";
+								const sel = i === selected;
+								const cursor = sel ? theme.fg("accent", "→") : " ";
+								const icon = theme.fg(on ? "accent" : "dim", TOOL_ICONS[tool]);
+								const name = theme.fg(
+									sel ? "accent" : on ? "text" : "muted",
+									tool.padEnd(nameWidth),
+								);
+								const cur = handles[tool].current();
+								const value = theme.fg(
+									on ? "success" : "dim",
+									cur.padEnd(valueWidth),
+								);
+								const bar = theme.fg(
+									on ? "accent" : "dim",
+									levelBar(cur, handles[tool].values),
+								);
+								return `${cursor} ${icon}  ${name}  ${value}  ${bar}`;
+							});
+							const lines = [
+								theme.fg("accent", theme.bold("󱎫  Optimizer")),
+								"",
+								...rows,
+								"",
+								theme.fg(
+									"dim",
+									helpSummary(handles[TOOL_ORDER[selected]!].help),
+								),
+								"",
+								theme.fg("dim", "←→ change · ↑↓ move · esc close"),
+							];
+							return frameLines({
+								width: boxW,
+								lines,
+								color: (s) => theme.fg("accent", s),
+								bg: (s) => theme.bg("customMessageBg", s),
+							});
+						},
+						invalidate: () => {},
+						handleInput: (data: string) => {
+							if (data === "k" || data === "\u001b[A") move(-1);
+							else if (data === "j" || data === "\u001b[B") move(1);
+							else if (data === "h" || data === "\u001b[D") cycle(-1);
+							else if (
+								data === "l" ||
+								data === "\u001b[C" ||
+								data === " " ||
+								data === "\r"
+							)
+								cycle(1);
+							else if (data === "\u001b" || data === "q") {
+								done(null);
+								return;
+							} else return;
+							tui.requestRender();
+						},
+					};
+				},
+				{
+					overlay: true,
+					overlayOptions: { anchor: "center", width: boxW, maxHeight: "80%" },
+				},
+			);
 		},
 	});
 }

package/src/persist.test.ts

@@ -0,0 +1,56 @@
+/**
+ * Regression test for the cross-session reset bug: optimizer tool states
+ * (caveman/ponytail/rtk/toon) were lost on a full quit/restart because they
+ * only persisted to the session log. persist.ts adds disk persistence so a
+ * value written in one session is readable in the next.
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { loadOptValue, saveOptValue } from "./persist.ts";
+
+let tmpAgentDir: string;
+
+beforeAll(() => {
+	tmpAgentDir = mkdtempSync(join(tmpdir(), "optimizer-persist-test-"));
+	process.env.PI_CODING_AGENT_DIR = tmpAgentDir;
+});
+
+afterAll(() => {
+	delete process.env.PI_CODING_AGENT_DIR;
+	try {
+		rmSync(tmpAgentDir, { recursive: true });
+	} catch {
+		// temp dir may already be gone — safe to ignore
+	}
+});
+
+describe("optimizer persistence", () => {
+	test("returns undefined before anything is saved", () => {
+		expect(loadOptValue("caveman")).toBeUndefined();
+	});
+
+	test("round-trips a single tool value across save/load (new-session sim)", () => {
+		saveOptValue("caveman", "lite");
+		// A fresh load (as a new session would do) sees the persisted value.
+		expect(loadOptValue("caveman")).toBe("lite");
+	});
+
+	test("persists each tool independently in one shared file", () => {
+		saveOptValue("ponytail", "full");
+		saveOptValue("rtk", "off");
+		saveOptValue("toon", "on");
+		expect(loadOptValue("caveman")).toBe("lite");
+		expect(loadOptValue("ponytail")).toBe("full");
+		expect(loadOptValue("rtk")).toBe("off");
+		expect(loadOptValue("toon")).toBe("on");
+	});
+
+	test("overwriting one tool leaves the others intact", () => {
+		saveOptValue("caveman", "ultra");
+		expect(loadOptValue("caveman")).toBe("ultra");
+		expect(loadOptValue("ponytail")).toBe("full");
+	});
+});

package/src/persist.ts

@@ -0,0 +1,50 @@
+/**
+ * persist.ts — disk-backed persistence for the /optimizer tool states.
+ *
+ * caveman/ponytail previously saved only to the session log (lost on a fresh
+ * session); rtk/toon never persisted at all. This stores every tool's current
+ * value in one file under the agent dir so the picker survives a full quit and
+ * restart. Each tool reads its value on session_start and writes on run().
+ *
+ *   ~/.pi/agent/optimizer.json  →  { "caveman": "lite", "rtk": "on", ... }
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import type { OptimizerTool } from "./status.ts";
+
+type OptimizerConfig = Partial<Record<OptimizerTool, string>>;
+
+function getStatePath(): string {
+	return join(getAgentDir(), "optimizer.json");
+}
+
+function readAll(): OptimizerConfig {
+	try {
+		const sp = getStatePath();
+		if (!existsSync(sp)) return {};
+		const raw = JSON.parse(readFileSync(sp, "utf-8")) as OptimizerConfig;
+		return raw && typeof raw === "object" ? raw : {};
+	} catch {
+		// Missing, corrupt, or no getAgentDir (tests/headless) — start clean.
+		return {};
+	}
+}
+
+/** Read a single tool's persisted value, or undefined if none. */
+export function loadOptValue(tool: OptimizerTool): string | undefined {
+	return readAll()[tool];
+}
+
+/** Persist a single tool's value, merging into the shared config file. */
+export function saveOptValue(tool: OptimizerTool, value: string): void {
+	try {
+		const sp = getStatePath();
+		mkdirSync(dirname(sp), { recursive: true });
+		const next = { ...readAll(), [tool]: value };
+		writeFileSync(sp, JSON.stringify(next, null, 2), "utf-8");
+	} catch (err) {
+		console.warn(`optimizer: persist ${tool} failed:`, err);
+	}
+}

package/src/ponytail.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,
@@ -195,42 +193,3 @@ describe("buildPrompt", () => {
 		expect(lite).not.toContain("YAGNI extremist");
 	});
 });
-
-// ── 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("default level is full", () => {
-		expect(DEFAULT_CONFIG.defaultLevel).toBe("full");
-	});
-
-	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);
-		}
-	});
-});