pi-mega-compact 0.7.8 → 0.8.0

package/extensions/dashboard-server/index-reader.ts

@@ -0,0 +1,130 @@
+/**
+ * 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";
+import type { IndexRepo, IndexIndex } from "./types.js";
+
+export function getIndexDir(): string {
+  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(): IndexIndex | null {
+  const indexPath = join(getIndexDir(), "index.sqlite");
+  if (!existsSync(indexPath)) return null;
+  let db: DatabaseSync | undefined;
+  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() as Record<string, unknown>[];
+    const mapped: IndexRepo[] = 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 as number | null) ?? null,
+      provider: (r.provider as string | null) ?? null,
+      providerName: (r.provider_name as string | null) ?? null,
+      modelName: (r.model_name as string | null) ?? null,
+      inputRate: (r.input_rate as number | null) ?? null,
+      outputRate: (r.output_rate as number | null) ?? 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() as { kept: number; dropped: number; sess: number };
+            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() as { context_window: number; max_tokens: number; reasoning: number } | undefined;
+            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: string) =>
+      /^\/tmp\//.test(p) || /^\/private\/tmp\//.test(p) || /^\/var\/folders\//.test(p) ||
+      /\/mc-(ext|e2e|resume|recall)-/.test(p);
+    const seenName = new Set<string>();
+    const repos: IndexRepo[] = [];
+    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 */ }
+  }
+}

package/extensions/dashboard-server/server.test.ts

@@ -0,0 +1,131 @@
+/**
+ * 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: () => boolean | Promise<boolean>, timeoutMs = 6000): Promise<void> {
+  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: string): string {
+  return mkdtempSync(join(tmpdir(), prefix));
+}
+
+async function withServer<T>(
+  port: string,
+  dir: string,
+  fn: (port: number) => Promise<T>,
+): Promise<T> {
+  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()) as Array<{ repo_root: string; value: number; ts: number }>;
+      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())) as unknown[];
+      assert.equal(all.length, 3);
+      const capped = (await fetch(`http://localhost:${port}/api/game-scores?metric=cache&limit=2`).then((r) => r.json())) as unknown[];
+      assert.equal(capped.length, 2);
+      const zero = (await fetch(`http://localhost:${port}/api/game-scores?metric=cache&limit=0`).then((r) => r.json())) as unknown[];
+      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()) as Array<{ id: string; title: string; hidden: number; unlocked_at: number | null }>;
+      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);
+    });
+  });
+});