@opengsd/gsd-pi 1.3.0-dev.65546769 → 1.3.0-dev.72e3af2a

package/packages/pi-coding-agent/dist/core/session-manager.js

@@ -1,457 +1,20 @@
 import { uuidv7 } from "@gsd/pi-agent-core";
-import { randomUUID } from "crypto";
-import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, statSync, writeFileSync, } from "fs";
-import { readdir, readFile, stat } from "fs/promises";
+import { appendFileSync, existsSync, mkdirSync, writeFileSync, } from "fs";
+import { readdir } from "fs/promises";
 import { join, resolve } from "path";
-import { getAgentDir as getDefaultAgentDir, getSessionsDir } from "../config.js";
+import { getSessionsDir } from "../config.js";
 import { normalizePath, resolvePath } from "../utils/paths.js";
-import { createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage, } from "./messages.js";
-export const CURRENT_SESSION_VERSION = 3;
+import { CURRENT_SESSION_VERSION, } from "./session-manager-types.js";
+import { buildSessionContext } from "./session-manager-context.js";
+import { buildSessionInfosWithConcurrency, findMostRecentSession, getDefaultSessionDir, listSessionsFromDir, loadEntriesFromFile, } from "./session-manager-list.js";
+import { generateSessionEntryId, migrateToCurrentVersion, } from "./session-manager-migration.js";
+export { CURRENT_SESSION_VERSION, } from "./session-manager-types.js";
+export { buildSessionContext, getLatestCompactionEntry, } from "./session-manager-context.js";
+export { findMostRecentSession, getDefaultSessionDir, listSessionsFromDir, loadEntriesFromFile, } from "./session-manager-list.js";
+export { migrateSessionEntries, parseSessionEntries, } from "./session-manager-migration.js";
 function createSessionId() {
     return uuidv7();
 }
