pi-mega-compact 0.11.3 → 0.11.5

package/dist/src/engine.test.js

@@ -1,111 +0,0 @@
-import { test } 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 { VectorStore, vectorMarkInjected, vectorSearch } from "./vectorStore.js";
-import { compactSession, recall, mergeSummary, supersededCount } from "./engine.js";
-const baseTmp = mkdtempSync(join(tmpdir(), "mc-engine-"));
-let counter = 0;
-function store() {
-    return new VectorStore({ dedupSim: 0.9, stateDir: join(baseTmp, `run-${counter++}`) });
-}
-const SESS = "sess_engine";
-function msg(role, text, toolName) {
-    return toolName ? { role, text, toolName, input: text, output: text } : { role, text };
-}
-test("compactSession supersedes then persists a checkpoint", () => {
-    const s = store();
-    const messages = [
-        msg("user", "read src/server.ts"),
-        msg("assistant", "ok", "Read"),
-        msg("user", "edit src/server.ts"),
-        msg("assistant", "ok", "Edit"),
-        msg("user", "now fix the bug in src/server.ts"),
-        msg("assistant", "done", "Edit"),
-    ];
-    const r = compactSession({ sessionId: SESS, messages, keepFrom: 4, timestamp: 1 }, s);
-    assert.equal(r.skipped, false);
-    assert.equal(r.deduped, false);
-    assert.match(r.checkpointId ?? "", /^chkpt_001$/);
-    assert.ok(r.summary.length > 0, "summary produced by COLLAPSE");
-    assert.ok(r.regionHash.length > 0);
-    // SUPERSEDE dropped the obsolete first read turn (user read @0 superseded by
-    // the edit @2) — so exactly one superseded message in the compacted slice.
-    assert.equal(supersededCount(messages.slice(0, 4)), 1);
-    assert.equal(r.compactedFrom, 4);
-    // The persisted checkpoint is searchable.
-    assert.equal(vectorSearch(s, SESS, "bug src/server.ts", 5).length, 1);
-});
-test("compactSession is idempotent on identical region (dedup sentinel)", () => {
-    const s = store();
-    const messages = [
-        msg("user", "alpha work on the parser"),
-        msg("assistant", "did it", "Edit"),
-        msg("user", "beta work on the renderer"),
-        msg("assistant", "done", "Edit"),
-    ];
-    const r1 = compactSession({ sessionId: SESS, messages, keepFrom: 4, timestamp: 1 }, s);
-    const r2 = compactSession({ sessionId: SESS, messages, keepFrom: 4, timestamp: 2 }, s);
-    assert.equal(r1.deduped, false);
-    assert.equal(r2.deduped, true);
-    assert.equal(r1.checkpointId, r2.checkpointId);
-    assert.equal(vectorSearch(s, SESS, "parser", 10).length, 1);
-});
-test("compactSession skipped when slice is empty", () => {
-    const s = store();
-    const r = compactSession({ sessionId: SESS, messages: [msg("user", "only tail")], keepFrom: 0 }, s);
-    assert.equal(r.skipped, true);
-    assert.equal(vectorSearch(s, SESS, "x", 5).length, 0);
-});
-test("recall drops already-injected checkpoints", () => {
-    const s = store();
-    compactSession({ sessionId: SESS, messages: [msg("user", "investigated src/vectorStore.ts"), msg("assistant", "ok", "Edit")], keepFrom: 2, timestamp: 1 }, s);
-    const first = recall({ sessionId: SESS, query: "vectorStore", limit: 5, skipInjected: true }, s);
-    assert.equal(first.newHits.length, 1);
-    vectorMarkInjected(s, SESS, first.hits[0].checkpoint.checkpointId);
-    const second = recall({ sessionId: SESS, query: "vectorStore", limit: 5, skipInjected: true }, s);
-    assert.equal(second.newHits.length, 0);
-    // Without the skip flag, both hits still surface.
-    assert.equal(second.hits.length, 1);
-});
-test("mergeSummary accumulates prior + new context", () => {
-    const prior = "<summary>Conversation summary:\n- Key files referenced: src/a.ts.\n</summary>";
-    const next = "<summary>Conversation summary:\n- Key files referenced: src/b.ts.\n</summary>";
-    const merged = mergeSummary(prior, next);
-    assert.ok(merged.includes("src/a.ts"));
-    assert.ok(merged.includes("src/b.ts"));
-    assert.ok(merged.includes("Newly compacted"));
-});
-test("supersededCount reports obsolete reads", () => {
-    const messages = [
-        msg("user", "read src/x.ts"),
-        msg("assistant", "ok", "Read"),
-        msg("user", "write src/x.ts"),
-        msg("assistant", "ok", "Edit"),
-    ];
-    assert.equal(supersededCount(messages), 1);
-});
-test("compactSession with useExtractive produces topicSummary on checkpoint", () => {
-    const s = store();
-    const messages = [
-        msg("user", "let's refactor the auth module in src/auth.ts"),
-        msg("assistant", "I'll start by reading the current implementation", "Read"),
-        msg("user", "extract the login logic into a separate function"),
-        msg("assistant", "Extracted login() into src/auth.ts:45", "Edit"),
-        msg("user", "now add the session token generation"),
-        msg("assistant", "Added generateSessionToken in src/auth.ts:78", "Edit"),
-    ];
-    const r = compactSession({ sessionId: "sess_extr", messages, keepFrom: 4, timestamp: 1, useExtractiveSummary: true }, s);
-    assert.equal(r.skipped, false);
-    assert.ok(r.checkpointId, "checkpoint created");
-    // The checkpoint should have topicSummary populated
-    const hits = vectorSearch(s, "sess_extr", "auth refactor", 5);
-    assert.ok(hits.length > 0);
-    // topicSummary should be present on the stored checkpoint (via extractive path)
-    assert.ok(hits[0].checkpoint.topicSummary, "topicSummary should be populated when useExtractive is true");
-    assert.ok(hits[0].checkpoint.topicSummary.length > 0);
-});
-test("cleanup", () => {
-    rmSync(baseTmp, { recursive: true, force: true });
-});

