pi-mega-compact 0.7.8 → 0.8.0

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

@@ -0,0 +1,41 @@
+/**
+ * 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");
+    });
+});

package/dist/extensions/dashboard-server/index-reader.js

@@ -0,0 +1,133 @@
+/**
+ * dashboard-server/index-reader.ts — machine-wide repo registry reader.
+ *
+ * The extension writes a machine-wide repo registry into a single SQLite DB
+ * (<indexDir>/index.sqlite) as the concurrency-safe write path; the dashboard
+ * reads that table directly (one read-only connection, opened per request so a
+ * concurrent writer's WAL never blocks the request). All registry data lives in
+ * SQLite (the project's one-store invariant) — there is no JSON mirror. Same
+ * index-dir resolution as src/store/sqlite.ts getIndexDir().
+ */
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+export function getIndexDir() {
+    const override = process.env.MEGACOMPACT_INDEX_DIR;
+    if (override && override.trim() !== "")
+        return override;
+    try {
+        return join(homedir(), ".mega-compact-index");
+    }
+    catch {
+        return join("/tmp", ".mega-compact-index");
+    }
+}
+/** Read the machine-wide repo registry from SQLite (read-only, single shot). */
+export function readIndex() {
+    const indexPath = join(getIndexDir(), "index.sqlite");
+    if (!existsSync(indexPath))
+        return null;
+    let db;
+    try {
+        // Read-only + immutable WAL so a concurrent writer's WAL never blocks us.
+        db = new DatabaseSync(indexPath, { readOnly: true });
+        db.exec("PRAGMA journal_mode = WAL");
+        const rows = db
+            .prepare("SELECT * FROM repo_registry ORDER BY last_seen DESC")
+            .all();
+        const mapped = rows.map((r) => ({
+            repoRoot: String(r.repo_root ?? ""),
+            displayName: String(r.display_name ?? ""),
+            stateDir: String(r.state_dir ?? ""),
+            checkpointCount: Number(r.checkpoint_count ?? 0),
+            tokensSaved: Number(r.tokens_saved ?? 0),
+            compressedOriginalBytes: Number(r.compressed_original_bytes ?? 0),
+            lastCompactedAt: r.last_compacted_at ?? null,
+            provider: r.provider ?? null,
+            providerName: r.provider_name ?? null,
+            modelName: r.model_name ?? null,
+            inputRate: r.input_rate ?? null,
+            outputRate: r.output_rate ?? null,
+            lastSeen: Number(r.last_seen ?? 0),
+            // Defaults — enriched below from each repo's own store.
+            tokensKept: 0,
+            tokensDropped: 0,
+            sessions: 0,
+            contextWindow: null,
+            maxTokens: null,
+            reasoning: null,
+        }));
+        // Enrich each repo with per-store token + model detail read directly via
+        // node:sqlite (same zero-dependency invariant as readIndex; no store graph
+        // import). Best-effort: a missing/corrupt store degrades to the defaults
+        // above so the dashboard never fails to render.
+        for (const repo of mapped) {
+            try {
+                const storePath = join(repo.stateDir, "sqlite.db");
+                if (existsSync(storePath)) {
+                    const sdb = new DatabaseSync(storePath, { readOnly: true });
+                    try {
+                        const tok = sdb
+                            .prepare(`SELECT COALESCE(SUM(token_estimate),0) AS kept,
+                        COALESCE(SUM(original_token_estimate),0) AS dropped,
+                        COUNT(DISTINCT session_id) AS sess
+                 FROM context_chunks WHERE dedup_status != 'removed'`)
+                            .get();
+                        repo.tokensKept = Number(tok.kept ?? 0);
+                        repo.tokensDropped = Number(tok.dropped ?? 0);
+                        repo.sessions = Number(tok.sess ?? 0);
+                        const mrow = sdb
+                            .prepare(`SELECT context_window, max_tokens, reasoning
+                 FROM model_snapshots ORDER BY captured_at DESC LIMIT 1`)
+                            .get();
+                        if (mrow) {
+                            repo.contextWindow = Number(mrow.context_window ?? 0) || null;
+                            repo.maxTokens = Number(mrow.max_tokens ?? 0) || null;
+                            repo.reasoning = Number(mrow.reasoning ?? 0) === 1;
+                        }
+                    }
+                    finally {
+                        sdb.close();
+                    }
+                }
+            }
+            catch {
+                /* best-effort — keep the defaults */
+            }
+        }
+        // Defensive display hygiene (belt-and-suspenders — the real fix is that
+        // tests now isolate via MEGACOMPACT_INDEX_DIR): drop transient test/temp
+        // paths that should never have been real repos, and collapse duplicate
+        // display names to the most-recently-seen row (rows are last_seen DESC, so
+        // the first occurrence wins). Keeps the All-repos list readable.
+        const isTransient = (p) => /^\/tmp\//.test(p) || /^\/private\/tmp\//.test(p) || /^\/var\/folders\//.test(p) ||
+            /\/mc-(ext|e2e|resume|recall)-/.test(p);
+        const seenName = new Set();
+        const repos = [];
+        for (const r of mapped) {
+            if (isTransient(r.repoRoot))
+                continue;
+            if (seenName.has(r.displayName))
+                continue;
+            seenName.add(r.displayName);
+            repos.push(r);
+        }
+        const summary = {
+            totalRepos: repos.length,
+            totalCheckpoints: repos.reduce((a, r) => a + r.checkpointCount, 0),
+            totalTokensSaved: repos.reduce((a, r) => a + r.tokensSaved, 0),
+            totalCompressedOriginalBytes: repos.reduce((a, r) => a + r.compressedOriginalBytes, 0),
+        };
+        return { updatedAt: new Date().toISOString(), summary, repos };
+    }
+    catch {
+        return null;
+    }
+    finally {
+        try {
+            db?.close();
+        }
+        catch { /* ignore */ }
+    }
+}