pi-mega-compact 0.11.4 → 0.11.5

package/dist/extensions/dashboard-server/html.test.js

@@ -1,52 +0,0 @@
-/**
- * html.test.ts — S34 Game Mode tab presence in the dashboard HTML template.
- */
-import { test, describe } from "node:test";
-import assert from "node:assert/strict";
-import { dashboardHtml } from "./html.js";
-describe("S34 dashboard HTML Game Mode", () => {
-    const html = dashboardHtml("custom");
-    test("Game Mode tab button + panel-game exist", () => {
-        assert.ok(html.includes('<button class="tab" data-tab="game">Game Mode</button>'), "game tab button present");
-        assert.ok(html.includes('<div class="tab-panel" id="panel-game">'), "panel-game present");
-    });
-    test("level-up-pulse + mega-flash keyframes present", () => {
-        assert.ok(html.includes("@keyframes level-up-pulse"), "level-up-pulse keyframe present");
-        assert.ok(html.includes("@keyframes mega-flash"), "mega-flash keyframe present");
-    });
-    test("empty-state string present", () => {
-        assert.ok(html.includes("No scores yet — run a session with game mode on."), "empty-state string present");
-    });
-});
-describe("S35 dashboard HTML achievements", () => {
-    const html = dashboardHtml("custom");
-    test("Achievements heading + ach-tiles/ach-toast containers present", () => {
-        assert.ok(html.includes(">Achievements</h3>"), "Achievements heading present");
-        assert.ok(html.includes('id="ach-tiles"'), "ach-tiles container present");
-        assert.ok(html.includes('id="ach-toast"'), "ach-toast element present");
-    });
-    test("ach-unlock-pulse keyframe + ach-tile classes present", () => {
-        assert.ok(html.includes("@keyframes ach-unlock-pulse"), "ach-unlock-pulse keyframe present");
-        assert.ok(html.includes(".ach-tile"), "ach-tile class present");
-        assert.ok(html.includes(".ach-tile.unlocked"), "unlocked class present");
-        assert.ok(html.includes(".ach-tile.locked"), "locked class present");
-    });
-    test("renderAchievements fn + GET /api/achievements fetch present", () => {
-        assert.ok(html.includes("function renderAchievements"), "renderAchievements fn present");
-        assert.ok(html.includes("fetch('/api/achievements')"), "achievements fetch present");
-    });
-    test("visible-but-locked teaser string present", () => {
-        assert.ok(html.includes("??? "), "??? teaser present");
-    });
-});
-describe("S35 dashboard HTML achievements escaping (v0.8.4 fix)", () => {
-    const html = dashboardHtml("custom");
-    test("Opie's Wild Ride JS string is backslash-escaped (no bare apostrophe)", () => {
-        // The served <script> uses single-quoted JS strings: '🏆 Opie\'s Wild Ride...'.
-        // A bare apostrophe (Opie's) would terminate the string and halt the script,
-        // breaking .tab click bindings. The served HTML MUST contain the escaped
-        // form Opie\'s and MUST NOT contain the bare form '🏆 Opie's'.
-        assert.ok(html.includes("🏆 Opie\\'s Wild Ride"), "served JS contains Opie\\'s (escaped)");
-        assert.ok(!html.includes("🏆 Opie's Wild Ride"), "no bare Opie's in served JS");
-    });
-});

package/dist/extensions/dashboard-server/perf-server.test.js

