pi-mega-compact 0.21.2 → 0.21.4

package/src/store/turns/memory-store/ctx.ts

@@ -0,0 +1,62 @@
+/**
+ * ctx.ts — internal context interface for InMemoryTurnStore method bodies
+ * (extracted from memory-store.ts). Each free function in this directory
+ * operates on a MemoryTurnStoreCtx so the shell class can delegate without
+ * exposing its private fields.
+ *
+ * Mirrors sqlite-store/ctx.ts. The Map/array references are stable for the
+ * life of the store: arrays (recall, forks) are mutated IN PLACE
+ * (push/splice/length=0), never reassigned, so a ctx captured at any point
+ * sees the current contents. The id counter is module-scoped here so both the
+ * shell (writers) and admin.ts share one allocator.
+ */
+import { randomBytes } from "node:crypto";
+import type {
+	ConversationFork,
+	ConversationId,
+	SessionId,
+	TurnEntry,
+	TurnRecallEntry,
+} from "../types.js";
+
+/** Internal row with numeric id. */
+export interface TurnRow {
+	id: number;
+	entry: TurnEntry;
+	epochId?: string;
+}
+
+/** Internal recall row keyed by numeric turn id. */
+export interface RecallRow {
+	turnId: number;
+	entry: TurnRecallEntry;
+}
+
+/** The mutable in-memory state free functions operate on. */
+export interface MemoryTurnStoreCtx {
+	turns: Map<number, TurnRow>;
+	recall: RecallRow[];
+	forks: ConversationFork[];
+	convIndex: Map<ConversationId, number[]>;
+	sessionConv: Map<SessionId, ConversationId>;
+}
+
+// Auto-increment counter — shared by writers (appendTurn/forkConversation) and
+// admin (restore). Module-scoped so a single counter spans the store's life.
+let nextId = 1;
+
+export function allocId(): number {
+	return nextId++;
+}
+
+export function resetIdCounter(): void {
+	nextId = 1;
+}
+
+export function newConversationId(): ConversationId {
+	return `conv_${randomBytes(8).toString("hex")}`;
+}
+
+export function normalizeSessionId(sid: SessionId): SessionId {
+	return sid.replace(/-.*$/, "");
+}

package/src/store/turns/memory-store/read.ts