package/dist/src/extractive.test.js

@@ -1,147 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { extractiveSummarize } from "./extractive.js";
-function msg(role, text, toolName) {
-    return toolName ? { role, text, toolName, input: text, output: text } : { role, text };
-}
-// ---- Crash regression: undefined text (S25 hotfix) ------------------------
-// pi tool/custom messages can arrive with `text: undefined` when only
-// input/output is set. The adapter (adapt.ts) now coerces to "", and
-// extractiveSummarize guards its entry too. This test pins the no-crash
-// contract directly against the engine entry (defense in depth).
-test("extractiveSummarize does not crash on messages with undefined text", () => {
-    const messages = [
-        { role: "user", text: "please edit src/index.ts" },
-        { role: "assistant", text: undefined, toolName: "Edit", input: "src/index.ts" },
-        { role: "tool", text: undefined, toolName: "Edit", output: "ok" },
-        { role: "assistant", text: "done editing src/index.ts" },
-    ];
-    // Must not throw — previously crashed at text.matchAll in extractFilePaths.
-    const s = extractiveSummarize(messages);
-    assert.ok(typeof s.topicSummary === "string");
-    assert.ok(s.topicSummary.length >= 0);
-});
-// ---- Determinism -----------------------------------------------------------
-test("extractive summary is deterministic", () => {
-    const messages = [
-        msg("user", "please write src/index.ts"),
-        msg("assistant", "I'll write src/index.ts now."),
-        msg("tool", '{"file_path":"src/index.ts"}', "write"),
-        msg("assistant", "Done."),
-    ];
-    const s1 = extractiveSummarize(messages);
-    const s2 = extractiveSummarize(messages);
-    assert.deepStrictEqual(s1, s2);
-});
-// ---- Compression -----------------------------------------------------------
-test("extractive summary produces small output", () => {
-    // Build 70 messages (simulating a session)
-    const messages = [];
-    for (let i = 0; i < 70; i++) {
-        messages.push(msg("user", `request ${i}: please help with feature ${i}`));
-        messages.push(msg("assistant", `working on feature ${i} in src/file${i % 5}.ts`));
-        messages.push(msg("tool", `{"file_path":"src/file${i % 5}.ts","content":"..."}`, "write"));
-        messages.push(msg("assistant", `done with feature ${i}`));
-    }
-    const rawText = messages.map((m) => m.text).join("\n");
-    const rawTokens = Math.ceil(rawText.length / 4);
-    const summary = extractiveSummarize(messages);
-    const ratio = rawTokens / summary.tokenEstimate;
-    // Compression should be at least 5:1 (target is 35:1)
-    assert.ok(ratio >= 5, `compression ratio ${ratio.toFixed(1)}:1 is less than 5:1`);
-    assert.ok(summary.tokenEstimate < 5000, `summary is ${summary.tokenEstimate} tokens (expected < 5000)`);
-});
-// ---- Empty input ------------------------------------------------------------
-test("empty messages returns minimal summary", () => {
-    const summary = extractiveSummarize([]);
-    assert.equal(summary.topicSummary, "(empty)");
-    assert.equal(summary.keyDecisions.length, 0);
-    assert.equal(summary.nextSteps.length, 0);
-    assert.equal(summary.filesModified.length, 0);
-    assert.equal(summary.tokenEstimate, 0);
-});
-// ---- Key decisions ----------------------------------------------------------
-test("extracts decisions from assistant messages", () => {
-    const messages = [
-        msg("user", "which database should we use?"),
-        msg("assistant", "I recommend using better-sqlite3 for the local vector store."),
-        msg("assistant", "Let's go with the Trident pipeline architecture."),
-    ];
-    const summary = extractiveSummarize(messages);
-    assert.ok(summary.keyDecisions.length >= 1, "should extract at least 1 decision");
-    assert.ok(summary.keyDecisions.some((d) => d.includes("better-sqlite3")), `decisions: ${JSON.stringify(summary.keyDecisions)}`);
-});
-test("no decisions in tool messages", () => {
-    const messages = [
-        msg("tool", "I recommend something", "bash"),
-    ];
-    const summary = extractiveSummarize(messages);
-    // Tool messages should not be checked for decisions
-    assert.equal(summary.keyDecisions.length, 0);
-});
-// ---- Files modified ---------------------------------------------------------
-test("extracts files from write/edit tool calls", () => {
-    const messages = [
-        msg("tool", '{"file_path":"/home/user/project/src/index.ts","content":"..."}', "write"),
-        msg("tool", '{"file_path":"/home/user/project/README.md","content":"..."}', "edit"),
-    ];
-    const summary = extractiveSummarize(messages);
-    assert.ok(summary.filesModified.includes("/home/user/project/src/index.ts"));
-    assert.ok(summary.filesModified.includes("/home/user/project/README.md"));
-});
-test("extracts files from git commands in bash", () => {
-    const messages = [
-        msg("tool", "git add src/index.ts src/types.ts", "bash"),
-    ];
-    const summary = extractiveSummarize(messages);
-    assert.ok(summary.filesModified.some((f) => f.includes("index.ts")));
-});
-// ---- Pending work -----------------------------------------------------------
-test("extracts pending work markers", () => {
-    const messages = [
-        msg("user", "run the tests"),
-        msg("assistant", "Tests pass. TODO: add integration tests for the dedup path."),
-    ];
-    const summary = extractiveSummarize(messages);
-    assert.ok(summary.nextSteps.length >= 1, "should find TODO");
-    assert.ok(summary.nextSteps.some((s) => /integration tests/i.test(s)));
-});
-// ---- topicSummary structure -------------------------------------------------
-test("topicSummary contains scope line", () => {
-    const messages = [
-        msg("user", "hello"),
-        msg("assistant", "hi there"),
-    ];
-    const summary = extractiveSummarize(messages);
-    assert.ok(summary.topicSummary.includes("Conversation: 2 messages"));
-    assert.ok(summary.topicSummary.includes("1 user"));
-    assert.ok(summary.topicSummary.includes("1 assistant"));
-});
-test("topicSummary includes tools when present", () => {
-    const messages = [
-        msg("tool", "ok", "write"),
-        msg("tool", "ok", "bash"),
-    ];
-    const summary = extractiveSummarize(messages);
-    assert.ok(summary.topicSummary.includes("Tools:"));
-    assert.ok(summary.topicSummary.includes("write"));
-    assert.ok(summary.topicSummary.includes("bash"));
-});
-// ---- Same messages produce same summary ------------------------------------
-test("deterministic across invocations with complex input", () => {
-    const messages = [
-        msg("user", "help me refactor the auth module"),
-        msg("assistant", "I'll look at the current auth implementation."),
-        msg("tool", '{"file_path":"src/auth.ts"}', "read"),
-        msg("assistant", "I recommend splitting auth.ts into separate files."),
-        msg("user", "sounds good, go ahead"),
-        msg("assistant", "I'll create src/auth/login.ts and src/auth/register.ts."),
-        msg("tool", '{"file_path":"src/auth/login.ts","content":"..."}', "write"),
-        msg("tool", '{"file_path":"src/auth/register.ts","content":"..."}', "write"),
-        msg("assistant", "Done. TODO: update the import paths in main.ts."),
-    ];
-    const results = Array.from({ length: 5 }, () => extractiveSummarize(messages));
-    for (let i = 1; i < results.length; i++) {
-        assert.deepStrictEqual(results[i], results[0], `run ${i} differs from run 0`);
-    }
-});

