@hheei/omp-optimizer 0.1.0

package/src/persist.test.ts

@@ -0,0 +1,52 @@
+/** Persistence contract for optimizer values across fresh store instances. */
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import * as path from "node:path";
+import { createOptimizerStore } from "./persist.ts";
+
+let tmpAgentDir: string;
+let statePath: string;
+
+beforeAll(() => {
+	tmpAgentDir = mkdtempSync(path.join(tmpdir(), "omp-optimizer-persist-test-"));
+	statePath = path.join(tmpAgentDir, "optimizer.json");
+});
+
+afterAll(() => {
+	rmSync(tmpAgentDir, { recursive: true, force: true });
+});
+
+describe("optimizer persistence", () => {
+	test("returns undefined before anything is saved", () => {
+		expect(createOptimizerStore(statePath).load("caveman")).toBeUndefined();
+	});
+
+	test("round-trips a value across fresh store instances", () => {
+		createOptimizerStore(statePath).save("caveman", "lite");
+		expect(createOptimizerStore(statePath).load("caveman")).toBe("lite");
+	});
+
+	test("persists each tool independently in one shared file", () => {
+		const store = createOptimizerStore(statePath);
+		store.save("ponytail", "full");
+		store.save("rtk", "off");
+		expect(store.load("caveman")).toBe("lite");
+		expect(store.load("ponytail")).toBe("full");
+		expect(store.load("rtk")).toBe("off");
+	});
+
+	test("overwriting one tool leaves the others intact", () => {
+		const store = createOptimizerStore(statePath);
+		store.save("caveman", "ultra");
+		expect(store.load("caveman")).toBe("ultra");
+		expect(store.load("ponytail")).toBe("full");
+	});
+
+	test("drops legacy TOON state on the next write", () => {
+		writeFileSync(statePath, JSON.stringify({ caveman: "lite", toon: "on" }));
+		createOptimizerStore(statePath).save("rtk", "on");
+		expect(JSON.parse(readFileSync(statePath, "utf8"))).toEqual({ caveman: "lite", rtk: "on" });
+	});
+});

package/src/persist.ts

@@ -0,0 +1,58 @@
+/** Disk-backed persistence for optimizer values. */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getAgentDir, logger } from "@oh-my-pi/pi-utils";
+import type { OptimizerTool } from "./status.ts";
+
+type OptimizerFileConfig = Partial<Record<OptimizerTool, string>>;
+
+const OPTIMIZER_TOOLS: readonly OptimizerTool[] = ["caveman", "rtk", "ponytail", "t2s"];
+
+export interface OptimizerStore {
+	load(tool: OptimizerTool): string | undefined;
+	save(tool: OptimizerTool, value: string): void;
+}
+
+export function createOptimizerStore(statePath: string): OptimizerStore {
+	const readState = (): OptimizerFileConfig => {
+		try {
+			if (!fs.existsSync(statePath)) return {};
+			const raw = JSON.parse(fs.readFileSync(statePath, "utf8")) as unknown;
+			if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
+
+			const config: OptimizerFileConfig = {};
+			for (const tool of OPTIMIZER_TOOLS) {
+				const value = (raw as Record<string, unknown>)[tool];
+				if (typeof value === "string") config[tool] = value;
+			}
+			return config;
+		} catch {
+			return {};
+		}
+	};
+
+	return {
+		load: (tool: OptimizerTool) => readState()[tool],
+		save: (tool: OptimizerTool, value: string) => {
+			try {
+				fs.mkdirSync(path.dirname(statePath), { recursive: true });
+				fs.writeFileSync(statePath, JSON.stringify({ ...readState(), [tool]: value }, null, 2), "utf8");
+			} catch (error) {
+				logger.warn("omp-optimizer: failed to persist state", { tool, error: String(error) });
+			}
+		},
+	};
+}
+
+function defaultStore(): OptimizerStore {
+	return createOptimizerStore(path.join(getAgentDir(), "optimizer.json"));
+}
+
+export function loadOptValue(tool: OptimizerTool): string | undefined {
+	return defaultStore().load(tool);
+}
+
+export function saveOptValue(tool: OptimizerTool, value: string): void {
+	defaultStore().save(tool, value);
+}

package/src/ponytail.test.ts

