@xynogen/pix-optimizer 1.1.3 → 1.1.6

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/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);
-		}
-	});
-});

package/src/ponytail.ts

@@ -9,21 +9,11 @@
  * skill. We inject it as a system-prompt fragment — no external hooks/files.
  */
 
-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 ────────────────────────────────────────────────────────────────────
@@ -41,19 +31,6 @@ export const LEVEL_NUMBERS: Record<string, Level> = {
 	"3": "ultra",
 };
 
-const PONYTAIL_COMMAND_OPTIONS = [
-	{ value: "1", label: "1 (lite)", description: "Name the lazier alternative" },
-	{ value: "2", label: "2 (full)", description: "The ladder enforced" },
-	{ value: "3", label: "3 (ultra)", description: "YAGNI extremist" },
-	{ value: "lite", label: "lite", description: "Name the lazier alternative" },
-	{ value: "full", label: "full", description: "The ladder enforced" },
-	{ value: "ultra", label: "ultra", description: "YAGNI extremist" },
-	{ value: "off", label: "off", description: "Disable ponytail mode" },
-	{ value: "stop", label: "stop", description: "Disable ponytail mode" },
-	{ value: "quit", label: "quit", description: "Disable ponytail mode" },
-	{ value: "config", label: "config", description: "Open settings dialog" },
-] as const;
-
 // ── Status labels ─────────────────────────────────────────────────────────────
 
 export const STATUS_LABELS: Record<Exclude<Level, "off">, string> = {
@@ -140,7 +117,7 @@ export function buildHelp(current: Level): string {
 	return [
 		`Ponytail mode: ${statusLine}`,
 		"",
-		"Usage: /opt ponytail <level>",
+		"Usage: /optimizer ponytail <level>",
 		"  1  lite   - name the lazier alternative, you pick",
 		"  2  full   - the ladder enforced (default)",
 		"  3  ultra  - YAGNI extremist",
@@ -157,55 +134,6 @@ export function toggleLevel(current: Level): Level {
 	return current === "off" ? "full" : "off";
 }
 
-// ── Config ────────────────────────────────────────────────────────────────────
-
-export interface PonytailConfig {
-	/** 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: PonytailConfig = {
-	defaultLevel: "full",
-	showStatus: true,
-};
-
-const CONFIG_PATH = join(homedir(), ".pi", "agent", "ponytail.json");
-
-export function parseConfig(raw: unknown): PonytailConfig {
-	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<PonytailConfig> {
-	try {
-		const raw = await readFile(CONFIG_PATH, "utf8");
-		return parseConfig(JSON.parse(raw));
-	} catch {
-		return { ...DEFAULT_CONFIG };
-	}
-}
-
-async function saveConfig(config: PonytailConfig): 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 ponytail(
@@ -213,26 +141,11 @@ export function ponytail(
 	status: OptimizerStatus,
 ): OptimizerHandle {
 	let level: Level = "off";
-	let config: PonytailConfig = { ...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("ponytail", on, ctx);
+		status.set("ponytail", level !== "off", ctx);
 	}
 
 	// Inject ponytail prompt via before_agent_start
@@ -243,25 +156,14 @@ export function ponytail(
 		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 === "ponytail-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("ponytail-level", { level });
-		}
-
 		syncStatus(ctx);
 	});
 
@@ -273,33 +175,14 @@ export function ponytail(
 	});
 	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("ponytail-level", { level });
@@ -313,127 +196,11 @@ export function ponytail(
 		);
 	}
 
-	function complete(prefix: string) {
-		const normalized = prefix.trim().toLowerCase();
-		const items = PONYTAIL_COMMAND_OPTIONS.filter((item) =>
-			item.value.startsWith(normalized),
-		);
-		return items.length > 0 ? items.map((i) => ({ ...i })) : null;
-	}
-
-	// -- 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(" Ponytail Config")), 0, 0),
-			);
-			container.addChild(
-				new Text(theme.fg("dim", " Saved to ~/.pi/agent/ponytail.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(data);
-					_tui.requestRender();
-				},
-			};
-		});
-	}
-
 	return {
 		name: "ponytail",
-		help: "ponytail <1|2|3|lite|full|ultra|off|config> — lazy senior dev (minimal code)",
+		help: "ponytail — lazy senior dev (minimal code)",
+		values: LEVELS,
+		current: () => level,
 		run,
-		complete,
 	};
 }

package/src/rtk.test.ts

@@ -68,6 +68,11 @@ describe("rewriteChain", () => {
 		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",