@@ -0,0 +1,172 @@
+/**
+ * read.ts — TurnReader method bodies for InMemoryTurnStore (extracted from
+ * memory-store.ts). Free functions operating on a MemoryTurnStoreCtx; the
+ * shell class delegates here. Mirrors sqlite-store/read.ts.
+ */
+import type {
+	ConversationFork,
+	ConversationId,
+	ConversationStats,
+	TurnEntry,
+	TurnFilter,
+	TurnId,
+	TurnRecallEntry,
+} from "../types.js";
+import { normalizeSessionId, type MemoryTurnStoreCtx } from "./ctx.js";
+
+export function query(ctx: MemoryTurnStoreCtx, filter: TurnFilter): TurnEntry[] {
+	let results = [...ctx.turns.values()].map((r) => r.entry);
+
+	if (filter.conversationId !== undefined) {
+		results = results.filter(
+			(t) => t.conversationId === filter.conversationId,
+		);
+	}
+	if (filter.sessionId !== undefined) {
+		results = results.filter(
+			(t) =>
+				normalizeSessionId(t.sessionId) ===
+				normalizeSessionId(filter.sessionId!),
+		);
+	}
+	if (filter.sinceMs !== undefined) {
+		results = results.filter((t) => t.endedAt >= filter.sinceMs!);
+	}
+	if (filter.untilMs !== undefined) {
+		results = results.filter((t) => t.endedAt <= filter.untilMs!);
+	}
+	if (filter.pressureBand !== undefined) {
+		results = results.filter((t) => t.pressureBand === filter.pressureBand);
+	}
+
+	results.sort((a, b) => a.endedAt - b.endedAt);
+
+	const offset = filter.offset ?? 0;
+	const limit = filter.limit ?? 1000;
+	return results.slice(offset, offset + limit);
+}
+
+export function getTurn(
+	ctx: MemoryTurnStoreCtx,
+	turnId: TurnId,
+): TurnEntry | undefined {
+	const row = ctx.turns.get(Number(turnId));
+	return row ? { ...row.entry, epochId: row.epochId } : undefined;
+}
+
+export function getTurnByIndex(
+	ctx: MemoryTurnStoreCtx,
+	conversationId: ConversationId,
+	turnIndex: number,
+): TurnEntry | undefined {
+	const ids = ctx.convIndex.get(conversationId) ?? [];
+	for (const id of ids) {
+		const row = ctx.turns.get(id);
+		if (row && row.entry.turnIndex === turnIndex) {
+			return { ...row.entry, epochId: row.epochId };
+		}
+	}
+	return undefined;
+}
+
+export function listRecall(
+	ctx: MemoryTurnStoreCtx,
+	turnId: TurnId,
+): TurnRecallEntry[] {
+	return ctx.recall
+		.filter((r) => r.turnId === Number(turnId))
+		.map((r) => r.entry)
+		.sort((a, b) => b.score - a.score);
+}
+
+export function listRecallByIndex(
+	ctx: MemoryTurnStoreCtx,
+	conversationId: ConversationId,
+	turnIndex: number,
+): TurnRecallEntry[] {
+	const turn = getTurnByIndex(ctx, conversationId, turnIndex);
+	if (!turn) return [];
+	// Resolve the numeric row id for this turn via the convIndex.
+	const ids = ctx.convIndex.get(conversationId) ?? [];
+	for (const id of ids) {
+		const row = ctx.turns.get(id);
+		if (row && row.entry.turnIndex === turnIndex) {
+			return listRecall(ctx, String(id));
+		}
+	}
+	return [];
+}
+
+export function listForks(
+	ctx: MemoryTurnStoreCtx,
+	conversationId: ConversationId,
+): ConversationFork[] {
+	return ctx.forks
+		.filter((f) => f.parentConversationId === conversationId)
+		.sort((a, b) => a.createdAt - b.createdAt);
+}
+
+export function countTurns(
+	ctx: MemoryTurnStoreCtx,
+	conversationId: ConversationId,
+): number {
+	const ids = ctx.convIndex.get(conversationId);
+	return ids?.length ?? 0;
+}
+
+export function conversationStats(
+	ctx: MemoryTurnStoreCtx,
+	conversationId: ConversationId,
+): ConversationStats {
+	const ids = ctx.convIndex.get(conversationId) ?? [];
+	const entries = ids
+		.map((id) => ctx.turns.get(id)?.entry)
+		.filter((e): e is TurnEntry => e !== undefined);
+
+	if (entries.length === 0) {
+		return {
+			turnCount: 0,
+			firstTurnAt: 0,
+			lastTurnAt: 0,
+			avgCtxPercent: 0,
+			pressureBands: {},
+		};
+	}
+
+	let ctxSum = 0;
+	let ctxCount = 0;
+	const bands: Record<string, number> = {};
+
+	for (const e of entries) {
+		if (e.ctxPercent !== undefined) {
+			ctxSum += e.ctxPercent;
+			ctxCount++;
+		}
+		if (e.pressureBand)
+			bands[e.pressureBand] = (bands[e.pressureBand] ?? 0) + 1;
+	}
+
+	return {
+		turnCount: entries.length,
+		firstTurnAt: entries[0].endedAt,
+		lastTurnAt: entries[entries.length - 1].endedAt,
+		avgCtxPercent: ctxCount > 0 ? ctxSum / ctxCount : 0,
+		pressureBands: bands,
+	};
+}
+
+export function nextTurnIndexFor(
+	ctx: MemoryTurnStoreCtx,
+	conversationId: ConversationId,
+): number {
+	let max = -1;
+	for (const [, row] of ctx.turns) {
+		if (
+			row.entry.conversationId === conversationId &&
+			row.entry.turnIndex > max
+		) {
+			max = row.entry.turnIndex;
+		}
+	}
+	return max + 1;
+}

package/src/store/turns/memory-store/write.ts

