pi-mega-compact 0.11.4 → 0.11.6

package/src/engine.test.ts

@@ -1,123 +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";
-import type { EngineMessage } from "./types.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: EngineMessage["role"], text: string, toolName?: string): EngineMessage {
-  return toolName ? { role, text, toolName, input: text, output: text } : { role, text };
-}
-
-test("compactSession supersedes then persists a checkpoint", () => {
-  const s = store();
-  const messages: EngineMessage[] = [
-    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: EngineMessage[] = [
-    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: EngineMessage[] = [
-    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: EngineMessage[] = [
-    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/src/extractive.test.ts

@@ -1,174 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { extractiveSummarize } from "./extractive.js";
-import type { EngineMessage } from "./types.js";
-
-function msg(role: EngineMessage["role"], text: string, toolName?: string): EngineMessage {
-  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 as unknown as string, toolName: "Edit", input: "src/index.ts" },
-    { role: "tool", text: undefined as unknown as string, toolName: "Edit", output: "ok" },
-    { role: "assistant", text: "done editing src/index.ts" },
-  ] as EngineMessage[];
-  // 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: EngineMessage[] = [
-    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: EngineMessage[] = [];
-  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: EngineMessage[] = [
-    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: EngineMessage[] = [
-    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: EngineMessage[] = [
-    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: EngineMessage[] = [
-    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: EngineMessage[] = [
-    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: EngineMessage[] = [
-    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: EngineMessage[] = [
-    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: EngineMessage[] = [
-    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/src/fork.test.ts

@@ -1,94 +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: string;
-let counter = 0;
-
-beforeEach(() => {
-	tmpDir = mkdtempSync(join(tmpdir(), "mc-fork-"));
-});
-
-afterEach(() => {
-	closeAllTurnDbs();
-	rmSync(tmpDir, { recursive: true, force: true });
-});
-
-function stateDir(): string {
-	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: unknown) => {
-			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: unknown) => {
-			return e instanceof ForkError && e.code === "NO_RECALL";
-		},
-	);
-	store.close();
-});

package/src/game/scoring.test.ts

@@ -1,103 +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";
-import type { LeaderboardRow } from "../store/sqlite/game-scores.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: number, opts: { ts?: number; meta?: unknown } = {}): LeaderboardRow {
-	return { repo_root: "/repo/a", value, ts: opts.ts ?? 1_700_000_000_000, meta: opts.meta ?? null };
-}
-
-describe("evaluateAchievements (S35)", () => {
-	const empty = { dedupe: [] as LeaderboardRow[], turns: [] as LeaderboardRow[], cache: [] as LeaderboardRow[], megaCache: [] as LeaderboardRow[], 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);
-	});
-});