pi-mega-compact 0.7.9 → 0.8.1

package/extensions/mega-game-cmds.test.ts

@@ -0,0 +1,143 @@
+/**
+ * mega-game-cmds.test.ts — /mega-game command parsing matrix (S30).
+ * Uses an isolated state dir + a fake pi harness (mirrors mega-compact.test.ts).
+ * Pi runtime is mocked; the src/ helpers under test are pi-agnostic.
+ */
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { mkdtempSync, rmSync } from "node:fs";
+import { createRequire } from "node:module";
+import { closeStore, getGameState } from "../src/store/sqlite.js";
+import { THEME_IDS } from "../src/config/themes.js";
+
+// ESM bootstrap so `require()` works in this .test.ts (mirrors
+// mega-compact.test.ts:20-24). Needed for the dynamic `require("./mega-game-cmds.js")`
+// that wires the command against a fake pi without binding to the real pi
+// module at load time.
+const require = createRequire(import.meta.url);
+
+type Cmd = { description?: string; handler: (args: string, ctx: any) => Promise<void> };
+
+type Harness = {
+  commands: Record<string, Cmd>;
+  notifies: string[];
+  ctx: any;
+};
+
+function makeHarness(stateDir: string): Harness {
+  const commands: Record<string, Cmd> = {};
+  const notifies: string[] = [];
+  const runtime = { bindRepo: () => {}, currentStateDir: stateDir, bumpGameState: () => {} };
+  const ctx = {
+    cwd: stateDir,
+    ui: { notify: (s: string) => notifies.push(s) },
+  };
+  const fakePi = {
+    registerCommand: (name: string, opts: Cmd) => {
+      commands[name] = opts;
+    },
+  };
+  // Import after env is set so stateDir resolves. Dynamic import keeps the
+  // test from binding to the real pi module at load time.
+  const mod = require("./mega-game-cmds.js") as {
+    registerGameCommands: (pi: unknown, runtime: unknown) => void;
+  };
+  mod.registerGameCommands(fakePi, runtime);
+  return { commands, notifies, ctx };
+}
+
+describe("/mega-compact-settings (S30; /mega-game alias)", () => {
+  let dir: string;
+  before(() => {
+    dir = mkdtempSync(join(tmpdir(), "mc-megagame-"));
+    process.env.MEGACOMPACT_STATE_DIR = dir;
+  });
+  after(() => {
+    closeStore(dir);
+    delete process.env.MEGACOMPACT_STATE_DIR;
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  async function run(args: string): Promise<string[]> {
+    const h = makeHarness(dir);
+    h.notifies.length = 0;
+    await h.commands["mega-game"].handler(args, h.ctx);
+    return h.notifies;
+  }
+
+  it("registers /mega-compact-settings as primary + /mega-game as alias", async () => {
+    const h = makeHarness(dir);
+    assert.ok(h.commands["mega-compact-settings"], "primary registered");
+    assert.ok(h.commands["mega-game"], "alias registered");
+  });
+
+  it("bare command prints current (default) state", async () => {
+    const lines = await run("");
+    assert.ok(lines.some((l) => l.includes("game mode: off")));
+    assert.ok(lines.some((l) => l.includes("transparent")));
+    assert.ok(lines.some((l) => l.includes("tui:")));
+  });
+
+  it("on enables game mode and persists", async () => {
+    await run("on");
+    assert.equal(getGameState().game_mode_on, true);
+  });
+
+  it("off disables game mode and persists", async () => {
+    await run("on");
+    await run("off");
+    assert.equal(getGameState().game_mode_on, false);
+  });
+
+  it("theme <id> sets a valid theme and persists", async () => {
+    await run("theme retro");
+    assert.equal(getGameState().theme, "retro");
+    await run("theme cyan-neon");
+    assert.equal(getGameState().theme, "cyan-neon");
+  });
+
+  it("theme <unknown> is rejected with a usage line and does not mutate", async () => {
+    await run("theme retro");
+    const lines = await run("theme bogus");
+    assert.ok(lines.some((l) => l.includes("unknown theme")));
+    assert.equal(getGameState().theme, "retro");
+  });
+
+  it("theme next cycles to the next theme and wraps", async () => {
+    await run(`theme ${THEME_IDS[0]}`);
+    await run("theme next");
+    assert.equal(getGameState().theme, THEME_IDS[1]);
+    // cycle to the end then wrap
+    await run(`theme ${THEME_IDS[THEME_IDS.length - 1]!}`);
+    await run("theme next");
+    assert.equal(getGameState().theme, THEME_IDS[0]);
+  });
+
+  it("theme (bare) lists all themes", async () => {
+    const lines = await run("theme");
+    for (const id of THEME_IDS) {
+      assert.ok(lines.some((l) => l.includes(id)), `lists ${id}`);
+    }
+  });
+
+  it("tui full|minimal sets display mode and persists", async () => {
+    await run("tui minimal");
+    assert.equal(getGameState().tui_display_mode, "minimal");
+    await run("tui full");
+    assert.equal(getGameState().tui_display_mode, "full");
+  });
+
+  it("tui <bad> prints usage and does not mutate", async () => {
+    await run("tui minimal");
+    const lines = await run("tui huge");
+    assert.ok(lines.some((l) => l.includes("usage")));
+    assert.equal(getGameState().tui_display_mode, "minimal");
+  });
+
+  it("unknown subcommand prints usage", async () => {
+    const lines = await run("bogus");
+    assert.ok(lines.some((l) => l.includes("usage")));
+  });
+});

package/extensions/mega-game-cmds.ts

@@ -0,0 +1,142 @@
+/**
+ * mega-game-cmds.ts — /mega-compact-settings slash command (S30; renamed in v0.8.x).
+ *
+ * Backs the game-mode toggle + theme picker + TUI display mode. All state is
+ * the global `game_state` SQLite row (src/store/sqlite/game-state.ts) — local
+ * only (PREVENT-PI-004: no network; no guardrails-allow needed because this
+ * command touches no fetch/http). All SQL is parameterized (PREVENT-002) and
+ * lives in the src/ submodule, not here.
+ *
+ * The primary command is /mega-compact-settings. /mega-game is retained as a
+ * backward-compat alias (same handler) so existing muscle memory + docs keep
+ * working.
+ *
+ * Usage:
+ *   /mega-compact-settings                 print current state
+ *   /mega-compact-settings on              enable game mode (scoring + level-up + MEGA CACHE)
+ *   /mega-compact-settings off             disable game mode
+ *   /mega-compact-settings theme           list available themes
+ *   /mega-compact-settings theme <id>      set theme by id
+ *   /mega-compact-settings theme next      cycle to next theme
+ *   /mega-compact-settings tui full        full TUI widget (bars, stats, flair)
+ *   /mega-compact-settings tui minimal     one-line TUI widget (level + cache %)
+ *   /mega-compact-settings achievements      list unlocked achievements
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { MegaRuntime } from "./mega-runtime.js";
+import {
+  getGameState,
+  setGameState,
+  type GameState,
+} from "../src/store/sqlite.js";
+import { listAchievements } from "../src/store/sqlite/game-achievements.js";
+import { THEMES, THEME_IDS, getTheme, isValidTheme, nextTheme, DEFAULT_THEME } from "../src/config/themes.js";
+
+/** Notify/usage tag + command name. Primary surface is /mega-compact-settings. */
+const TAG = "mega-compact-settings";
+
+/** Format the current state as a human-readable status line set. */
+function fmtState(s: GameState): string[] {
+  return [
+    `[${TAG}] game mode: ${s.game_mode_on ? "ON" : "off"}`,
+    `  theme: ${s.theme}${s.theme === DEFAULT_THEME ? " (default)" : ""}`,
+    `  tui:   ${s.tui_display_mode}`,
+  ];
+}
+
+/** Shared handler for /mega-compact-settings (primary) + /mega-game (alias). */
+async function handleSettings(
+  args: string,
+  ctx: ExtensionContext,
+  runtime: MegaRuntime,
+): Promise<void> {
+  runtime.bindRepo(ctx.cwd);
+  const stateDir = runtime.currentStateDir;
+  const parts = args.trim().split(/\s+/).filter(Boolean);
+
+  // bare  → print current state.
+  if (parts.length === 0) {
+    const s = getGameState(stateDir);
+    for (const line of fmtState(s)) ctx.ui.notify(line);
+    return;
+  }
+
+  const sub = parts[0]!;
+
+  // achievements — terse list of unlocked (hidden only once unlocked).
+  if (sub === "achievements") {
+    const rows = listAchievements(stateDir).filter((r) => r.unlocked_at != null);
+    ctx.ui.notify(`[${TAG}] achievements unlocked (${rows.length}/9):`);
+    for (const r of rows) {
+      ctx.ui.notify(`  ${r.icon ?? ""} ${r.title}`);
+    }
+    return;
+  }
+
+  // on|off
+  if (sub === "on" || sub === "off") {
+    const s = setGameState({ game_mode_on: sub === "on" }, stateDir);
+    runtime.bumpGameState();
+    ctx.ui.notify(`[${TAG}] game mode ${s.game_mode_on ? "ON" : "off"}`);
+    return;
+  }
+
+  // theme [id|next]
+  if (sub === "theme") {
+    if (parts.length === 1) {
+      // list themes
+      ctx.ui.notify(`[${TAG}] themes:`);
+      for (const t of THEMES) {
+        ctx.ui.notify(`  ${t.id.padEnd(14)} ${t.label}`);
+      }
+      return;
+    }
+    const arg = parts[1]!;
+    let id: string;
+    if (arg === "next") {
+      id = nextTheme(getGameState(stateDir).theme);
+    } else if (isValidTheme(arg)) {
+      id = arg;
+    } else {
+      ctx.ui.notify(`[${TAG}] unknown theme "${arg}". Valid: ${THEME_IDS.join(", ")}`);
+      return;
+    }
+    const s = setGameState({ theme: id }, stateDir);
+    runtime.bumpGameState();
+    ctx.ui.notify(`[${TAG}] theme → ${s.theme} (${getTheme(s.theme)?.label ?? ""})`);
+    return;
+  }
+
+  // tui full|minimal
+  if (sub === "tui") {
+    const arg = parts[1];
+    if (arg !== "full" && arg !== "minimal") {
+      ctx.ui.notify(`[${TAG}] usage: /${TAG} tui full|minimal`);
+      return;
+    }
+    const s = setGameState({ tui_display_mode: arg }, stateDir);
+    runtime.bumpGameState();
+    ctx.ui.notify(`[${TAG}] tui → ${s.tui_display_mode}`);
+    return;
+  }
+
+  ctx.ui.notify(
+    `[${TAG}] usage: /${TAG} [on|off|theme [id|next]|tui [full|minimal]|achievements]`,
+  );
+}
+
+/** Register /mega-compact-settings (primary) + /mega-game (backward-compat alias). */
+export function registerGameCommands(pi: ExtensionAPI, runtime: MegaRuntime): void {
+  const description =
+    "Game mode toggle + theme picker + TUI display mode. Usage: /mega-compact-settings [on|off|theme [id|next]|tui [full|minimal]|achievements]";
+  const handler = (args: string, ctx: ExtensionContext) => handleSettings(args, ctx, runtime);
+
+  // Primary command (renamed in v0.8.x from /mega-game).
+  pi.registerCommand("mega-compact-settings", { description, handler });
+  // Backward-compat alias: /mega-game still resolves to the same settings UI.
+  pi.registerCommand("mega-game", {
+    description: "(alias for /mega-compact-settings) " + description,
+    handler,
+  });
+}

package/extensions/mega-runtime/state.test.ts

@@ -0,0 +1,171 @@
+/**
+ * state.test.ts — S31 MegaRuntime game-state cache round-trip.
+ *
+ * getCachedGameState() lazily reads the game_state row; bumpGameState()
+ * evicts so the next read re-queries. Uses MEGACOMPACT_STATE_DIR + mkdtemp
+ * (G7). A minimal MegaRuntime is constructed directly (no pi runtime).
+ */
+import { describe, it, after } from "node:test";
+import assert from "node:assert/strict";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { mkdtempSync, rmSync } from "node:fs";
+import { createRequire } from "node:module";
+import { execSync } from "node:child_process";
+import { closeStore, getGameState, setGameState } from "../../src/store/sqlite.js";
+import { DEFAULT_GAME_STATE } from "../../src/store/sqlite/game-state.js";
+
+const require = createRequire(import.meta.url);
+// Require the compiled JS (build output) so ESM import of pi-tui etc. resolves.
+const { MegaRuntime } = require("./state.js") as {
+	MegaRuntime: new (config: any) => any;
+};
+
+/** Minimal MegaConfig — enough fields for the constructor; the snapshot path
+ *  isn't exercised here, only getCachedGameState/bumpGameState. */
+function minimalConfig(stateDir: string): any {
+	return {
+		tier: "custom",
+		tierPct: null,
+		thresholdTokens: 100_000,
+		stateDir,
+		fastGatePct: 70,
+		anchorUserMessages: 3,
+		preserveRecent: 4,
+		preserveRecentMin: 2,
+		auto: false,
+		autoInline: false,
+		autoContinueLengthStop: false,
+		autoPctTrigger: null,
+		dedupSim: 0.9,
+		raptorEnabled: false,
+		legacyDurableTrim: false,
+		dbMirror: false,
+		crossRepoEnabled: false,
+		crossRepoCosine: 0.9,
+		memoryAutoReview: false,
+		memoryReviewInterval: 10,
+		recallMaxTokens: 1500,
+		windowDedupe: false,
+		debug: false,
+	};
+}
+
+/** Fresh isolated state dir per test — the game_state row is global and
+ *  persists across cases in a shared dir, so each case gets its own mkdtemp to
+ *  avoid cross-test contamination. */
+function freshDir(): string {
+	return mkdtempSync(join(tmpdir(), "mc-state-"));
+}
+
+describe("MegaRuntime game-state cache (S31)", () => {
+	const dirs: string[] = [];
+	after(() => {
+		for (const d of dirs) {
+			try { closeStore(d); } catch { /* */ }
+		}
+		delete process.env.MEGACOMPACT_STATE_DIR;
+		for (const d of dirs) rmSync(d, { recursive: true, force: true });
+	});
+
+	it("getCachedGameState returns defaults on a fresh install", () => {
+		const dir = freshDir(); dirs.push(dir);
+		process.env.MEGACOMPACT_STATE_DIR = dir;
+		const rt = new MegaRuntime(minimalConfig(dir));
+		const gs = rt.getCachedGameState();
+		assert.deepEqual(gs, { ...DEFAULT_GAME_STATE });
+	});
+
+	it("getCachedGameState memoizes (same ref across calls)", () => {
+		const dir = freshDir(); dirs.push(dir);
+		process.env.MEGACOMPACT_STATE_DIR = dir;
+		const rt = new MegaRuntime(minimalConfig(dir));
+		const a = rt.getCachedGameState();
+		const b = rt.getCachedGameState();
+		assert.equal(a, b, "memoized — same object ref");
+	});
+
+	it("bumpGameState evicts so the next read reflects a setGameState write", () => {
+		const dir = freshDir(); dirs.push(dir);
+		process.env.MEGACOMPACT_STATE_DIR = dir;
+		const rt = new MegaRuntime(minimalConfig(dir));
+		const before = rt.getCachedGameState();
+		assert.equal(before.game_mode_on, false);
+
+		// Write out-of-band (as /mega-game would).
+		setGameState({ game_mode_on: true, theme: "retro", tui_display_mode: "minimal" }, dir);
+
+		// Without bump, the stale memo is returned.
+		const stale = rt.getCachedGameState();
+		assert.equal(stale.game_mode_on, false, "stale cache before bump");
+
+		// After bump, the next read re-queries and reflects the write.
+		rt.bumpGameState();
+		const fresh = rt.getCachedGameState();
+		assert.equal(fresh.game_mode_on, true);
+		assert.equal(fresh.theme, "retro");
+		assert.equal(fresh.tui_display_mode, "minimal");
+		// And matches the authoritative getGameState read.
+		assert.deepEqual(fresh, getGameState(dir));
+	});
+
+	it("bumpGameState is idempotent (safe to call when cache is empty)", () => {
+		const dir = freshDir(); dirs.push(dir);
+		process.env.MEGACOMPACT_STATE_DIR = dir;
+		const rt = new MegaRuntime(minimalConfig(dir));
+		rt.bumpGameState(); // no cached state yet — must not throw
+		const gs = rt.getCachedGameState();
+		assert.deepEqual(gs, { ...DEFAULT_GAME_STATE });
+	});
+
+	it("bindRepo evicts cachedGameState so a repo switch reflects the new repo's game_state", () => {
+		// Two fresh git repos A and B simulate a real repo switch. Each holds its
+		// own per-repo state dir at <root>/.pi/mega-compact (what repoStateDir
+		// returns for a git cwd), and each holds its own game_state row, so a repo
+		// switch (bindRepo) must evict the cached memo or the widget shows A's
+		// theme/mode/toggle after moving to B. Uses MEGACOMPACT_STATE_DIR + mkdtemp
+		// + closeStore (G7); the global state dir stays separate.
+		const globalDir = freshDir(); dirs.push(globalDir);
+		const repoA = freshDir(); dirs.push(repoA);
+		const repoB = freshDir(); dirs.push(repoB);
+		const stateA = join(repoA, ".pi", "mega-compact");
+		const stateB = join(repoB, ".pi", "mega-compact");
+
+		// Make A and B real git roots so resolveRepoRoot(cwd) returns the root and
+		// repoStateDir produces <root>/.pi/mega-compact (the per-repo store).
+		execSync("git init -q", { cwd: repoA });
+		execSync("git init -q", { cwd: repoB });
+
+		// Seed A and B with distinct game_state rows in their per-repo dirs.
+		setGameState({ game_mode_on: true, theme: "retro", tui_display_mode: "minimal" }, stateA);
+		setGameState({ game_mode_on: false, theme: "cyan-neon", tui_display_mode: "full" }, stateB);
+
+		// Construct the runtime against the GLOBAL dir (the non-git fallback so a
+		// real bindRepo switch occurs once we point it at a git root).
+		process.env.MEGACOMPACT_STATE_DIR = globalDir;
+		const rt = new MegaRuntime(minimalConfig(globalDir));
+
+		// Point the runtime at repo A and prime the cache.
+		rt.bindRepo(repoA);
+		assert.equal(rt.currentStateDir, stateA, "bindRepo(A) switched to A's per-repo dir");
+		const a = rt.getCachedGameState();
+		assert.equal(a.game_mode_on, true, "A: game_mode_on primed");
+		assert.equal(a.theme, "retro", "A: theme primed");
+		assert.equal(a.tui_display_mode, "minimal", "A: tui_display_mode primed");
+
+		// Switch to repo B: bindRepo must evict cachedGameState so the next read
+		// re-queries B's row instead of returning A's stale memo.
+		rt.bindRepo(repoB);
+		assert.equal(rt.currentStateDir, stateB, "bindRepo(B) switched to B's per-repo dir");
+		const b = rt.getCachedGameState();
+		assert.equal(b.game_mode_on, false, "B: game_mode_on after switch (not A's stale true)");
+		assert.equal(b.theme, "cyan-neon", "B: theme after switch (not A's stale retro)");
+		assert.equal(b.tui_display_mode, "full", "B: tui_display_mode after switch (not A's stale minimal)");
+		assert.deepEqual(b, getGameState(stateB), "B matches authoritative getGameState read");
+
+		// Cleanup the per-repo DB handles.
+		try { closeStore(globalDir); } catch { /* */ }
+		try { closeStore(stateA); } catch { /* */ }
+		try { closeStore(stateB); } catch { /* */ }
+	});
+});