@@ -0,0 +1,126 @@
+/**
+ * write.ts — TurnWriter method bodies for InMemoryTurnStore (extracted from
+ * memory-store.ts). Free functions operating on a MemoryTurnStoreCtx; the
+ * shell class delegates here. Mirrors sqlite-store/write.ts.
+ */
+import {
+	DuplicateTurnError,
+	type ConversationId,
+	type SessionId,
+	type TurnEntry,
+	type TurnId,
+	type TurnRecallEntry,
+} from "../types.js";
+import {
+	allocId,
+	newConversationId,
+	normalizeSessionId,
+	type MemoryTurnStoreCtx,
+} from "./ctx.js";
+
+export function appendTurn(
+	ctx: MemoryTurnStoreCtx,
+	entry: TurnEntry,
+): TurnId {
+	// Check for duplicate (conversationId, turnIndex)
+	for (const [, row] of ctx.turns) {
+		if (
+			row.entry.conversationId === entry.conversationId &&
+			row.entry.turnIndex === entry.turnIndex
+		) {
+			throw new DuplicateTurnError(entry.conversationId, entry.turnIndex);
+		}
+	}
+	const id = allocId();
+	const sid = normalizeSessionId(entry.sessionId);
+	const normalized = { ...entry, sessionId: sid };
+	ctx.turns.set(id, { id, entry: normalized });
+
+	// Update indices
+	const convIds = ctx.convIndex.get(entry.conversationId) ?? [];
+	convIds.push(id);
+	ctx.convIndex.set(entry.conversationId, convIds);
+
+	ctx.sessionConv.set(sid, entry.conversationId);
+
+	return String(id);
+}
+
+export function appendRecall(ctx: MemoryTurnStoreCtx, entry: TurnRecallEntry): void {
+	// De-dup by (turn_id, checkpoint_id)
+	const exists = ctx.recall.some(
+		(r) =>
+			r.turnId === Number(entry.turnId) &&
+			r.entry.checkpointId === entry.checkpointId,
+	);
+	if (!exists) {
+		ctx.recall.push({ turnId: Number(entry.turnId), entry });
+	}
+}
+
+export function ensureConversationId(
+	ctx: MemoryTurnStoreCtx,
+	sessionId: SessionId,
+): ConversationId {
+	const sid = normalizeSessionId(sessionId);
+	const existing = ctx.sessionConv.get(sid);
+	if (existing) return existing;
+	// Generate and store a new conversation ID for this session
+	const convId = newConversationId();
+	ctx.sessionConv.set(sid, convId);
+	return convId;
+}
+
+export function forkConversation(
+	ctx: MemoryTurnStoreCtx,
+	parentId: ConversationId,
+	forkTurnIndex: number,
+): ConversationId {
+	const childId = newConversationId();
+	const now = Date.now();
+
+	// 1. Record the fork lineage
+	ctx.forks.push({
+		parentConversationId: parentId,
+		childConversationId: childId,
+		forkTurnIndex,
+		createdAt: now,
+	});
+
+	// 2. Find the parent's turn at forkTurnIndex
+	const parentTurnIds = ctx.convIndex.get(parentId) ?? [];
+	const parentTurnRow = parentTurnIds
+		.map((id) => ctx.turns.get(id))
+		.find((r) => r?.entry.turnIndex === forkTurnIndex);
+
+	if (!parentTurnRow) return childId; // no parent turn — nothing to seed
+
+	// 3. Create a seed turn in the child conversation
+	const seedId = allocId();
+	const seedEntry: TurnEntry = {
+		conversationId: childId,
+		sessionId: `fork_${childId}`,
+		turnIndex: 0,
+		role: "system",
+		endedAt: now,
+	};
+	ctx.turns.set(seedId, { id: seedId, entry: seedEntry });
+	ctx.convIndex.set(childId, [seedId]);
+
+	// 4. Copy the parent's recall entries into the child's seed turn
+	const parentRecall = ctx.recall.filter((r) => r.turnId === parentTurnRow.id);
+	for (const r of parentRecall) {
+		ctx.recall.push({
+			turnId: seedId,
+			entry: {
+				turnId: String(seedId),
+				checkpointId: r.entry.checkpointId,
+				score: r.entry.score,
+				source: r.entry.source,
+				raptorLevel: r.entry.raptorLevel,
+			},
+		});
+	}
+
+	return childId;
+}