pi-mega-compact 0.21.3 → 0.21.4

package/dist/src/store/turns/memory-store/admin.js

@@ -0,0 +1,119 @@
+import { allocId, normalizeSessionId, resetIdCounter, } from "./ctx.js";
+export function prune(ctx, policy) {
+    const cutoff = Date.now() - policy.maxTurnAgeMs;
+    let turnsRemoved = 0;
+    let recallRemoved = 0;
+    for (const [convId, turnIds] of ctx.convIndex.entries()) {
+        const total = turnIds.length;
+        const canDelete = Math.max(0, total - policy.keepMinPerConversation);
+        if (canDelete === 0)
+            continue;
+        // Find old turns to delete
+        const oldIds = turnIds
+            .filter((id) => {
+            const row = ctx.turns.get(id);
+            return row && row.entry.endedAt < cutoff;
+        })
+            .slice(0, canDelete);
+        for (const id of oldIds) {
+            // Remove recall for this turn, in place (preserve ctx.recall reference)
+            const before = ctx.recall.length;
+            let w = 0;
+            for (let i = 0; i < ctx.recall.length; i++) {
+                if (ctx.recall[i].turnId !== id)
+                    ctx.recall[w++] = ctx.recall[i];
+            }
+            ctx.recall.length = w;
+            recallRemoved += before - ctx.recall.length;
+            ctx.turns.delete(id);
+            turnsRemoved++;
+        }
+        // Update convIndex
+        ctx.convIndex.set(convId, turnIds.filter((id) => ctx.turns.has(id)));
+    }
+    const branchesPreserved = ctx.forks.length;
+    return {
+        turnsRemoved,
+        recallRemoved,
+        branchesPreserved,
+        freedBytes: 0, // in-memory — no file size to measure
+    };
+}
+export function vacuum(_ctx) {
+    // No-op for in-memory store
+}
+export function checkpoint(ctx) {
+    // Emit turns in a stable order (by internal ID / insertion order)
+    const sorted = [...ctx.turns.values()].sort((a, b) => a.id - b.id);
+    const turns = sorted.map((r) => r.entry);
+    // Build mapping: internal ID → 1-based position
+    const idToPos = new Map();
+    for (let i = 0; i < sorted.length; i++) {
+        idToPos.set(sorted[i].id, i + 1);
+    }
+    // Replace recall's turnId with the stable 1-based position
+    const recall = ctx.recall.map((r) => ({
+        turnId: String(idToPos.get(r.turnId) ?? r.turnId),
+        checkpointId: r.entry.checkpointId,
+        score: r.entry.score,
+        source: r.entry.source,
+        raptorLevel: r.entry.raptorLevel,
+    }));
+    return {
+        version: 1,
+        exportedAt: Date.now(),
+        turns,
+        recall,
+        forks: [...ctx.forks],
+    };
+}
+export function restore(ctx, from) {
+    clear(ctx);
+    // Map: 1-based position → new internal ID
+    const posToNewId = new Map();
+    for (let i = 0; i < from.turns.length; i++) {
+        const t = from.turns[i];
+        const newId = allocId();
+        const sid = normalizeSessionId(t.sessionId);
+        const normalized = { ...t, sessionId: sid };
+        ctx.turns.set(newId, { id: newId, entry: normalized });
+        // Update indices
+        const convIds = ctx.convIndex.get(t.conversationId) ?? [];
+        convIds.push(newId);
+        ctx.convIndex.set(t.conversationId, convIds);
+        ctx.sessionConv.set(sid, t.conversationId);
+        posToNewId.set(i + 1, newId);
+    }
+    // Re-attach recall with position-based TurnId → new internal ID mapping
+    for (const r of from.recall) {
+        const targetInternalId = posToNewId.get(Number(r.turnId));
+        if (targetInternalId !== undefined) {
+            ctx.recall.push({
+                turnId: targetInternalId,
+                entry: r,
+            });
+        }
+    }
+    // In-place replace forks (preserve ctx.forks reference)
+    ctx.forks.length = 0;
+    ctx.forks.push(...from.forks);
+}
+export function clear(ctx) {
+    ctx.turns.clear();
+    ctx.recall.length = 0;
+    ctx.forks.length = 0;
+    ctx.convIndex.clear();
+    ctx.sessionConv.clear();
+    resetIdCounter();
+}
+export function stampTurnsEpoch(ctx, sessionId, epochId) {
+    const sid = normalizeSessionId(sessionId);
+    let stamped = 0;
+    for (const row of ctx.turns.values()) {
+        if (row.epochId === undefined && row.entry.sessionId === sid) {
+            row.epochId = epochId;
+            stamped++;
+        }
+    }
+    return stamped;
+}

package/dist/src/store/turns/memory-store/ctx.js

@@ -0,0 +1,28 @@
+/**
+ * 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";
+// 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() {
+    return nextId++;
+}
+export function resetIdCounter() {
+    nextId = 1;
+}
+export function newConversationId() {
+    return `conv_${randomBytes(8).toString("hex")}`;
+}
+export function normalizeSessionId(sid) {
+    return sid.replace(/-.*$/, "");
+}

package/dist/src/store/turns/memory-store/read.js

@@ -0,0 +1,110 @@
+import { normalizeSessionId } from "./ctx.js";
+export function query(ctx, filter) {
+    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, turnId) {
+    const row = ctx.turns.get(Number(turnId));
+    return row ? { ...row.entry, epochId: row.epochId } : undefined;
+}
+export function getTurnByIndex(ctx, conversationId, turnIndex) {
+    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, turnId) {
+    return ctx.recall
+        .filter((r) => r.turnId === Number(turnId))
+        .map((r) => r.entry)
+        .sort((a, b) => b.score - a.score);
+}
+export function listRecallByIndex(ctx, conversationId, turnIndex) {
+    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, conversationId) {
+    return ctx.forks
+        .filter((f) => f.parentConversationId === conversationId)
+        .sort((a, b) => a.createdAt - b.createdAt);
+}
+export function countTurns(ctx, conversationId) {
+    const ids = ctx.convIndex.get(conversationId);
+    return ids?.length ?? 0;
+}
+export function conversationStats(ctx, conversationId) {
+    const ids = ctx.convIndex.get(conversationId) ?? [];
+    const entries = ids
+        .map((id) => ctx.turns.get(id)?.entry)
+        .filter((e) => e !== undefined);
+    if (entries.length === 0) {
+        return {
+            turnCount: 0,
+            firstTurnAt: 0,
+            lastTurnAt: 0,
+            avgCtxPercent: 0,
+            pressureBands: {},
+        };
+    }
+    let ctxSum = 0;
+    let ctxCount = 0;
+    const bands = {};
+    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, conversationId) {
+    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/dist/src/store/turns/memory-store/write.js

@@ -0,0 +1,88 @@
+/**
+ * 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, } from "../types.js";
+import { allocId, newConversationId, normalizeSessionId, } from "./ctx.js";
+export function appendTurn(ctx, entry) {
+    // 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, entry) {
+    // 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, sessionId) {
+    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, parentId, forkTurnIndex) {
+    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 = {
+        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;
+}