@@ -0,0 +1,195 @@
+import { describe, expect, it } from "bun:test";
+import {
+	buildHelp,
+	buildPrompt,
+	LEVEL_NUMBERS,
+	LEVELS,
+	type Level,
+	resolveLevel,
+	STATUS_LABELS,
+	STOP_ALIASES,
+	toggleLevel,
+} from "./ponytail.ts";
+
+// ── LEVELS ────────────────────────────────────────────────────────────────────
+
+describe("LEVELS", () => {
+	it("contains off as first entry", () => {
+		expect(LEVELS[0]).toBe("off");
+	});
+
+	it("contains all expected levels", () => {
+		const expected: Level[] = ["off", "lite", "full", "ultra"];
+		for (const l of expected) expect(LEVELS).toContain(l);
+	});
+
+	it("has no micro level (caveman-only)", () => {
+		expect(LEVELS).not.toContain("micro" as Level);
+	});
+});
+
+// ── STOP_ALIASES ──────────────────────────────────────────────────────────────
+
+describe("STOP_ALIASES", () => {
+	it("includes off, stop, quit", () => {
+		expect(STOP_ALIASES.has("off")).toBe(true);
+		expect(STOP_ALIASES.has("stop")).toBe(true);
+		expect(STOP_ALIASES.has("quit")).toBe(true);
+	});
+
+	it("does not include active levels", () => {
+		expect(STOP_ALIASES.has("full")).toBe(false);
+		expect(STOP_ALIASES.has("ultra")).toBe(false);
+	});
+});
+
+// ── STATUS_LABELS ─────────────────────────────────────────────────────────────
+
+describe("STATUS_LABELS", () => {
+	it("has a label for every non-off level", () => {
+		const nonOff = LEVELS.filter((l) => l !== "off") as Exclude<Level, "off">[];
+		for (const l of nonOff) {
+			expect(STATUS_LABELS[l]).toBeTruthy();
+		}
+	});
+
+	it("levels are uppercase", () => {
+		expect(STATUS_LABELS.lite).toBe("LITE");
+		expect(STATUS_LABELS.full).toBe("FULL");
+		expect(STATUS_LABELS.ultra).toBe("ULTRA");
+	});
+});
+
+// ── resolveLevel ──────────────────────────────────────────────────────────────
+
+describe("resolveLevel", () => {
+	it("resolves valid levels", () => {
+		expect(resolveLevel("lite")).toBe("lite");
+		expect(resolveLevel("full")).toBe("full");
+		expect(resolveLevel("ultra")).toBe("ultra");
+		expect(resolveLevel("off")).toBe("off");
+	});
+
+	it("maps stop aliases to off", () => {
+		expect(resolveLevel("stop")).toBe("off");
+		expect(resolveLevel("quit")).toBe("off");
+	});
+
+	it("is case-insensitive", () => {
+		expect(resolveLevel("FULL")).toBe("full");
+		expect(resolveLevel("Ultra")).toBe("ultra");
+		expect(resolveLevel("STOP")).toBe("off");
+	});
+
+	it("trims whitespace", () => {
+		expect(resolveLevel("  full  ")).toBe("full");
+	});
+
+	it("returns null for unknown input", () => {
+		expect(resolveLevel("unknown")).toBeNull();
+		expect(resolveLevel("")).toBeNull();
+		expect(resolveLevel("config")).toBeNull(); // config handled separately
+		expect(resolveLevel("micro")).toBeNull(); // no micro level
+	});
+});
+
+// ── numeric levels ────────────────────────────────────────────────────────────
+
+describe("numeric levels", () => {
+	it("maps 1/2/3 to lite/full/ultra", () => {
+		expect(resolveLevel("1")).toBe("lite");
+		expect(resolveLevel("2")).toBe("full");
+		expect(resolveLevel("3")).toBe("ultra");
+	});
+
+	it("maps 0 to off", () => {
+		expect(resolveLevel("0")).toBe("off");
+	});
+
+	it("LEVEL_NUMBERS only covers 1-3", () => {
+		expect(Object.keys(LEVEL_NUMBERS).sort()).toEqual(["1", "2", "3"]);
+	});
+
+	it("rejects out-of-range numbers", () => {
+		expect(resolveLevel("4")).toBeNull();
+		expect(resolveLevel("9")).toBeNull();
+	});
+
+	it("trims whitespace around numbers", () => {
+		expect(resolveLevel("  2  ")).toBe("full");
+	});
+});
+
+// ── buildHelp ─────────────────────────────────────────────────────────────────
+
+describe("buildHelp", () => {
+	it("lists numeric shortcuts", () => {
+		const help = buildHelp("off");
+		expect(help).toContain("1");
+		expect(help).toContain("lite");
+		expect(help).toContain("2");
+		expect(help).toContain("full");
+		expect(help).toContain("3");
+		expect(help).toContain("ultra");
+	});
+
+	it("shows current level when active", () => {
+		expect(buildHelp("ultra")).toContain("ULTRA");
+	});
+
+	it("shows off when disabled", () => {
+		expect(buildHelp("off")).toContain("off");
+	});
+
+	it("mentions config", () => {
+		expect(buildHelp("off")).toContain("config");
+	});
+});
+
+// ── toggleLevel ───────────────────────────────────────────────────────────────
+
+describe("toggleLevel", () => {
+	it("off → full", () => {
+		expect(toggleLevel("off")).toBe("full");
+	});
+
+	it("full → off", () => {
+		expect(toggleLevel("full")).toBe("off");
+	});
+
+	it("any non-off level → off", () => {
+		const nonOff = LEVELS.filter((l) => l !== "off") as Level[];
+		for (const l of nonOff) {
+			expect(toggleLevel(l)).toBe("off");
+		}
+	});
+});
+
+// ── buildPrompt ───────────────────────────────────────────────────────────────
+
+describe("buildPrompt", () => {
+	it("returns empty string for off", () => {
+		expect(buildPrompt("off")).toBe("");
+	});
+
+	it("includes BASE ladder for all active levels", () => {
+		for (const l of ["lite", "full", "ultra"] as Level[]) {
+			expect(buildPrompt(l)).toContain("PONYTAIL MODE ACTIVE");
+			expect(buildPrompt(l)).toContain("first rung that holds");
+		}
+	});
+
+	it("includes SAFETY clause for all active levels", () => {
+		for (const l of ["lite", "full", "ultra"] as Level[]) {
+			expect(buildPrompt(l)).toContain("When NOT to be lazy");
+		}
+	});
+
+	it("each level has distinct intensity instructions", () => {
+		const lite = buildPrompt("lite");
+		const ultra = buildPrompt("ultra");
+		expect(lite).toContain("name the lazier alternative");
+		expect(ultra).toContain("YAGNI extremist");
+		expect(lite).not.toContain("YAGNI extremist");
+	});
+});