@@ -1,80 +0,0 @@
-/**
- * perf-server.test.ts — v0.8.8 /api/perf endpoint (GET aggregates + 405).
- * Mirrors the server.test.ts spawn-and-fetch harness (self-contained so the
- * dashboard HTTP-port lane stays isolated).
- */
-import { test, describe } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, readFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { spawn } from "node:child_process";
-import { recordPerfSample } from "../../src/store/sqlite.js";
-const SERVER_ENTRY = new URL("./server.js", import.meta.url).pathname;
-function waitFor(cond, timeoutMs = 6000) {
-    const start = Date.now();
-    return new Promise((resolve, reject) => {
-        const tick = async () => {
-            if (await cond())
-                return resolve();
-            if (Date.now() - start > timeoutMs)
-                return reject(new Error("timeout"));
-            setTimeout(tick, 50);
-        };
-        tick();
-    });
-}
-function freshDir(prefix) {
-    return mkdtempSync(join(tmpdir(), prefix));
-}
-async function withServer(port, dir, fn) {
-    process.env.MEGACOMPACT_DASHBOARD_PORT = port;
-    const child = spawn(process.execPath, [SERVER_ENTRY, dir], { stdio: "ignore" });
-    try {
-        await waitFor(async () => {
-            try {
-                const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
-                const res = await fetch(`http://localhost:${raw.port}/api/version`);
-                return res.ok;
-            }
-            catch {
-                return false;
-            }
-        });
-        const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
-        return await fn(raw.port);
-    }
-    finally {
-        child.kill("SIGTERM");
-        delete process.env.MEGACOMPACT_DASHBOARD_PORT;
-        rmSync(dir, { recursive: true, force: true });
-    }
-}
-describe("v0.8.8 /api/perf", () => {
-    test("GET returns aggregates over recorded perf_samples", async () => {
-        const dir = freshDir("dash-perf-agg-");
-        recordPerfSample(dir, "turn_latency_ms", 100, { turnIndex: 1 });
-        recordPerfSample(dir, "turn_latency_ms", 200);
-        recordPerfSample(dir, "tps", 50);
-        recordPerfSample(dir, "rss_mb", 256);
-        await withServer("19440", dir, async (port) => {
-            const res = await fetch(`http://localhost:${port}/api/perf?minutes=30`);
-            assert.equal(res.status, 200);
-            const d = (await res.json());
-            assert.equal(d.sampleCount, 4);
-            assert.equal(d.turn_latency_ms.n, 2);
-            assert.equal(d.turn_latency_ms.p50, 100); // nearest-rank p50 of [100,200]
-            assert.equal(d.turn_latency_ms.p95, 200); // nearest-rank p95 of [100,200]
-            assert.equal(d.tps.avg, 50);
-            assert.equal(d.rss_mb.latest, 256);
-            assert.equal(d.diag, null); // no runtime wrote dashboard.json in this dir
-        });
-    });
-    test("non-GET (POST) -> 405", async () => {
-        const dir = freshDir("dash-perf-meth-");
-        await withServer("19441", dir, async (port) => {
-            const res = await fetch(`http://localhost:${port}/api/perf`, { method: "POST" });
-            assert.equal(res.status, 405);
-        });
-    });
-});

package/dist/extensions/dashboard-server/routes-cache.test.js

