pi-mega-compact 0.13.0 → 0.13.2

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

@@ -0,0 +1,111 @@
+import { normalizeSessionId, rowToEntry, rowToRecall, rowToFork } from "./rows.js";
+export function query(ctx, filter) {
+    const { db } = ctx;
+    const clauses = [];
+    const params = [];
+    if (filter.conversationId !== undefined) {
+        clauses.push("conversation_id = ?");
+        params.push(filter.conversationId);
+    }
+    if (filter.sessionId !== undefined) {
+        clauses.push("session_id = ?");
+        params.push(normalizeSessionId(filter.sessionId));
+    }
+    if (filter.sinceMs !== undefined) {
+        clauses.push("ended_at >= ?");
+        params.push(filter.sinceMs);
+    }
+    if (filter.untilMs !== undefined) {
+        clauses.push("ended_at <= ?");
+        params.push(filter.untilMs);
+    }
+    if (filter.pressureBand !== undefined) {
+        clauses.push("pressure_band = ?");
+        params.push(filter.pressureBand);
+    }
+    const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+    const limit = filter.limit ?? 1000;
+    const offset = filter.offset ?? 0;
+    const rows = db
+        .prepare(`SELECT * FROM turns ${where} ORDER BY ended_at ASC LIMIT ? OFFSET ?`)
+        .all(...params, limit, offset);
+    return rows.map(rowToEntry);
+}
+export function getTurn(ctx, turnId) {
+    const { db } = ctx;
+    const row = db
+        .prepare("SELECT * FROM turns WHERE id = ?")
+        .get(Number(turnId));
+    return row ? rowToEntry(row) : undefined;
+}
+export function getTurnByIndex(ctx, conversationId, turnIndex) {
+    const { db } = ctx;
+    const row = db
+        .prepare("SELECT * FROM turns WHERE conversation_id = ? AND turn_index = ?")
+        .get(conversationId, turnIndex);
+    return row ? rowToEntry(row) : undefined;
+}
+export function listRecall(ctx, turnId) {
+    const { db } = ctx;
+    const rows = db
+        .prepare("SELECT * FROM turn_recall WHERE turn_id = ? ORDER BY score DESC")
+        .all(Number(turnId));
+    return rows.map(rowToRecall);
+}
+export function listRecallByIndex(ctx, conversationId, turnIndex) {
+    const { db } = ctx;
+    const row = db
+        .prepare("SELECT id FROM turns WHERE conversation_id = ? AND turn_index = ?")
+        .get(conversationId, turnIndex);
+    if (!row)
+        return [];
+    return listRecall(ctx, String(row.id));
+}
+export function listForks(ctx, conversationId) {
+    const { db } = ctx;
+    const rows = db
+        .prepare("SELECT * FROM conversation_forks WHERE parent_conversation_id = ? ORDER BY created_at ASC")
+        .all(conversationId);
+    return rows.map(rowToFork);
+}
+export function countTurns(ctx, conversationId) {
+    const { db } = ctx;
+    const row = db
+        .prepare("SELECT COUNT(*) as cnt FROM turns WHERE conversation_id = ?")
+        .get(conversationId);
+    return row.cnt;
+}
+export function conversationStats(ctx, conversationId) {
+    const { db } = ctx;
+    const rows = db
+        .prepare("SELECT ended_at, ctx_percent, pressure_band FROM turns WHERE conversation_id = ? ORDER BY ended_at ASC")
+        .all(conversationId);
+    if (rows.length === 0) {
+        return {
+            turnCount: 0,
+            firstTurnAt: 0,
+            lastTurnAt: 0,
+            avgCtxPercent: 0,
+            pressureBands: {},
+        };
+    }
+    let ctxSum = 0;
+    let ctxCount = 0;
+    const bands = {};
+    for (const r of rows) {
+        if (r.ctx_percent !== null) {
+            ctxSum += r.ctx_percent;
+            ctxCount++;
+        }
+        const band = r.pressure_band;
+        if (band)
+            bands[band] = (bands[band] ?? 0) + 1;
+    }
+    return {
+        turnCount: rows.length,
+        firstTurnAt: rows[0].ended_at,
+        lastTurnAt: rows[rows.length - 1].ended_at,
+        avgCtxPercent: ctxCount > 0 ? ctxSum / ctxCount : 0,
+        pressureBands: bands,
+    };
+}

package/dist/src/store/turns/sqlite-store/rows.js

@@ -0,0 +1,42 @@
+/**
+ * rows.ts — row ↔ entry mappers + id helpers (extracted from sqlite-store.ts).
+ */
+import { randomBytes } from "node:crypto";
+export function newConversationId() {
+    return `conv_${randomBytes(8).toString("hex")}`;
+}
+export function normalizeSessionId(sid) {
+    // Matches the existing normalizeSessionId in src/store.ts
+    return sid.replace(/-.*$/, "");
+}
+export function rowToEntry(r) {
+    return {
+        conversationId: r.conversation_id,
+        sessionId: r.session_id,
+        turnIndex: r.turn_index,
+        role: r.role,
+        endedAt: r.ended_at,
+        ctxTokens: r.ctx_tokens ?? undefined,
+        ctxPercent: r.ctx_percent ?? undefined,
+        pressureBand: r.pressure_band ?? undefined,
+        model: r.model ?? undefined,
+        epochId: r.epoch_id ?? undefined,
+    };
+}
+export function rowToRecall(r) {
+    return {
+        turnId: String(r.turn_id),
+        checkpointId: r.checkpoint_id,
+        score: r.score,
+        source: r.source,
+        raptorLevel: r.raptor_level ?? undefined,
+    };
+}
+export function rowToFork(r) {
+    return {
+        parentConversationId: r.parent_conversation_id,
+        childConversationId: r.child_conversation_id,
+        forkTurnIndex: r.fork_turn_index,
+        createdAt: r.created_at,
+    };
+}