package/src/ponytail.ts

@@ -0,0 +1,145 @@
+/**
+ * ponytail.ts — pure logic + Pi extension
+ *
+ * "Lazy senior dev" mode: governs WHAT the agent builds (minimal code, YAGNI),
+ * orthogonal to caveman which governs HOW it talks. Pure helpers exported for
+ * tests; ponytail(pi, status) is the extension entry, wired by index.ts.
+ *
+ * Ruleset adapted from DietrichGebert/ponytail (MIT), the "lazy senior dev"
+ * skill. We inject it as a system-prompt fragment — no external hooks/files.
+ */
+
+import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import {
+	createMode,
+	resolveLevel as resolveLevelGeneric,
+	toggleLevel as toggleLevelGeneric,
+} from "./mode.ts";
+import type { OptimizerHandle, OptimizerStatus } from "./status.ts";
+
+// ── Levels ────────────────────────────────────────────────────────────────────
+
+export const LEVELS = ["off", "lite", "full", "ultra"] as const;
+
+export type Level = (typeof LEVELS)[number];
+
+export const STOP_ALIASES = new Set(["off", "stop", "quit", "0"]);
+
+// Numeric shortcuts: /opt ponytail 1|2|3
+export const LEVEL_NUMBERS: Record<string, Level> = {
+	"1": "lite",
+	"2": "full",
+	"3": "ultra",
+};
+
+// ── Status labels ─────────────────────────────────────────────────────────────
+
+export const STATUS_LABELS: Record<Exclude<Level, "off">, string> = {
+	lite: "LITE",
+	full: "FULL",
+	ultra: "ULTRA",
+};
+
+// ── Prompt fragments ──────────────────────────────────────────────────────────
+
+const BASE = `\
+PONYTAIL MODE ACTIVE. You are a lazy senior developer. Lazy means efficient, \
+not careless. The best code is the code never written.
+
+Before writing any code, stop at the first rung that holds:
+1. Does this need to exist at all? Speculative need = skip it, say so in one line. (YAGNI)
+2. Stdlib does it? Use it.
+3. Native platform feature covers it? Use it (\`<input type="date">\` over a picker lib, CSS over JS, DB constraint over app code).
+4. Already-installed dependency solves it? Use it. Never add a new one for what a few lines can do.
+5. Can it be one line? One line.
+6. Only then: the minimum code that works.
+
+The ladder is a reflex, not a research project. Two rungs work → take the higher one and move on.
+
+Rules:
+- No unrequested abstractions: no interface with one impl, no factory for one product, no config for a value that never changes.
+- No boilerplate, no scaffolding "for later". Deletion over addition. Boring over clever. Fewest files possible.
+- Complex request? Ship the lazy version and question it in the same response. Never stall on an answer you can default.
+- Two same-size stdlib options? Take the one correct on edge cases. Lazy means less code, not the flimsier algorithm.
+- Mark deliberate simplifications with a \`ponytail:\` comment. A shortcut with a known ceiling names the ceiling and the upgrade path.`;
+
+const INTENSITY: Record<Exclude<Level, "off">, string> = {
+	lite: `\
+Build what's asked, but name the lazier alternative in one line. User picks.
+Example: "Done, cache added. FYI: \`functools.lru_cache\` covers this in one line if you'd rather not own a cache class."`,
+
+	full: `\
+The ladder enforced. Stdlib and native first. Shortest diff, shortest explanation.
+Example: "\`@lru_cache(maxsize=1000)\` on the fetch function. Skipped custom cache class, add when lru_cache measurably falls short."`,
+
+	ultra: `\
+YAGNI extremist. Deletion before addition. Ship the one-liner and challenge the rest of the requirement in the same breath.
+Example: "No cache until a profiler says so. When it does: \`@lru_cache\`. A hand-rolled TTL cache class is a bug farm with a hit rate."`,
+};
+
+const SAFETY = `\
+When NOT to be lazy: never simplify away input validation at trust boundaries, \
+error handling that prevents data loss, security, accessibility, or anything \
+explicitly requested. Hardware is never the spec ideal — leave the calibration knob.
+Lazy code without its check is unfinished: non-trivial logic leaves ONE runnable check behind \
+(an assert-based self-check or one small test file; no frameworks). Trivial one-liners need no test.
+Output: code first, then at most three short lines — what was skipped, when to add it.
+Boundaries: ponytail governs what you build, not how you talk. "stop ponytail" / "normal mode" reverts.`;
+
+/**
+ * Build the system prompt injection for a given level.
+ * Returns empty string when level is "off".
+ */
+export function buildPrompt(level: Level): string {
+	if (level === "off") return "";
+	return [BASE, "", `Intensity: ${INTENSITY[level]}`, "", SAFETY].join("\n");
+}
+
+// ── Level resolution ──────────────────────────────────────────────────────────
+
+/**
+ * Resolve a raw command arg to a Level, or return null if unrecognised.
+ * Handles stop aliases (stop/quit → "off") and valid level names.
+ */
+export function resolveLevel(arg: string): Level | null {
+	return resolveLevelGeneric(arg, LEVELS, LEVEL_NUMBERS, STOP_ALIASES);
+}
+
+/**
+ * Help text shown when /opt ponytail is run with no argument.
+ */
+export function buildHelp(current: Level): string {
+	const statusLine = current === "off" ? "off" : `${STATUS_LABELS[current]} (${current})`;
+	return [
+		`Ponytail mode: ${statusLine}`,
+		"",
+		"Usage: /optimizer ponytail <level>",
+		"  1  lite   - name the lazier alternative, you pick",
+		"  2  full   - the ladder enforced (default)",
+		"  3  ultra  - YAGNI extremist",
+		"  0  off    - disable (aliases: off, stop, quit)",
+		"",
+		"  config    - open settings dialog",
+	].join("\n");
+}
+
+/**
+ * Toggle: off → full, anything else → off.
+ */
+export function toggleLevel(current: Level): Level {
+	return toggleLevelGeneric(current);
+}
+
+// ── Pi extension ────────────────────────────────────────────────────────────
+
+export function ponytail(pi: ExtensionAPI, status: OptimizerStatus): OptimizerHandle {
+	return createMode(pi, status, {
+		name: "ponytail",
+		help: "ponytail — lazy senior dev (minimal code)",
+		levels: LEVELS,
+		buildPrompt,
+		resolve: resolveLevel,
+		notify: (level) =>
+			level === "off" ? "Ponytail mode off." : `Ponytail: ${STATUS_LABELS[level]}`,
+	});
+}