package/dist/src/fork.test.js

@@ -1,81 +0,0 @@
-/**
- * fork.test.ts — S50C fork primitive tests. No network; temp dirs.
- *
- * Uses the contract-first TurnStore (createTurnStore({ stateDir })).
- */
-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 { createTurnStore, closeAllTurnDbs } from "./store/turns/index.js";
-import { forkFromConversation, ForkError } from "./fork.js";
-let tmpDir;
-let counter = 0;
-beforeEach(() => {
-    tmpDir = mkdtempSync(join(tmpdir(), "mc-fork-"));
-});
-afterEach(() => {
-    closeAllTurnDbs();
-    rmSync(tmpDir, { recursive: true, force: true });
-});
-function stateDir() {
-    return join(tmpDir, `run-${counter++}`);
-}
-test("fork resolves the turn + returns the recall set to rehydrate", () => {
-    const dir = stateDir();
-    const store = createTurnStore({ stateDir: dir });
-    const conv = store.ensureConversationId("sess_f");
-    const turnId = store.appendTurn({
-        conversationId: conv,
-        sessionId: "sess_f",
-        turnIndex: 2,
-        role: "assistant",
-        endedAt: Date.now(),
-    });
-    store.appendRecall({
-        turnId: turnId,
-        checkpointId: "cp_a",
-        score: 0.9,
-        source: "checkpoint",
-    });
-    store.appendRecall({
-        turnId: turnId,
-        checkpointId: "cp_b",
-        score: 0.7,
-        source: "cluster_summary",
-        raptorLevel: 1,
-    });
-    const out = forkFromConversation(store, conv, 2);
-    assert.ok(out.childConversationId.startsWith("conv_"));
-    assert.notEqual(out.childConversationId, conv);
-    assert.equal(out.forkTurn.turnIndex, 2);
-    assert.deepEqual(out.checkpointIds.sort(), ["cp_a", "cp_b"]);
-    assert.equal(out.recalled.length, 2);
-    store.close();
-});
-test("unknown turn → ForkError TURN_NOT_FOUND", () => {
-    const dir = stateDir();
-    const store = createTurnStore({ stateDir: dir });
-    const conv = store.ensureConversationId("sess_g");
-    assert.throws(() => forkFromConversation(store, conv, 99), (e) => {
-        return e instanceof ForkError && e.code === "TURN_NOT_FOUND";
-    });
-    store.close();
-});
-test("turn with no recall set → ForkError NO_RECALL", () => {
-    const dir = stateDir();
-    const store = createTurnStore({ stateDir: dir });
-    const conv = store.ensureConversationId("sess_h");
-    store.appendTurn({
-        conversationId: conv,
-        sessionId: "sess_h",
-        turnIndex: 0,
-        role: "assistant",
-        endedAt: Date.now(),
-    });
-    assert.throws(() => forkFromConversation(store, conv, 0), (e) => {
-        return e instanceof ForkError && e.code === "NO_RECALL";
-    });
-    store.close();
-});

