pi-mega-compact 0.11.4 → 0.11.5

package/src/config/themes.test.ts

@@ -1,116 +0,0 @@
-/**
- * themes.test.ts — S30 theme palette source-of-truth tests.
- * Pi-agnostic: no pi runtime imports.
- */
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import {
-  THEMES,
-  THEME_IDS,
-  DEFAULT_THEME,
-  getTheme,
-  isValidTheme,
-  nextTheme,
-  themeCssVars,
-  themeDataBlock,
-} from "./themes.js";
-
-describe("themes (S30)", () => {
-  it("defines exactly 6 themes", () => {
-    assert.equal(THEMES.length, 6);
-    assert.equal(THEME_IDS.length, 6);
-  });
-
-  it("has unique ids", () => {
-    assert.equal(new Set(THEME_IDS).size, 6);
-  });
-
-  it("default theme is transparent", () => {
-    assert.equal(DEFAULT_THEME, "transparent");
-    assert.ok(isValidTheme(DEFAULT_THEME));
-  });
-
-  it("includes retro, orange-bold, cyan-neon, amber-mono, grayscale", () => {
-    for (const id of ["retro", "orange-bold", "cyan-neon", "amber-mono", "grayscale"]) {
-      assert.ok(isValidTheme(id), `missing ${id}`);
-    }
-  });
-
-  it("transparent theme has null bg (CSS + ANSI)", () => {
-    const t = getTheme("transparent");
-    assert.ok(t);
-    assert.equal(t!.css.bg, null);
-    assert.equal(t!.ansi.bg, null);
-  });
-
-  it("every non-transparent theme has a non-null bg", () => {
-    for (const t of THEMES) {
-      if (t.id === "transparent") continue;
-      assert.ok(t.css.bg, `${t.id} css.bg`);
-      assert.ok(t.ansi.bg, `${t.id} ansi.bg`);
-    }
-  });
-
-  it("every theme has css + ansi {fg,accent,mega} strings", () => {
-    for (const t of THEMES) {
-      assert.ok(typeof t.css.fg === "string" && t.css.fg.startsWith("#"));
-      assert.ok(typeof t.css.accent === "string");
-      assert.ok(typeof t.css.mega === "string");
-      assert.ok(typeof t.ansi.fg === "string");
-      assert.ok(typeof t.ansi.accent === "string");
-      assert.ok(typeof t.ansi.mega === "string");
-    }
-  });
-
-  it("getTheme returns undefined for unknown id", () => {
-    assert.equal(getTheme("nope"), undefined);
-  });
-
-  it("isValidTheme is false for unknown", () => {
-    assert.equal(isValidTheme("nope"), false);
-  });
-
-  it("nextTheme cycles through all themes and wraps", () => {
-    const seen: string[] = [];
-    let cur = DEFAULT_THEME;
-    for (let i = 0; i < THEME_IDS.length; i++) {
-      cur = nextTheme(cur);
-      seen.push(cur);
-    }
-    // after N steps we've visited every theme once
-    assert.equal(new Set(seen).size, THEME_IDS.length);
-    // wraps: one more step from the last returns to the first
-    const first = nextTheme(THEME_IDS[THEME_IDS.length - 1]!);
-    assert.equal(first, THEME_IDS[0]);
-  });
-
-  it("nextTheme falls back to DEFAULT_THEME for unknown current", () => {
-    assert.equal(nextTheme("garbage"), DEFAULT_THEME);
-  });
-});
-
-describe("themeCssVars / themeDataBlock (S32)", () => {
-  it("themeCssVars emits --bg/--fg/--accent/--mega for a normal theme", () => {
-    const t = getTheme("retro")!;
-    const vars = themeCssVars(t);
-    assert.match(vars, /--bg: #003300;/);
-    assert.match(vars, /--fg: #33ff33;/);
-    assert.match(vars, /--accent: #00ff41;/);
-    assert.match(vars, /--mega: #39ff14;/);
-  });
-
-  it("themeCssVars maps null bg to 'transparent'", () => {
-    const t = getTheme("transparent")!;
-    const vars = themeCssVars(t);
-    assert.match(vars, /--bg: transparent;/);
-    assert.match(vars, /--fg: #c9d1d9;/);
-  });
-
-  it("themeDataBlock wraps vars in a :root[data-theme=\"<id\"] selector", () => {
-    const t = getTheme("cyan-neon")!;
-    const block = themeDataBlock(t);
-    assert.equal(block.startsWith(':root[data-theme="cyan-neon"]{ '), true);
-    assert.equal(block.endsWith(" }"), true);
-    assert.ok(block.includes("--accent: #22d3ee;"));
-  });
-});

package/src/dedup/dedup.test.ts

@@ -1,46 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { normalize, stripAnsi } from "./normalize.js";
-import { computeContentDigest, CONTENT_HASH_VERSION } from "./digest.js";
-
-test("normalize collapses whitespace/newline variants to one form (Sprint 9)", () => {
-  // Sprint 9 normalizes whitespace/newlines/ANSI (not case — that is Sprint 10).
-  const variants = [
-    "foo  bar",
-    "foo bar",
-    "foo\tbar",
-    "foo\nbar",
-    "  foo   bar  ",
-    "foo\r\nbar",
-  ];
-  const digests = variants.map((v) => computeContentDigest(v).contentHash);
-  const unique = new Set(digests);
-  assert.equal(unique.size, 1, "all whitespace/newline variants must collapse to one digest");
-});
-
-test("normalize is idempotent", () => {
-  const input = "  Hello   World  \n";
-  assert.equal(normalize(normalize(input)), normalize(input));
-});
-
-test("stripAnsi removes terminal color codes", () => {
-  const colored = "err\x1b[31m fatal\x1b[0m boom";
-  assert.equal(stripAnsi(colored), "err fatal boom");
-});
-
-test("computeContentDigest emits full 64-hex dual hashes + version", () => {
-  const d = computeContentDigest("the same region text");
-  assert.equal(d.contentHash.length, 64);
-  assert.equal(d.contentHash2.length, 64);
-  assert.equal(d.contentHashVersion, CONTENT_HASH_VERSION);
-  assert.equal(d.normalizedText, "the same region text");
-  // Secondary is an independent view (reversed) so it differs from primary.
-  assert.notEqual(d.contentHash, d.contentHash2);
-});
-
-test("dual-hash: distinct content yields a distinct pair (both must agree to dedup)", () => {
-  const a = computeContentDigest("region about authentication");
-  const b = computeContentDigest("region about authorization");
-  assert.notEqual(a.contentHash, b.contentHash);
-  assert.notEqual(a.contentHash2, b.contentHash2);
-});

package/src/dedup/l1.test.ts

@@ -1,57 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { minhashSignature, shingles, signatureSimilarity, NUM_HASHES } from "./l1-minhash.js";
-import { lshBands, BANDS, ROWS_PER_BAND } from "./l1-lsh.js";
-import { trigramSimilarity, isNearDuplicate, L1_VERIFY_THRESHOLD } from "./l1-verify.js";
-
-test("minhashSignature is deterministic across calls (same input → same sig)", () => {
-  const a = minhashSignature("the authentication module handles login securely");
-  const b = minhashSignature("the authentication module handles login securely");
-  assert.deepEqual(a, b);
-  assert.equal(a.length, NUM_HASHES);
-});
-
-test("minhashSignature of near-identical text is more similar than of unrelated text", () => {
-  const s1 = minhashSignature("user logged in and viewed the dashboard");
-  const s2 = minhashSignature("user logged in and viewed the dashboard page"); // one word added
-  const s3 = minhashSignature("the compiler optimized the hot loop aggressively");
-  assert.ok(signatureSimilarity(s1, s2) > signatureSimilarity(s1, s3));
-});
-
-test("lshBands produces BANDS keys and is stable per session", () => {
-  const sig = minhashSignature("some text to band");
-  const k1 = lshBands(sig, "sess_a", 1);
-  const k2 = lshBands(sig, "sess_a", 1);
-  assert.equal(k1.length, BANDS);
-  assert.equal(BANDS * ROWS_PER_BAND, NUM_HASHES);
-  assert.deepEqual(k1, k2);
-  // Different session → different bucket keys (scoped, deterministic).
-  const k3 = lshBands(sig, "sess_b", 1);
-  assert.notDeepEqual(k1, k3);
-});
-
-test("lshBands keys are stable across restarts (no entropy source)", () => {
-  // Recomputed in a fresh call path — determinism is structural, not time-based.
-  const sig = minhashSignature("deterministic bucket key check");
-  const first = lshBands(sig, "sess_x", 1);
-  const again = lshBands(sig, "sess_x", 1);
-  assert.deepEqual(first, again);
-});
-
-test("trigramSimilarity is 1 for identical, high for one-word-edit, low for unrelated", () => {
-  const a = "the quick brown fox jumps";
-  assert.equal(trigramSimilarity(a, a), 1);
-  assert.ok(trigramSimilarity(a, "the quick brown fox jumps over") >= L1_VERIFY_THRESHOLD);
-  assert.ok(trigramSimilarity(a, "a completely different sentence about databases") < 0.5);
-});
-
-test("isNearDuplicate thresholds at 0.85", () => {
-  assert.equal(isNearDuplicate("user fixed the parser bug", "user fixed the parser bug today"), true);
-  assert.equal(isNearDuplicate("alpha beta gamma", "totally different words here"), false);
-});
-
-test("shingles are capped at 50K (complexity guard)", () => {
-  const huge = "x".repeat(200_000);
-  const sh = shingles(huge);
-  assert.ok(sh.length <= 50_000);
-});

package/src/dedup/raptor/buildHistory.test.ts

@@ -1,353 +0,0 @@
-/**
- * buildHistory.test.ts — S42D RAPTOR build history + freshness tests.
- *
- * No network. Real stores with temp state dirs.
- */
-
-import { test, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { openStore } from "../../store/sqlite/utils.js";
-import {
-  insertBuildHistory,
-  getLatestBuild,
-  listBuildHistory,
-  computeCoherenceScore,
-  isRaptorTreeFresh,
-  clearBuildHistory,
-} from "./buildHistory.js";
-import { runRaptor } from "./index.js";
-import { VectorStore, vectorList } from "../../vectorStore.js";
-import { compactSession } from "../../engine.js";
-import { loadDedupConfig } from "../../config/dedup.js";
-import { normalizeSessionId } from "../../store.js";
-import { Logger } from "../../log.js";
-import type { RaptorTree } from "./tree.js";
-import type { DedupConfigShape } from "../../config/dedup.js";
-import type { EngineMessage } from "../../types.js";
-
-let tmpDir: string;
-let counter = 0;
-
-beforeEach(() => {
-  tmpDir = mkdtempSync(join(tmpdir(), "mc-bh-"));
-});
-
-afterEach(() => {
-  rmSync(tmpDir, { recursive: true, force: true });
-});
-
-function stateDir(): string {
-  return join(tmpDir, `run-${counter++}`);
-}
-
-function cfg(overrides?: Record<string, unknown>): DedupConfigShape {
-  return {
-    ...loadDedupConfig(),
-    RAPTOR_ENABLED: true,
-    L0_ENABLED: false,
-    L1_ENABLED: false,
-    L2_ENABLED: false,
-    ...overrides,
-  };
-}
-
-function msg(text: string, toolName?: string): EngineMessage {
-  return toolName
-    ? { role: "assistant", text, toolName, input: text, output: text }
-    : { role: "user", text };
-}
-
-// ─── 1. Build-history rows are created with correct metadata ──────────────
-
-test("S42D-1: insertBuildHistory + getLatestBuild round-trip", () => {
-  const sd = stateDir();
-  openStore(sd); // initialize schema
-  const ts = Date.now();
-  const id = insertBuildHistory(
-    {
-      sessionId: "sess-foo",
-      stateDir: sd,
-      startedAt: ts - 500,
-      completedAt: ts,
-      nodeCount: 6,
-      leafCount: 10,
-      depth: 3,
-      configJson: '{"budgetMs":5000}',
-      coherenceScore: 0.82,
-      timedOut: false,
-    },
-    sd,
-  );
-  assert.ok(id, "build id returned");
-  const latest = getLatestBuild("sess-foo", sd);
-  assert.ok(latest, "latest build found");
-  assert.equal(latest!.sessionId, normalizeSessionId("sess-foo"));
-  assert.equal(latest!.nodeCount, 6);
-  assert.equal(latest!.leafCount, 10);
-  assert.equal(latest!.depth, 3);
-  assert.equal(latest!.coherenceScore, 0.82);
-  assert.equal(latest!.timedOut, false);
-  assert.equal(latest!.configJson, '{"budgetMs":5000}');
-  // getLatest returns the newest by completed_at
-  insertBuildHistory(
-    {
-      sessionId: "sess-foo",
-      stateDir: sd,
-      startedAt: ts + 1000,
-      completedAt: ts + 2000,
-      nodeCount: 7,
-      leafCount: 11,
-      depth: 3,
-      configJson: "{}",
-      coherenceScore: null,
-      timedOut: true,
-    },
-    sd,
-  );
-  const newest = getLatestBuild("sess-foo", sd);
-  assert.equal(newest!.nodeCount, 7);
-  assert.equal(newest!.timedOut, true);
-  assert.equal(newest!.coherenceScore, null);
-  // listBuildHistory returns all, newest first
-  const all = listBuildHistory("sess-foo", sd);
-  assert.equal(all.length, 2);
-  assert.equal(all[0].nodeCount, 7); // newest first
-  // No history for an unknown session
-  assert.equal(getLatestBuild("sess-none", sd), null);
-  assert.deepEqual(listBuildHistory("sess-none", sd), []);
-  // clearBuildHistory removes rows
-  clearBuildHistory("sess-foo", sd);
-  assert.equal(getLatestBuild("sess-foo", sd), null);
-});
-
-// ─── 2. Coherence score: 1.0 for identical, lower for diverse ───────────────
-
-test("S42D-2: computeCoherenceScore is 1.0 for identical embeddings, lower for diverse", () => {
-  const identical: RaptorTree = {
-    rootId: "root",
-    nodes: new Map([
-      ["root", { id: "root", level: 0, parentId: null, children: ["c1", "c2"], summary: "r", embedding: [1, 0], qualityMarker: "low", tokenEstimate: 2 }],
-      ["c1", { id: "c1", level: 1, parentId: "root", children: [], summary: "c1", embedding: [1, 0], qualityMarker: "low", tokenEstimate: 1 }],
-      ["c2", { id: "c2", level: 1, parentId: "root", children: [], summary: "c2", embedding: [1, 0], qualityMarker: "low", tokenEstimate: 1 }],
-    ]),
-    levels: 2,
-    timedOut: false,
-  };
-  assert.equal(computeCoherenceScore(identical), 1.0);
-  // Diverse: orthogonal children → cosine 0
-  const diverse: RaptorTree = {
-    rootId: "root",
-    nodes: new Map([
-      ["root", { id: "root", level: 0, parentId: null, children: ["c1", "c2"], summary: "r", embedding: [1, 0], qualityMarker: "low", tokenEstimate: 2 }],
-      ["c1", { id: "c1", level: 1, parentId: "root", children: [], summary: "c1", embedding: [1, 0], qualityMarker: "low", tokenEstimate: 1 }],
-      ["c2", { id: "c2", level: 1, parentId: "root", children: [], summary: "c2", embedding: [0, 1], qualityMarker: "low", tokenEstimate: 1 }],
-    ]),
-    levels: 2,
-    timedOut: false,
-  };
-  const diverseScore = computeCoherenceScore(diverse);
-  assert.ok(diverseScore < 1.0, `diverse score < 1.0 (got ${diverseScore})`);
-  assert.ok(diverseScore >= 0, "score is non-negative");
-  // No internal nodes with >=2 children → 0
-  const single: RaptorTree = {
-    rootId: "root",
-    nodes: new Map([
-      ["root", { id: "root", level: 0, parentId: null, children: ["c1"], summary: "r", embedding: [1, 0], qualityMarker: "low", tokenEstimate: 1 }],
-      ["c1", { id: "c1", level: 1, parentId: "root", children: [], summary: "c1", embedding: [1, 0], qualityMarker: "low", tokenEstimate: 1 }],
-    ]),
-    levels: 2,
-    timedOut: false,
-  };
-  assert.equal(computeCoherenceScore(single), 0);
-});
-
-// ─── 2b. Coherence with leaf embeddings (the real-tree shape) ──────────────
-
-test("S42D-2b: computeCoherenceScore uses leafEmbeddings for leaf children (real-tree shape)", () => {
-  // Root whose children are raw leaves (the common collapse-path shape).
-  // Without leafEmbeddings, leaves fall back to the root centroid → score 1.0
-  // (degenerate). With true leaf embeddings, diverse leaves score < 1.0.
-  const tree: RaptorTree = {
-    rootId: "root",
-    nodes: new Map([
-      ["root", { id: "root", level: 0, parentId: null, children: ["l1", "l2"], summary: "r", embedding: [1, 0], qualityMarker: "low", tokenEstimate: 2 }],
-    ]),
-    levels: 1,
-    timedOut: false,
-  };
-  // No leaf map → both leaves use root centroid [1,0] → cosine 1.0 (degenerate).
-  assert.equal(computeCoherenceScore(tree), 1.0);
-  // Leaf map with orthogonal leaves → cosine 0 (truly diverse).
-  const leafMap = new Map([
-    ["l1", [1, 0]],
-    ["l2", [0, 1]],
-  ]);
-  const score = computeCoherenceScore(tree, leafMap);
-  assert.ok(score < 1.0, `diverse leaves score < 1.0 (got ${score})`);
-  assert.ok(score >= 0, "score non-negative");
-  // Identical leaves via the map → 1.0
-  const leafMapIdentical = new Map([
-    ["l1", [1, 0]],
-    ["l2", [1, 0]],
-  ]);
-  assert.equal(computeCoherenceScore(tree, leafMapIdentical), 1.0);
-});
-
-// ─── 3. Freshness check: recent + stable → fresh ────────────────────────────
-
-test("S42D-3: isRaptorTreeFresh true for recent build + stable count", () => {
-  const sd = stateDir();
-  openStore(sd);
-  insertBuildHistory(
-    {
-      sessionId: "sess-fresh",
-      stateDir: sd,
-      startedAt: Date.now() - 1000,
-      completedAt: Date.now() - 500, // < 4h old
-      nodeCount: 6,
-      leafCount: 10,
-      depth: 3,
-      configJson: "{}",
-      coherenceScore: 0.5,
-      timedOut: false,
-    },
-    sd,
-  );
-  // 10 checkpoints, latest had 10 → within 20% → fresh
-  assert.equal(isRaptorTreeFresh("sess-fresh", sd, 4, 10), true);
-  // 11 checkpoints → 10% change → still fresh
-  assert.equal(isRaptorTreeFresh("sess-fresh", sd, 4, 11), true);
-  // 9 checkpoints → 10% change → fresh
-  assert.equal(isRaptorTreeFresh("sess-fresh", sd, 4, 9), true);
-});
-
-// ─── 4. Freshness check: stale build → not fresh ────────────────────────────
-
-test("S42D-4: isRaptorTreeFresh false for stale build (>4h old)", () => {
-  const sd = stateDir();
-  openStore(sd);
-  const oldTs = Date.now() - 5 * 3_600_000; // 5h ago
-  insertBuildHistory(
-    {
-      sessionId: "sess-stale",
-      stateDir: sd,
-      startedAt: oldTs - 1000,
-      completedAt: oldTs,
-      nodeCount: 6,
-      leafCount: 10,
-      depth: 3,
-      configJson: "{}",
-      coherenceScore: 0.5,
-      timedOut: false,
-    },
-    sd,
-  );
-  assert.equal(isRaptorTreeFresh("sess-stale", sd, 4, 10), false);
-});
-
-// ─── 5. Freshness check: count drift > 20% → not fresh ──────────────────────
-
-test("S42D-5: isRaptorTreeFresh false when checkpoint count changed by >20%", () => {
-  const sd = stateDir();
-  openStore(sd);
-  insertBuildHistory(
-    {
-      sessionId: "sess-drift",
-      stateDir: sd,
-      startedAt: Date.now() - 1000,
-      completedAt: Date.now() - 500,
-      nodeCount: 6,
-      leafCount: 10,
-      depth: 3,
-      configJson: "{}",
-      coherenceScore: 0.5,
-      timedOut: false,
-    },
-    sd,
-  );
-  // 13 checkpoints vs 10 → 30% increase → not fresh
-  assert.equal(isRaptorTreeFresh("sess-drift", sd, 4, 13), false);
-  // 7 checkpoints vs 10 → 30% decrease → not fresh
-  assert.equal(isRaptorTreeFresh("sess-drift", sd, 4, 7), false);
-});
-
-// ─── 6. No build history → freshness false (forces build) ───────────────────
-
-test("S42D-6: isRaptorTreeFresh false when no build history exists", () => {
-  const sd = stateDir();
-  openStore(sd);
-  assert.equal(isRaptorTreeFresh("sess-none", sd, 4, 50), false);
-  // freshnessHours=0 always false (disables the gate → always rebuild)
-  insertBuildHistory(
-    {
-      sessionId: "sess-zero",
-      stateDir: sd,
-      startedAt: Date.now() - 100,
-      completedAt: Date.now() - 50,
-      nodeCount: 1,
-      leafCount: 5,
-      depth: 1,
-      configJson: "{}",
-      coherenceScore: 0.5,
-      timedOut: false,
-    },
-    sd,
-  );
-  assert.equal(isRaptorTreeFresh("sess-zero", sd, 0, 5), false);
-});
-
-// ─── 7. runRaptor records build history end-to-end ──────────────────────────
-
-test("S42D-7: runRaptor records a build-history row on real build", () => {
-  const sd = stateDir();
-  const s = new VectorStore({ dedupSim: 0.9, stateDir: sd, config: cfg() });
-  const sid = "bh-e2e";
-  // Seed 12 checkpoints and build a tree.
-  for (let i = 1; i <= 12; i++) {
-    compactSession(
-      {
-        sessionId: sid,
-        messages: [
-          msg(`build-history test checkpoint ${i} alpha beta`),
-          msg(`ack ${i}`, "Edit"),
-       	],
-        keepFrom: 2,
-        timestamp: i + 1,
-      },
-      s,
-    );
-  }
-  const nsid = normalizeSessionId(sid);
-  const all = vectorList(s, nsid);
-  const leaves = all.map((cp) => ({
-    id: cp.checkpointId,
-    messages: [],
-    sourceText: cp.normalizedText ?? cp.summary ?? cp.regionHash,
-    embedding: cp.embedding,
-  }));
-  const tree = runRaptor(leaves, {
-    stateDir: sd,
-    sessionId: nsid,
-    logger: new Logger(),
-  });
-  assert.ok(tree, "tree built");
-  const latest = getLatestBuild(nsid, sd);
-  assert.ok(latest, "build history recorded by runRaptor");
-  assert.equal(latest!.leafCount, leaves.length);
-  assert.equal(latest!.depth, tree!.levels);
-  assert.equal(latest!.timedOut, tree!.timedOut);
-  assert.equal(latest!.nodeCount, tree!.nodes.size);
-  assert.ok(
-    latest!.coherenceScore !== null && latest!.coherenceScore >= 0,
-    "coherence score recorded",
-  );
-  // The freshness gate should now report fresh for the same checkpoint count.
-  assert.equal(
-    isRaptorTreeFresh(nsid, sd, 4, all.length),
-    true,
-    "tree is fresh immediately after build",
-  );
-});