-/** Generate a unique short ID (8 hex chars, collision-checked) */
-function generateId(byId) {
-    for (let i = 0; i < 100; i++) {
-        const id = randomUUID().slice(0, 8);
-        if (!byId.has(id))
-            return id;
-    }
-    // Fallback to full UUID if somehow we have collisions
-    return randomUUID();
-}
-/** Migrate v1 → v2: add id/parentId tree structure. Mutates in place. */
-function migrateV1ToV2(entries) {
-    const ids = new Set();
-    let prevId = null;
-    for (const entry of entries) {
-        if (entry.type === "session") {
-            entry.version = 2;
-            continue;
-        }
-        entry.id = generateId(ids);
-        entry.parentId = prevId;
-        prevId = entry.id;
-        // Convert firstKeptEntryIndex to firstKeptEntryId for compaction
-        if (entry.type === "compaction") {
-            const comp = entry;
-            if (typeof comp.firstKeptEntryIndex === "number") {
-                const targetEntry = entries[comp.firstKeptEntryIndex];
-                if (targetEntry && targetEntry.type !== "session") {
-                    comp.firstKeptEntryId = targetEntry.id;
-                }
-                delete comp.firstKeptEntryIndex;
-            }
-        }
-    }
-}
-/** Migrate v2 → v3: rename hookMessage role to custom. Mutates in place. */
-function migrateV2ToV3(entries) {
-    for (const entry of entries) {
-        if (entry.type === "session") {
-            entry.version = 3;
-            continue;
-        }
-        // Update message entries with hookMessage role
-        if (entry.type === "message") {
-            const msgEntry = entry;
-            if (msgEntry.message && msgEntry.message.role === "hookMessage") {
-                msgEntry.message.role = "custom";
-            }
-        }
-    }
-}
-/**
- * Run all necessary migrations to bring entries to current version.
- * Mutates entries in place. Returns true if any migration was applied.
- */
-function migrateToCurrentVersion(entries) {
-    const header = entries.find((e) => e.type === "session");
-    const version = header?.version ?? 1;
-    if (version >= CURRENT_SESSION_VERSION)
-        return false;
-    if (version < 2)
-        migrateV1ToV2(entries);
-    if (version < 3)
-        migrateV2ToV3(entries);
-    return true;
-}
-/** Exported for testing */
-export function migrateSessionEntries(entries) {
-    migrateToCurrentVersion(entries);
-}
-/** Exported for compaction.test.ts */
-export function parseSessionEntries(content) {
-    const entries = [];
-    const lines = content.trim().split("\n");
-    for (const line of lines) {
-        if (!line.trim())
-            continue;
-        try {
-            const entry = JSON.parse(line);
-            entries.push(entry);
-        }
-        catch {
-            // Skip malformed lines
-        }
-    }
-    return entries;
-}
-export function getLatestCompactionEntry(entries) {
-    for (let i = entries.length - 1; i >= 0; i--) {
-        if (entries[i].type === "compaction") {
-            return entries[i];
-        }
-    }
-    return null;
-}
-/**
- * Build the session context from entries using tree traversal.
- * If leafId is provided, walks from that entry to root.
- * Handles compaction and branch summaries along the path.
- */
-export function buildSessionContext(entries, leafId, byId) {
-    // Build uuid index if not available
-    if (!byId) {
-        byId = new Map();
-        for (const entry of entries) {
-            byId.set(entry.id, entry);
-        }
-    }
-    // Find leaf
-    let leaf;
-    if (leafId === null) {
-        // Explicitly null - return no messages (navigated to before first entry)
-        return { messages: [], thinkingLevel: "off", model: null };
-    }
-    if (leafId) {
-        leaf = byId.get(leafId);
-    }
-    if (!leaf) {
-        // Fallback to last entry (when leafId is undefined)
-        leaf = entries[entries.length - 1];
-    }
-    if (!leaf) {
-        return { messages: [], thinkingLevel: "off", model: null };
-    }
-    // Walk from leaf to root, collecting path
-    const path = [];
-    let current = leaf;
-    while (current) {
-        path.unshift(current);
-        current = current.parentId ? byId.get(current.parentId) : undefined;
-    }
-    // Extract settings and find compaction
-    let thinkingLevel = "off";
-    let model = null;
-    let compaction = null;
-    for (const entry of path) {
-        if (entry.type === "thinking_level_change") {
-            thinkingLevel = entry.thinkingLevel;
-        }
-        else if (entry.type === "model_change") {
-            model = { provider: entry.provider, modelId: entry.modelId };
-        }
-        else if (entry.type === "message" && entry.message.role === "assistant") {
-            model = { provider: entry.message.provider, modelId: entry.message.model };
-        }
-        else if (entry.type === "compaction") {
-            compaction = entry;
-        }
-    }
-    // Build messages and collect corresponding entries
-    // When there's a compaction, we need to:
-    // 1. Emit summary first (entry = compaction)
-    // 2. Emit kept messages (from firstKeptEntryId up to compaction)
-    // 3. Emit messages after compaction
-    const messages = [];
-    const appendMessage = (entry) => {
-        if (entry.type === "message") {
-            messages.push(entry.message);
-        }
-        else if (entry.type === "custom_message") {
-            messages.push(createCustomMessage(entry.customType, entry.content, entry.display, entry.details, entry.timestamp));
-        }
-        else if (entry.type === "branch_summary" && entry.summary) {
-            messages.push(createBranchSummaryMessage(entry.summary, entry.fromId, entry.timestamp));
-        }
-    };
-    if (compaction) {
-        // Emit summary first
-        messages.push(createCompactionSummaryMessage(compaction.summary, compaction.tokensBefore, compaction.timestamp));
-        // Find compaction index in path
-        const compactionIdx = path.findIndex((e) => e.type === "compaction" && e.id === compaction.id);
-        // Emit kept messages (before compaction, starting from firstKeptEntryId)
-        let foundFirstKept = false;
-        for (let i = 0; i < compactionIdx; i++) {
-            const entry = path[i];
-            if (entry.id === compaction.firstKeptEntryId) {
-                foundFirstKept = true;
-            }
-            if (foundFirstKept) {
-                appendMessage(entry);
-            }
-        }
-        // Emit messages after compaction
-        for (let i = compactionIdx + 1; i < path.length; i++) {
-            const entry = path[i];
-            appendMessage(entry);
-        }
-    }
-    else {
-        // No compaction - emit all messages, handle branch summaries and custom messages
-        for (const entry of path) {
-            appendMessage(entry);
-        }
-    }
-    return { messages, thinkingLevel, model };
-}
-/**
- * Compute the default session directory for a cwd.
- * Encodes cwd into a safe directory name under ~/.pi/agent/sessions/.
- */
-export function getDefaultSessionDir(cwd, agentDir = getDefaultAgentDir()) {
-    const resolvedCwd = resolvePath(cwd);
-    const resolvedAgentDir = resolvePath(agentDir);
-    const safePath = `--${resolvedCwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
-    const sessionDir = join(resolvedAgentDir, "sessions", safePath);
-    if (!existsSync(sessionDir)) {
-        mkdirSync(sessionDir, { recursive: true });
-    }
-    return sessionDir;
-}
-/** Exported for testing */
-export function loadEntriesFromFile(filePath) {
-    const resolvedFilePath = normalizePath(filePath);
-    if (!existsSync(resolvedFilePath))
-        return [];
-    const content = readFileSync(resolvedFilePath, "utf8");
-    const entries = [];
-    const lines = content.trim().split("\n");
-    for (const line of lines) {
-        if (!line.trim())
-            continue;
-        try {
-            const entry = JSON.parse(line);
-            entries.push(entry);
-        }
-        catch {
-            // Skip malformed lines
-        }
-    }
-    // Validate session header
-    if (entries.length === 0)
-        return entries;
-    const header = entries[0];
-    if (header.type !== "session" || typeof header.id !== "string") {
-        return [];
-    }
-    return entries;
-}
-function isValidSessionFile(filePath) {
-    try {
-        const fd = openSync(filePath, "r");
-        const buffer = Buffer.alloc(512);
-        const bytesRead = readSync(fd, buffer, 0, 512, 0);
-        closeSync(fd);
-        const firstLine = buffer.toString("utf8", 0, bytesRead).split("\n")[0];
-        if (!firstLine)
-            return false;
-        const header = JSON.parse(firstLine);
-        return header.type === "session" && typeof header.id === "string";
-    }
-    catch {
-        return false;
-    }
-}
-/** Exported for testing */
-export function findMostRecentSession(sessionDir) {
-    const resolvedSessionDir = normalizePath(sessionDir);
-    try {
-        const files = readdirSync(resolvedSessionDir)
-            .filter((f) => f.endsWith(".jsonl"))
-            .map((f) => join(resolvedSessionDir, f))
-            .filter(isValidSessionFile)
-            .map((path) => ({ path, mtime: statSync(path).mtime }))
-            .sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-        return files[0]?.path || null;
-    }
-    catch {
-        return null;
-    }
-}
-function isMessageWithContent(message) {
-    return typeof message.role === "string" && "content" in message;
-}
-function extractTextContent(message) {
-    const content = message.content;
-    if (typeof content === "string") {
-        return content;
-    }
-    return content
-        .filter((block) => block.type === "text")
-        .map((block) => block.text)
-        .join(" ");
-}
-function getLastActivityTime(entries) {
-    let lastActivityTime;
-    for (const entry of entries) {
-        if (entry.type !== "message")
-            continue;
-        const message = entry.message;
-        if (!isMessageWithContent(message))
-            continue;
-        if (message.role !== "user" && message.role !== "assistant")
-            continue;
-        const msgTimestamp = message.timestamp;
-        if (typeof msgTimestamp === "number") {
-            lastActivityTime = Math.max(lastActivityTime ?? 0, msgTimestamp);
-            continue;
-        }
-        const entryTimestamp = entry.timestamp;
-        if (typeof entryTimestamp === "string") {
-            const t = new Date(entryTimestamp).getTime();
-            if (!Number.isNaN(t)) {
-                lastActivityTime = Math.max(lastActivityTime ?? 0, t);
-            }
-        }
-    }
-    return lastActivityTime;
-}
-function getSessionModifiedDate(entries, header, statsMtime) {
-    const lastActivityTime = getLastActivityTime(entries);
-    if (typeof lastActivityTime === "number" && lastActivityTime > 0) {
-        return new Date(lastActivityTime);
-    }
-    const headerTime = typeof header.timestamp === "string" ? new Date(header.timestamp).getTime() : NaN;
-    return !Number.isNaN(headerTime) ? new Date(headerTime) : statsMtime;
-}
-async function buildSessionInfo(filePath) {
-    try {
-        const content = await readFile(filePath, "utf8");
-        const entries = [];
-        const lines = content.trim().split("\n");
-        for (const line of lines) {
-            if (!line.trim())
-                continue;
-            try {
-                entries.push(JSON.parse(line));
-            }
-            catch {
-                // Skip malformed lines
-            }
-        }
-        if (entries.length === 0)
-            return null;
-        const header = entries[0];
-        if (header.type !== "session")
-            return null;
-        const stats = await stat(filePath);
-        let messageCount = 0;
-        let firstMessage = "";
-        const allMessages = [];
-        let name;
-        for (const entry of entries) {
-            // Extract session name (use latest, including explicit clears)
-            if (entry.type === "session_info") {
-                const infoEntry = entry;
-                name = infoEntry.name?.trim() || undefined;
-            }
-            if (entry.type !== "message")
-                continue;
-            messageCount++;
-            const message = entry.message;
-            if (!isMessageWithContent(message))
-                continue;
-            if (message.role !== "user" && message.role !== "assistant")
-                continue;
-            const textContent = extractTextContent(message);
-            if (!textContent)
-                continue;
-            allMessages.push(textContent);
-            if (!firstMessage && message.role === "user") {
-                firstMessage = textContent;
-            }
-        }
-        const cwd = typeof header.cwd === "string" ? header.cwd : "";
-        const parentSessionPath = header.parentSession;
-        const modified = getSessionModifiedDate(entries, header, stats.mtime);
-        return {
-            path: filePath,
-            id: header.id,
-            cwd,
-            name,
-            parentSessionPath,
-            created: new Date(header.timestamp),
-            modified,
-            messageCount,
-            firstMessage: firstMessage || "(no messages)",
-            allMessagesText: allMessages.join(" "),
-        };
-    }
-    catch {
-        return null;
-    }
-}
-const MAX_CONCURRENT_SESSION_INFO_LOADS = 10;
-async function buildSessionInfosWithConcurrency(files, onLoaded) {
-    const results = new Array(files.length).fill(null);
-    const inFlight = new Set();
-    let nextIndex = 0;
-    const startNext = () => {
-        const index = nextIndex++;
-        const file = files[index];
-        if (!file)
-            return;
-        let task;
-        task = buildSessionInfo(file)
-            .then((info) => {
-            results[index] = info;
-        })
-            .catch(() => {
-            results[index] = null;
-        })
-            .finally(() => {
-            inFlight.delete(task);
-            onLoaded();
-        });
-        inFlight.add(task);
-    };
-    while (nextIndex < files.length || inFlight.size > 0) {
-        while (nextIndex < files.length && inFlight.size < MAX_CONCURRENT_SESSION_INFO_LOADS) {
-            startNext();
-        }
-        if (inFlight.size > 0) {
-            await Promise.race(inFlight);
-        }
-    }
-    return results;
-}
-async function listSessionsFromDir(dir, onProgress, progressOffset = 0, progressTotal) {
-    const sessions = [];
-    if (!existsSync(dir)) {
-        return sessions;
-    }
-    try {
-        const dirEntries = await readdir(dir);
-        const files = dirEntries.filter((f) => f.endsWith(".jsonl")).map((f) => join(dir, f));
-        const total = progressTotal ?? files.length;
-        let loaded = 0;
-        const results = await buildSessionInfosWithConcurrency(files, () => {
-            loaded++;
-            onProgress?.(progressOffset + loaded, total);
-        });
-        for (const info of results) {
-            if (info) {
-                sessions.push(info);
-            }
-        }
-    }
-    catch {
-        // Return empty list on error
-    }
-    return sessions;
-}
 /**
  * Manages conversation sessions as append-only trees stored in JSONL files.
  *
@@ -613,7 +176,7 @@ export class SessionManager {
     appendMessage(message) {
         const entry = {
             type: "message",
-            id: generateId(this.byId),
+            id: generateSessionEntryId(this.byId),
             parentId: this.leafId,
             timestamp: new Date().toISOString(),
             message,
@@ -625,7 +188,7 @@ export class SessionManager {
     appendThinkingLevelChange(thinkingLevel) {
         const entry = {
             type: "thinking_level_change",
-            id: generateId(this.byId),
+            id: generateSessionEntryId(this.byId),
             parentId: this.leafId,
             timestamp: new Date().toISOString(),
             thinkingLevel,
@@ -637,7 +200,7 @@ export class SessionManager {
     appendModelChange(provider, modelId) {
         const entry = {
             type: "model_change",
-            id: generateId(this.byId),
+            id: generateSessionEntryId(this.byId),
             parentId: this.leafId,
             timestamp: new Date().toISOString(),
             provider,
@@ -650,7 +213,7 @@ export class SessionManager {
     appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromHook) {
         const entry = {
             type: "compaction",
-            id: generateId(this.byId),
+            id: generateSessionEntryId(this.byId),
             parentId: this.leafId,
             timestamp: new Date().toISOString(),
             summary,
@@ -668,7 +231,7 @@ export class SessionManager {
             type: "custom",
             customType,
             data,
-            id: generateId(this.byId),
+            id: generateSessionEntryId(this.byId),
             parentId: this.leafId,
             timestamp: new Date().toISOString(),
         };
@@ -679,7 +242,7 @@ export class SessionManager {
     appendSessionInfo(name) {
         const entry = {
             type: "session_info",
-            id: generateId(this.byId),
+            id: generateSessionEntryId(this.byId),
             parentId: this.leafId,
             timestamp: new Date().toISOString(),
             name: name.trim(),
@@ -715,7 +278,7 @@ export class SessionManager {
             content,
             display,
             details,
-            id: generateId(this.byId),
+            id: generateSessionEntryId(this.byId),
             parentId: this.leafId,
             timestamp: new Date().toISOString(),
         };
@@ -763,7 +326,7 @@ export class SessionManager {
         }
         const entry = {
             type: "label",
-            id: generateId(this.byId),
+            id: generateSessionEntryId(this.byId),
             parentId: this.leafId,
             timestamp: new Date().toISOString(),
             targetId,
@@ -894,7 +457,7 @@ export class SessionManager {
         this.leafId = branchFromId;
         const entry = {
             type: "branch_summary",
-            id: generateId(this.byId),
+            id: generateSessionEntryId(this.byId),
             parentId: branchFromId,
             timestamp: new Date().toISOString(),
             fromId: branchFromId ?? "root",
@@ -946,7 +509,7 @@ export class SessionManager {
             for (const { targetId, label, timestamp: labelTimestamp } of labelsToWrite) {
                 const labelEntry = {
                     type: "label",
-                    id: generateId(new Set(pathEntryIds)),
+                    id: generateSessionEntryId(new Set(pathEntryIds)),
                     parentId,
                     timestamp: labelTimestamp,
                     targetId,
@@ -981,7 +544,7 @@ export class SessionManager {
         for (const { targetId, label, timestamp: labelTimestamp } of labelsToWrite) {
             const labelEntry = {
                 type: "label",
-                id: generateId(new Set([...pathEntryIds, ...labelEntries.map((e) => e.id)])),
+                id: generateSessionEntryId(new Set([...pathEntryIds, ...labelEntries.map((e) => e.id)])),
                 parentId,
                 timestamp: labelTimestamp,
                 targetId,