package/dist/src/game/scoring.test.js

@@ -1,98 +0,0 @@
-/**
- * scoring.test.ts — S33 pure scoring helpers. Pi-agnostic, no I/O.
- */
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { turnLevel, isMegaCache, cacheScore, evaluateAchievements, maxCompactCount, ACHIEVEMENT_DEFS } from "./scoring.js";
-describe("scoring (S33)", () => {
-    it("turnLevel: floor(log2(n+1))+1 sequence", () => {
-        assert.equal(turnLevel(0), 1);
-        assert.equal(turnLevel(1), 2);
-        assert.equal(turnLevel(2), 2);
-        assert.equal(turnLevel(3), 3);
-        assert.equal(turnLevel(4), 3);
-        assert.equal(turnLevel(7), 4);
-        assert.equal(turnLevel(15), 5);
-        // defensive: non-finite / negative inputs collapse to level 1
-        assert.equal(turnLevel(-1), 1);
-        assert.equal(turnLevel(NaN), 1);
-    });
-    it("isMegaCache: 100% is the boundary", () => {
-        assert.equal(isMegaCache(99.9), false);
-        assert.equal(isMegaCache(100), true);
-        assert.equal(isMegaCache(150), true);
-        assert.equal(isMegaCache(0), false);
-        assert.equal(isMegaCache(NaN), false);
-    });
-    it("cacheScore: 0 lookups -> 0 (not NaN), else hits/lookups*100", () => {
-        assert.equal(cacheScore(0, 0), 0);
-        assert.equal(cacheScore(7, 10), 70);
-        assert.equal(cacheScore(0, 5), 0);
-        assert.equal(cacheScore(10, 10), 100);
-        // non-finite inputs are guarded (no NaN leaks)
-        assert.equal(cacheScore(1, NaN), 0);
-        assert.equal(cacheScore(NaN, 5), 0);
-    });
-});
-function achRow(value, opts = {}) {
-    return { repo_root: "/repo/a", value, ts: opts.ts ?? 1_700_000_000_000, meta: opts.meta ?? null };
-}
-describe("evaluateAchievements (S35)", () => {
-    const empty = { dedupe: [], turns: [], cache: [], megaCache: [], reposCount: 0 };
-    it("ACHIEVEMENT_DEFS: 9 achievements, exactly 1 hidden", () => {
-        assert.equal(ACHIEVEMENT_DEFS.length, 9);
-        assert.equal(ACHIEVEMENT_DEFS.filter((d) => d.hidden).length, 1);
-    });
-    it("first_compact: >=1 dedupe row", () => {
-        const r = evaluateAchievements({ ...empty, dedupe: [achRow(1)] }, []);
-        assert.ok(r.unlocked.includes("first_compact"));
-        assert.ok(r.newlyUnlocked.includes("first_compact"));
-    });
-    it("compact_streak: max meta.compactCount >= 5", () => {
-        const r = evaluateAchievements({ ...empty, dedupe: [achRow(1, { meta: { compactCount: 5 } })] }, []);
-        assert.ok(r.unlocked.includes("compact_streak"));
-    });
-    it("turn_veteran: max turns >= 25", () => {
-        const r = evaluateAchievements({ ...empty, turns: [achRow(25)] }, []);
-        assert.ok(r.unlocked.includes("turn_veteran"));
-    });
-    it("level_five: turnLevel(maxTurns) >= 5 (15 turns)", () => {
-        const r = evaluateAchievements({ ...empty, turns: [achRow(15)] }, []);
-        assert.ok(r.unlocked.includes("level_five"));
-    });
-    it("dedupe_master: sum dedupe >= 100", () => {
-        const r = evaluateAchievements({ ...empty, dedupe: [achRow(60), achRow(40)] }, []);
-        assert.ok(r.unlocked.includes("dedupe_master"));
-    });
-    it("repo_explorer: reposCount >= 3", () => {
-        const r = evaluateAchievements({ ...empty, reposCount: 3 }, []);
-        assert.ok(r.unlocked.includes("repo_explorer"));
-    });
-    it("night_owl: a row whose local hour is in [0,5)", () => {
-        const d = new Date();
-        d.setHours(2, 0, 0, 0);
-        const r = evaluateAchievements({ ...empty, cache: [achRow(50, { ts: d.getTime() })] }, []);
-        assert.ok(r.unlocked.includes("night_owl"));
-    });
-    it("flawless: maxCache >= 100 AND no mega_cache overshoot", () => {
-        const r = evaluateAchievements({ ...empty, cache: [achRow(100)], megaCache: [] }, []);
-        assert.ok(r.unlocked.includes("flawless"));
-    });
-    it("flawless NOT when a mega_cache overshoot row (>100) exists", () => {
-        const r = evaluateAchievements({ ...empty, cache: [achRow(100)], megaCache: [achRow(101)] }, []);
-        assert.ok(!r.unlocked.includes("flawless"));
-    });
-    it("opie_wild_ride: any mega_cache trophy row exists", () => {
-        const r = evaluateAchievements({ ...empty, megaCache: [achRow(100)] }, []);
-        assert.ok(r.unlocked.includes("opie_wild_ride"));
-    });
-    it("newlyUnlocked excludes ids already unlocked", () => {
-        const r = evaluateAchievements({ ...empty, dedupe: [achRow(1)] }, ["first_compact"]);
-        assert.ok(r.unlocked.includes("first_compact"));
-        assert.ok(!r.newlyUnlocked.includes("first_compact"));
-    });
-    it("maxCompactCount: 0 when meta absent, else the max", () => {
-        assert.equal(maxCompactCount([achRow(1)]), 0);
-        assert.equal(maxCompactCount([achRow(1, { meta: { compactCount: 7 } })]), 7);
-    });
-});