package/dist/src/store/turns/sqlite-store/write.js

@@ -0,0 +1,102 @@
+import { DuplicateTurnError } from "../types.js";
+import { newConversationId, normalizeSessionId } from "./rows.js";
+export function appendTurn(ctx, entry) {
+    const { db } = ctx;
+    const sid = normalizeSessionId(entry.sessionId);
+    persistSessionConv(ctx, sid, entry.conversationId);
+    try {
+        db
+            .prepare(`INSERT INTO turns (conversation_id, session_id, turn_index, role, ended_at,
+	                           ctx_tokens, ctx_percent, pressure_band, model, epoch_id)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(entry.conversationId, sid, entry.turnIndex, entry.role, entry.endedAt, entry.ctxTokens ?? null, entry.ctxPercent ?? null, entry.pressureBand ?? null, entry.model ?? null, entry.epochId ?? null);
+    }
+    catch (e) {
+        if (e instanceof Error &&
+            e.message.includes("UNIQUE constraint") &&
+            e.code === "ERR_SQLITE_ERROR") {
+            throw new DuplicateTurnError(entry.conversationId, entry.turnIndex);
+        }
+        throw e;
+    }
+    const row = db
+        .prepare("SELECT id FROM turns WHERE conversation_id = ? AND turn_index = ?")
+        .get(entry.conversationId, entry.turnIndex);
+    return String(row.id);
+}
+/** Persist the session → conversation mapping when a turn is written. */
+function persistSessionConv(ctx, sid, conversationId) {
+    ctx.db
+        .prepare("INSERT OR IGNORE INTO session_conversations (session_id, conversation_id) VALUES (?, ?)")
+        .run(sid, conversationId);
+}
+export function appendRecall(ctx, entry) {
+    const { db } = ctx;
+    db
+        .prepare(`INSERT OR IGNORE INTO turn_recall (turn_id, checkpoint_id, score, source, raptor_level)
+         VALUES (?, ?, ?, ?, ?)`)
+        .run(Number(entry.turnId), entry.checkpointId, entry.score, entry.source, entry.raptorLevel ?? null);
+}
+export function ensureConversationId(ctx, sessionId) {
+    const { db } = ctx;
+    const sid = normalizeSessionId(sessionId);
+    // Check session_conversations table first (persistent mapping)
+    const row = db
+        .prepare("SELECT conversation_id FROM session_conversations WHERE session_id = ?")
+        .get(sid);
+    if (row)
+        return row.conversation_id;
+    // Check if any turn exists for this session (fallback)
+    const turnRow = db
+        .prepare("SELECT conversation_id FROM turns WHERE session_id = ? ORDER BY ended_at DESC LIMIT 1")
+        .get(sid);
+    if (turnRow) {
+        // Persist the mapping so future calls are consistent
+        db
+            .prepare("INSERT OR IGNORE INTO session_conversations (session_id, conversation_id) VALUES (?, ?)")
+            .run(sid, turnRow.conversation_id);
+        return turnRow.conversation_id;
+    }
+    // No turns yet — generate and persist a new conversation id
+    const convId = newConversationId();
+    db
+        .prepare("INSERT OR IGNORE INTO session_conversations (session_id, conversation_id) VALUES (?, ?)")
+        .run(sid, convId);
+    return convId;
+}
+export function forkConversation(ctx, parentId, forkTurnIndex) {
+    const { db } = ctx;
+    const childId = newConversationId();
+    const now = Date.now();
+    // 1. Record the fork lineage
+    db
+        .prepare(`INSERT INTO conversation_forks (parent_conversation_id, child_conversation_id, fork_turn_index, created_at)
+         VALUES (?, ?, ?, ?)`)
+        .run(parentId, childId, forkTurnIndex, now);
+    // 2. Find the parent's turn at forkTurnIndex
+    const parentTurn = db
+        .prepare("SELECT id FROM turns WHERE conversation_id = ? AND turn_index = ?")
+        .get(parentId, forkTurnIndex);
+    if (!parentTurn)
+        return childId; // no parent turn at that index — nothing to seed
+    // 3. Create a seed turn in the child conversation (turnIndex 0, role system)
+    db
+        .prepare(`INSERT INTO turns (conversation_id, session_id, turn_index, role, ended_at)
+         VALUES (?, ?, 0, 'system', ?)`)
+        .run(childId, `fork_${childId}`, now);
+    const childTurnRow = db
+        .prepare("SELECT id FROM turns WHERE conversation_id = ? AND turn_index = 0")
+        .get(childId);
+    if (!childTurnRow)
+        return childId;
+    // 4. Copy the parent's recall entries into the child's seed turn
+    const parentRecall = db
+        .prepare("SELECT checkpoint_id, score, source, raptor_level FROM turn_recall WHERE turn_id = ?")
+        .all(parentTurn.id);
+    const insertRecall = db.prepare(`INSERT OR IGNORE INTO turn_recall (turn_id, checkpoint_id, score, source, raptor_level)
+         VALUES (?, ?, ?, ?, ?)`);
+    for (const r of parentRecall) {
+        insertRecall.run(childTurnRow.id, r.checkpoint_id, r.score, r.source, r.raptor_level ?? null);
+    }
+    return childId;
+}