@@ -1,248 +0,0 @@
-/**
- * routes-cache.test.ts — Sprint A /api/provider-cache endpoint tests.
- *
- * Covers the A.4 spec:
- * - GET 200 → shape matches ProviderCacheResponse
- * - POST → 405
- * - empty perf_samples → zeros/nulls
- * - no model snapshot → savings: null
- * - with model snapshot → priced savings fields
- *
- * Uses the same spawn-and-fetch harness as perf-server.test.ts.
- */
-import { test, describe } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, readFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { spawn } from "node:child_process";
-import { recordPerfSample, recordModelSnapshot, } from "../../src/store/sqlite.js";
-const SERVER_ENTRY = new URL("./server.js", import.meta.url).pathname;
-function waitFor(cond, timeoutMs = 6000) {
-    const start = Date.now();
-    return new Promise((resolve, reject) => {
-        const tick = async () => {
-            if (await cond())
-                return resolve();
-            if (Date.now() - start > timeoutMs)
-                return reject(new Error("timeout"));
-            setTimeout(tick, 50);
-        };
-        tick();
-    });
-}
-function freshDir(prefix) {
-    return mkdtempSync(join(tmpdir(), prefix));
-}
-async function withServer(port, dir, fn) {
-    process.env.MEGACOMPACT_DASHBOARD_PORT = port;
-    const child = spawn(process.execPath, [SERVER_ENTRY, dir], {
-        stdio: "ignore",
-    });
-    try {
-        await waitFor(async () => {
-            try {
-                const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
-                const res = await fetch(`http://localhost:${raw.port}/api/version`);
-                return res.ok;
-            }
-            catch {
-                return false;
-            }
-        });
-        const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
-        return await fn(raw.port);
-    }
-    finally {
-        child.kill("SIGTERM");
-        delete process.env.MEGACOMPACT_DASHBOARD_PORT;
-        rmSync(dir, { recursive: true, force: true });
-    }
-}
-describe("/api/provider-cache", () => {
-    test("GET 200 — shape matches ProviderCacheResponse", async () => {
-        const dir = freshDir("dash-pcache-agg-");
-        // Seed one cache_hit_pct sample with full meta.
-        recordPerfSample(dir, "cache_hit_pct", 42, {
-            cacheRead: 100,
-            cacheWrite: 20,
-            input: 500,
-        });
-        await withServer("19450", dir, async (port) => {
-            const res = await fetch(`http://localhost:${port}/api/provider-cache`);
-            assert.equal(res.status, 200);
-            const body = (await res.json());
-            // Shape assertions
-            assert.ok("cache" in body, "should have cache");
-            assert.ok("savings" in body, "should have savings");
-            assert.ok("updatedAt" in body, "should have updatedAt");
-            assert.equal(body.cache.turnCount, 1);
-            assert.equal(body.cache.totalCacheRead, 100);
-            assert.equal(body.cache.totalCacheWrite, 20);
-            assert.equal(body.cache.totalInput, 500);
-            assert.ok(typeof body.cache.firstTurnAt === "string");
-            assert.ok(typeof body.cache.latestTurnAt === "string");
-            assert.ok(typeof body.updatedAt === "string");
-        });
-    });
-    test("GET 200 — empty perf_samples returns zeros/nulls", async () => {
-        const dir = freshDir("dash-pcache-empty-");
-        await withServer("19451", dir, async (port) => {
-            const res = await fetch(`http://localhost:${port}/api/provider-cache`);
-            assert.equal(res.status, 200);
-            const body = (await res.json());
-            assert.equal(body.cache.turnCount, 0);
-            assert.equal(body.cache.avgHitPct, 0);
-            assert.equal(body.cache.totalCacheRead, 0);
-            assert.equal(body.cache.totalCacheWrite, 0);
-            assert.equal(body.cache.totalInput, 0);
-            assert.equal(body.cache.firstTurnAt, null);
-            assert.equal(body.cache.latestTurnAt, null);
-            assert.equal(body.savings, null);
-        });
-    });
-    test("POST → 405", async () => {
-        const dir = freshDir("dash-pcache-meth-");
-        await withServer("19452", dir, async (port) => {
-            const res = await fetch(`http://localhost:${port}/api/provider-cache`, {
-                method: "POST",
-            });
-            assert.equal(res.status, 405);
-            const body = (await res.json());
-            assert.equal(body.error, "method_not_allowed");
-        });
-    });
-    test("no model snapshot → savings: null", async () => {
-        const dir = freshDir("dash-pcache-nosnap-");
-        recordPerfSample(dir, "cache_hit_pct", 50, {
-            cacheRead: 200,
-            cacheWrite: 30,
-            input: 1000,
-        });
-        await withServer("19453", dir, async (port) => {
-            const res = await fetch(`http://localhost:${port}/api/provider-cache`);
-            assert.equal(res.status, 200);
-            const body = (await res.json());
-            assert.equal(body.savings, null);
-        });
-    });
-    test("with model snapshot → priced savings fields", async () => {
-        const dir = freshDir("dash-pcache-savings-");
-        recordPerfSample(dir, "cache_hit_pct", 50, {
-            cacheRead: 2000,
-            cacheWrite: 400,
-            input: 10000,
-        });
-        // Record a model snapshot with a known input rate.
-        recordModelSnapshot("/tmp/test-repo", {
-            provider: "anthropic",
-            providerName: "Anthropic",
-            modelId: "claude-sonnet-4-20250514",
-            modelName: "Claude Sonnet 4",
-            inputRate: 3e-6, // $3 / 1M tokens
-            outputRate: 15e-6,
-            contextWindow: 200000,
-            maxTokens: 32000,
-            reasoning: false,
-        }, dir);
-        await withServer("19454", dir, async (port) => {
-            const res = await fetch(`http://localhost:${port}/api/provider-cache`);
-            assert.equal(res.status, 200);
-            const body = (await res.json());
-            assert.ok(body.savings, "savings should not be null");
-            // cacheReadSaved = 2000 * 3e-6 * 0.9 = 0.0054
-            assert.ok(body.savings.cacheReadSaved > 0, "cacheReadSaved > 0");
-            // cacheWriteCost = 400 * 3e-6 * 0.25 = 0.0003
-            assert.ok(body.savings.cacheWriteCost > 0, "cacheWriteCost > 0");
-            assert.ok(body.savings.netSaved ===
-                body.savings.cacheReadSaved - body.savings.cacheWriteCost, "netSaved = cacheReadSaved - cacheWriteCost");
-            assert.equal(body.savings.model, "Claude Sonnet 4");
-            assert.equal(body.savings.inputRate, 3e-6);
-        });
-    });
-    test("partial meta (missing fields) → treated as 0", async () => {
-        const dir = freshDir("dash-pcache-partial-");
-        // Only input in meta; cacheRead/cacheWrite missing → treated as 0.
-        recordPerfSample(dir, "cache_hit_pct", 30, { input: 800 });
-        // Only cacheRead in meta; input/cacheWrite missing → treated as 0.
-        recordPerfSample(dir, "cache_hit_pct", 60, { cacheRead: 150 });
-        await withServer("19455", dir, async (port) => {
-            const res = await fetch(`http://localhost:${port}/api/provider-cache`);
-            assert.equal(res.status, 200);
-            const body = (await res.json());
-            // First sample: input=800, cacheRead=0, cacheWrite=0
-            // Second sample: cacheRead=150, input=0, cacheWrite=0
-            assert.equal(body.cache.turnCount, 2);
-            assert.equal(body.cache.totalCacheRead, 150);
-            assert.equal(body.cache.totalCacheWrite, 0);
-            assert.equal(body.cache.totalInput, 800);
-        });
-    });
-    test("NULL meta → counted in turnCount, contributes 0 tokens + 0 avg", async () => {
-        const dir = freshDir("dash-pcache-nullmeta-");
-        // avgHitPct is derived from (cacheRead / (cacheRead + input + cacheWrite)) * 100,
-        // NOT from the `value` column. NULL meta → no tokens → avg 0, not 25.
-        recordPerfSample(dir, "cache_hit_pct", 25, undefined);
-        await withServer("19456", dir, async (port) => {
-            const res = await fetch(`http://localhost:${port}/api/provider-cache`);
-            assert.equal(res.status, 200);
-            const body = (await res.json());
-            assert.equal(body.cache.turnCount, 1);
-            assert.equal(body.cache.avgHitPct, 0);
-            assert.equal(body.cache.totalCacheRead, 0);
-            assert.equal(body.cache.totalCacheWrite, 0);
-            assert.equal(body.cache.totalInput, 0);
-        });
-    });
-    test("model snapshot with modelName=null → falls back to modelId", async () => {
-        const dir = freshDir("dash-pcache-modelid-");
-        recordPerfSample(dir, "cache_hit_pct", 10, {
-            cacheRead: 100,
-            cacheWrite: 10,
-            input: 1000,
-        });
-        recordModelSnapshot("/tmp/test-repo", {
-            provider: "openai",
-            providerName: null,
-            modelId: "gpt-4o",
-            modelName: null,
-            inputRate: 2.5e-6,
-            outputRate: 10e-6,
-            contextWindow: 128000,
-            maxTokens: 16384,
-            reasoning: false,
-        }, dir);
-        await withServer("19457", dir, async (port) => {
-            const res = await fetch(`http://localhost:${port}/api/provider-cache`);
-            assert.equal(res.status, 200);
-            const body = (await res.json());
-            assert.ok(body.savings);
-            assert.equal(body.savings.model, "gpt-4o");
-        });
-    });
-    test("model snapshot with zero inputRate → savings: null", async () => {
-        const dir = freshDir("dash-pcache-zerorate-");
-        recordPerfSample(dir, "cache_hit_pct", 10, {
-            cacheRead: 100,
-            cacheWrite: 10,
-            input: 1000,
-        });
-        recordModelSnapshot("/tmp/test-repo", {
-            provider: "local",
-            providerName: null,
-            modelId: "local-llm",
-            modelName: null,
-            inputRate: 0,
-            outputRate: 0,
-            contextWindow: 4096,
-            maxTokens: 2048,
-            reasoning: false,
-        }, dir);
-        await withServer("19458", dir, async (port) => {
-            const res = await fetch(`http://localhost:${port}/api/provider-cache`);
-            assert.equal(res.status, 200);
-            const body = (await res.json());
-            assert.equal(body.savings, null);
-        });
-    });
-});

