@caupulican/pi-adaptative 0.78.2 → 0.78.3

package/dist/core/session-manager.js

@@ -1,8 +1,10 @@
 import { uuidv7 } from "@earendil-works/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, closeSync, createReadStream, existsSync, mkdirSync, openSync, readdirSync, readSync, statSync, writeFileSync, } from "fs";
+import { readdir, stat } from "fs/promises";
 import { join, resolve } from "path";
+import { createInterface } from "readline";
+import { StringDecoder } from "string_decoder";
 import { getAgentDir as getDefaultAgentDir, getSessionsDir } from "../config.js";
 import { normalizePath, resolvePath } from "../utils/paths.js";
 import { createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage, } from "./messages.js";
@@ -215,12 +217,24 @@ export function buildSessionContext(entries, leafId, byId) {
  * Compute the default session directory for a cwd.
  * Encodes cwd into a safe directory name under ~/.pi/agent/sessions/.
  */
-function getDefaultSessionDirPath(cwd, agentDir = getDefaultAgentDir()) {
+function getEncodedSessionDirName(cwd) {
+    return `--${encodeURIComponent(resolvePath(cwd))}--`;
+}
+function getLegacySessionDirPath(cwd, agentDir = getDefaultAgentDir()) {
     const resolvedCwd = resolvePath(cwd);
     const resolvedAgentDir = resolvePath(agentDir);
     const safePath = `--${resolvedCwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
     return join(resolvedAgentDir, "sessions", safePath);
 }
+function getDefaultSessionDirPath(cwd, agentDir = getDefaultAgentDir()) {
+    const resolvedAgentDir = resolvePath(agentDir);
+    return join(resolvedAgentDir, "sessions", getEncodedSessionDirName(cwd));
+}
+function getDefaultSessionDirCandidates(cwd, agentDir = getDefaultAgentDir()) {
+    const current = getDefaultSessionDirPath(cwd, agentDir);
+    const legacy = getLegacySessionDirPath(cwd, agentDir);
+    return current === legacy ? [current] : [current, legacy];
+}
 export function getDefaultSessionDir(cwd, agentDir = getDefaultAgentDir()) {
     const sessionDir = getDefaultSessionDirPath(cwd, agentDir);
     if (!existsSync(sessionDir)) {
@@ -228,24 +242,52 @@ export function getDefaultSessionDir(cwd, agentDir = getDefaultAgentDir()) {
     }
     return sessionDir;
 }
+const SESSION_READ_BUFFER_SIZE = 1024 * 1024;
+function parseSessionEntryLine(line) {
+    if (!line.trim())
+        return null;
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        // Skip malformed lines
+        return null;
+    }
+}
 /** 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
+    const fd = openSync(resolvedFilePath, "r");
+    try {
+        const decoder = new StringDecoder("utf8");
+        const buffer = Buffer.allocUnsafe(SESSION_READ_BUFFER_SIZE);
+        let pending = "";
+        while (true) {
+            const bytesRead = readSync(fd, buffer, 0, buffer.length, null);
+            if (bytesRead === 0)
+                break;
+            pending += decoder.write(buffer.subarray(0, bytesRead));
+            let lineStart = 0;
+            let newlineIndex = pending.indexOf("\n", lineStart);
+            while (newlineIndex !== -1) {
+                const entry = parseSessionEntryLine(pending.slice(lineStart, newlineIndex));
+                if (entry)
+                    entries.push(entry);
+                lineStart = newlineIndex + 1;
+                newlineIndex = pending.indexOf("\n", lineStart);
+            }
+            pending = pending.slice(lineStart);
         }
+        pending += decoder.end();
+        const finalEntry = parseSessionEntryLine(pending);
+        if (finalEntry)
+            entries.push(finalEntry);
+    }
+    finally {
+        closeSync(fd);
     }
     // Validate session header
     if (entries.length === 0)
@@ -301,6 +343,24 @@ export function findMostRecentSession(sessionDir, cwd) {
         return null;
     }
 }
+function findMostRecentSessionInDirs(sessionDirs, cwd) {
+    let mostRecent = null;
+    for (const dir of sessionDirs) {
+        const sessionPath = findMostRecentSession(dir, cwd);
+        if (!sessionPath)
+            continue;
+        try {
+            const mtime = statSync(sessionPath).mtime.getTime();
+            if (!mostRecent || mtime > mostRecent.mtime) {
+                mostRecent = { path: sessionPath, mtime };
+            }
+        }
+        catch {
+            // Ignore races/deleted files
+        }
+    }
+    return mostRecent?.path ?? null;
+}
 function isMessageWithContent(message) {
     return typeof message.role === "string" && "content" in message;
 }
@@ -314,73 +374,64 @@ function extractTextContent(message) {
         .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 MAX_SESSION_SEARCH_TEXT_CHARS = 20_000;
+function getMessageActivityTime(entry) {
+    const message = entry.message;
+    if (!isMessageWithContent(message))
+        return undefined;
+    if (message.role !== "user" && message.role !== "assistant")
+        return undefined;
+    const msgTimestamp = message.timestamp;
+    if (typeof msgTimestamp === "number") {
+        return msgTimestamp;
     }
-    const headerTime = typeof header.timestamp === "string" ? new Date(header.timestamp).getTime() : NaN;
-    return !Number.isNaN(headerTime) ? new Date(headerTime) : statsMtime;
+    const t = new Date(entry.timestamp).getTime();
+    return Number.isNaN(t) ? undefined : t;
 }
 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 header = null;
         let messageCount = 0;
         let firstMessage = "";
-        const allMessages = [];
+        let allMessagesText = "";
         let name;
-        for (const entry of entries) {
+        let lastActivityTime;
+        const appendSearchText = (text) => {
+            if (!text || allMessagesText.length >= MAX_SESSION_SEARCH_TEXT_CHARS)
+                return;
+            const prefix = allMessagesText.length === 0 ? "" : " ";
+            const remaining = MAX_SESSION_SEARCH_TEXT_CHARS - allMessagesText.length - prefix.length;
+            if (remaining <= 0)
+                return;
+            allMessagesText += `${prefix}${text.slice(0, remaining)}`;
+        };
+        const rl = createInterface({
+            input: createReadStream(filePath, { encoding: "utf8" }),
+            crlfDelay: Infinity,
+        });
+        for await (const line of rl) {
+            const entry = parseSessionEntryLine(line);
+            if (!entry)
+                continue;
+            if (!header) {
+                if (entry.type !== "session")
+                    return null;
+                header = entry;
+                continue;
+            }
             // Extract session name (use latest, including explicit clears)
             if (entry.type === "session_info") {
-                const infoEntry = entry;
-                name = infoEntry.name?.trim() || undefined;
+                name = entry.name?.trim() || undefined;
+                continue;
             }
             if (entry.type !== "message")
                 continue;
             messageCount++;
+            const activityTime = getMessageActivityTime(entry);
+            if (typeof activityTime === "number") {
+                lastActivityTime = Math.max(lastActivityTime ?? 0, activityTime);
+            }
             const message = entry.message;
             if (!isMessageWithContent(message))
                 continue;
@@ -389,14 +440,21 @@ async function buildSessionInfo(filePath) {
             const textContent = extractTextContent(message);
             if (!textContent)
                 continue;
-            allMessages.push(textContent);
+            appendSearchText(textContent);
             if (!firstMessage && message.role === "user") {
                 firstMessage = textContent;
             }
         }
+        if (!header)
+            return null;
         const cwd = typeof header.cwd === "string" ? header.cwd : "";
         const parentSessionPath = header.parentSession;
-        const modified = getSessionModifiedDate(entries, header, stats.mtime);
+        const headerTime = typeof header.timestamp === "string" ? new Date(header.timestamp).getTime() : NaN;
+        const modified = typeof lastActivityTime === "number" && lastActivityTime > 0
+            ? new Date(lastActivityTime)
+            : !Number.isNaN(headerTime)
+                ? new Date(headerTime)
+                : stats.mtime;
         return {
             path: filePath,
             id: header.id,
@@ -407,7 +465,7 @@ async function buildSessionInfo(filePath) {
             modified,
             messageCount,
             firstMessage: firstMessage || "(no messages)",
-            allMessagesText: allMessages.join(" "),
+            allMessagesText,
         };
     }
     catch {
@@ -448,6 +506,17 @@ async function buildSessionInfosWithConcurrency(files, onLoaded) {
     }
     return results;
 }
+async function countSessionFiles(dir) {
+    if (!existsSync(dir))
+        return 0;
+    try {
+        const dirEntries = await readdir(dir);
+        return dirEntries.filter((f) => f.endsWith(".jsonl")).length;
+    }
+    catch {
+        return 0;
+    }
+}
 async function listSessionsFromDir(dir, onProgress, progressOffset = 0, progressTotal) {
     const sessions = [];
     if (!existsSync(dir)) {
@@ -589,8 +658,15 @@ export class SessionManager {
     _rewriteFile() {
         if (!this.persist || !this.sessionFile)
             return;
-        const content = `${this.fileEntries.map((e) => JSON.stringify(e)).join("\n")}\n`;
-        writeFileSync(this.sessionFile, content);
+        const fd = openSync(this.sessionFile, "w");
+        try {
+            for (const entry of this.fileEntries) {
+                writeFileSync(fd, `${JSON.stringify(entry)}\n`);
+            }
+        }
+        finally {
+            closeSync(fd);
+        }
     }
     isPersisted() {
         return this.persist;
@@ -602,7 +678,7 @@ export class SessionManager {
         return this.sessionDir;
     }
     usesDefaultSessionDir() {
-        return this.sessionDir === getDefaultSessionDirPath(this.cwd);
+        return getDefaultSessionDirCandidates(this.cwd).includes(this.sessionDir);
     }
     getSessionId() {
         return this.sessionId;
@@ -1069,10 +1145,12 @@ export class SessionManager {
      */
     static continueRecent(cwd, sessionDir) {
         const dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd);
-        const filterCwd = sessionDir !== undefined && dir !== getDefaultSessionDirPath(cwd);
-        const mostRecent = findMostRecentSession(dir, filterCwd ? cwd : undefined);
+        const defaultDirs = getDefaultSessionDirCandidates(cwd);
+        const filterCwd = sessionDir !== undefined && !defaultDirs.includes(dir);
+        const searchDirs = sessionDir ? [dir] : defaultDirs;
+        const mostRecent = findMostRecentSessionInDirs(searchDirs, filterCwd ? cwd : undefined);
         if (mostRecent) {
-            return new SessionManager(cwd, dir, mostRecent, true);
+            return new SessionManager(cwd, resolve(mostRecent, ".."), mostRecent, true);
         }
         return new SessionManager(cwd, dir, undefined, true);
     }
@@ -1136,11 +1214,22 @@ export class SessionManager {
      */
     static async list(cwd, sessionDir, onProgress) {
         const dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd);
-        const filterCwd = sessionDir !== undefined && dir !== getDefaultSessionDirPath(cwd);
+        const defaultDirs = getDefaultSessionDirCandidates(cwd);
+        const filterCwd = sessionDir !== undefined && !defaultDirs.includes(dir);
         const resolvedCwd = resolvePath(cwd);
-        const sessions = (await listSessionsFromDir(dir, onProgress)).filter((session) => !filterCwd || sessionCwdMatches(session.cwd, resolvedCwd));
-        sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
-        return sessions;
+        const dirs = sessionDir ? [dir] : defaultDirs;
+        const progressCounts = await Promise.all(dirs.map((candidateDir) => countSessionFiles(candidateDir)));
+        const progressTotal = progressCounts.reduce((sum, count) => sum + count, 0);
+        const allSessions = [];
+        let progressOffset = 0;
+        for (let i = 0; i < dirs.length; i++) {
+            const candidateDir = dirs[i];
+            const sessions = (await listSessionsFromDir(candidateDir, onProgress, progressOffset, progressTotal)).filter((session) => !filterCwd || sessionCwdMatches(session.cwd, resolvedCwd));
+            progressOffset += progressCounts[i];
+            allSessions.push(...sessions);
+        }
+        allSessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+        return allSessions;
     }
     static async listAll(sessionDirOrOnProgress, onProgress) {
         const customSessionDir = typeof sessionDirOrOnProgress === "string" ? normalizePath(sessionDirOrOnProgress) : undefined;