package/dist/extensions/dashboard-server/server.test.js

@@ -1,120 +0,0 @@
-/**
- * server.test.ts — S34 /api/game-scores endpoint (GET leaderboard, metric
- * validation, method + limit handling). Mirrors the S32 /api/game-state
- * spawn-and-fetch harness.
- */
-import { test, describe } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, readFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { spawn } from "node:child_process";
-import { recordScore } from "../../src/store/sqlite.js";
-const SERVER_ENTRY = new URL("./server.js", import.meta.url).pathname;
-function waitFor(cond, timeoutMs = 6000) {
-    const start = Date.now();
-    return new Promise((resolve, reject) => {
-        const tick = async () => {
-            if (await cond())
-                return resolve();
-            if (Date.now() - start > timeoutMs)
-                return reject(new Error("timeout"));
-            setTimeout(tick, 50);
-        };
-        tick();
-    });
-}
-function freshDir(prefix) {
-    return mkdtempSync(join(tmpdir(), prefix));
-}
-async function withServer(port, dir, fn) {
-    process.env.MEGACOMPACT_DASHBOARD_PORT = port;
-    const child = spawn(process.execPath, [SERVER_ENTRY, dir], { stdio: "ignore" });
-    try {
-        await waitFor(async () => {
-            try {
-                const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
-                const res = await fetch(`http://localhost:${raw.port}/api/version`);
-                return res.ok;
-            }
-            catch {
-                return false;
-            }
-        });
-        const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
-        return await fn(raw.port);
-    }
-    finally {
-        child.kill("SIGTERM");
-        delete process.env.MEGACOMPACT_DASHBOARD_PORT;
-        rmSync(dir, { recursive: true, force: true });
-    }
-}
-describe("S34 /api/game-scores", () => {
-    test("GET ?metric=cache returns recorded rows as JSON array", async () => {
-        const dir = freshDir("dash-gs-cache-");
-        recordScore(dir, { repo_root: "/repo/a", metric: "cache", value: 42 });
-        await withServer("19430", dir, async (port) => {
-            const res = await fetch(`http://localhost:${port}/api/game-scores?metric=cache`);
-            assert.equal(res.status, 200);
-            const rows = (await res.json());
-            assert.ok(Array.isArray(rows));
-            assert.equal(rows.length, 1);
-            assert.equal(rows[0].repo_root, "/repo/a");
-            assert.equal(rows[0].value, 42);
-            assert.ok(typeof rows[0].ts === "number");
-        });
-    });
-    test("unknown metric -> 400", async () => {
-        const dir = freshDir("dash-gs-bad-");
-        await withServer("19431", dir, async (port) => {
-            const res = await fetch(`http://localhost:${port}/api/game-scores?metric=bogus`);
-            assert.equal(res.status, 400);
-        });
-    });
-    test("non-GET (POST) -> 405", async () => {
-        const dir = freshDir("dash-gs-meth-");
-        await withServer("19432", dir, async (port) => {
-            const res = await fetch(`http://localhost:${port}/api/game-scores`, { method: "POST" });
-            assert.equal(res.status, 405);
-        });
-    });
-    test("limit clamp: 3 rows -> default 10 returns 3, limit=2 caps to 2, limit<=0 clamps to >=1", async () => {
-        const dir = freshDir("dash-gs-lim-");
-        recordScore(dir, { repo_root: "/repo/a", metric: "cache", value: 1 });
-        recordScore(dir, { repo_root: "/repo/b", metric: "cache", value: 2 });
-        recordScore(dir, { repo_root: "/repo/c", metric: "cache", value: 3 });
-        await withServer("19433", dir, async (port) => {
-            const all = (await fetch(`http://localhost:${port}/api/game-scores?metric=cache`).then((r) => r.json()));
-            assert.equal(all.length, 3);
-            const capped = (await fetch(`http://localhost:${port}/api/game-scores?metric=cache&limit=2`).then((r) => r.json()));
-            assert.equal(capped.length, 2);
-            const zero = (await fetch(`http://localhost:${port}/api/game-scores?metric=cache&limit=0`).then((r) => r.json()));
-            assert.ok(zero.length >= 1, "limit<=0 clamps to >=1 row");
-        });
-    });
-});
-describe("S35 /api/achievements", () => {
-    test("GET returns the 9 seeded achievement rows", async () => {
-        const dir = freshDir("dash-ach-");
-        await withServer("19434", dir, async (port) => {
-            const res = await fetch(`http://localhost:${port}/api/achievements`);
-            assert.equal(res.status, 200);
-            const rows = (await res.json());
-            assert.ok(Array.isArray(rows));
-            assert.equal(rows.length, 9);
-            const opie = rows.find((r) => r.id === "opie_wild_ride");
-            assert.ok(opie, "opie_wild_ride seeded");
-            assert.equal(opie.hidden, 1);
-            assert.equal(opie.unlocked_at, null);
-            assert.equal(rows.find((r) => r.id === "first_compact").title, "First Compact");
-        });
-    });
-    test("non-GET (POST) -> 405", async () => {
-        const dir = freshDir("dash-ach-meth-");
-        await withServer("19435", dir, async (port) => {
-            const res = await fetch(`http://localhost:${port}/api/achievements`, { method: "POST" });
-            assert.equal(res.status, 405);
-        });
-    });
-});