pi-namespace-patch 0.85.1 → 0.86.1-namespace.1

package/dist/core/session-manager.js

@@ -1,8 +1,8 @@
-import { uuidv7 } from "@earendil-works/pi-ai";
+import { getCurrentSystemMessage, uuidv7, } from "@earendil-works/pi-ai";
 import { randomUUID } from "crypto";
 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 { basename, join, resolve } from "path";
 import { createInterface } from "readline";
 import { StringDecoder } from "string_decoder";
 import { APP_NAME, getAgentDir as getDefaultAgentDir, getSessionsDir } from "../config.js";
@@ -168,6 +168,8 @@ export function sessionEntryToContextMessages(entry) {
         const message = entry.message;
         // Session files are parsed without validation; old versions, forks, or
         // hand-edited files can contain messages with null/missing content.
+        if (message.role === "system" && message.content == null)
+            return [{ ...message, content: "" }];
         if ((message.role === "user" || message.role === "assistant" || message.role === "toolResult") &&
             message.content == null) {
             return [{ ...message, content: [] }];
@@ -183,7 +185,8 @@ export function sessionEntryToContextMessages(entry) {
         return [createBranchSummaryMessage(entry.summary, entry.fromId, entry.timestamp)];
     }
     if (entry.type === "compaction") {
-        return [createCompactionSummaryMessage(entry.summary, entry.tokensBefore, entry.timestamp)];
+        const summary = createCompactionSummaryMessage(entry.summary, entry.tokensBefore, entry.timestamp);
+        return entry.systemMessage ? [entry.systemMessage, summary] : [summary];
     }
     return [];
 }
@@ -217,7 +220,7 @@ export function buildContextEntries(entries, leafId, byId) {
         if (entry.id === compaction.firstKeptEntryId) {
             foundFirstKept = true;
         }
-        if (foundFirstKept) {
+        if (foundFirstKept && !(entry.type === "message" && entry.message.role === "system")) {
             contextEntries.push(entry);
         }
     }
@@ -399,14 +402,16 @@ export function findMostRecentSession(sessionDir, cwd) {
     const resolvedCwd = cwd ? resolvePath(cwd) : undefined;
     try {
         const files = readdirSync(resolvedSessionDir)
-            .filter((f) => f.endsWith(".jsonl"))
-            .map((f) => join(resolvedSessionDir, f))
-            .map((path) => ({ path, header: readSessionHeaderForDiscovery(path) }))
-            .filter((file) => file.header !== null &&
-            (!resolvedCwd || sessionCwdMatches(getSessionHeaderCwd(file.header), resolvedCwd)))
-            .map(({ path }) => ({ path, mtime: statSync(path).mtime }))
-            .sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-        return files[0]?.path || null;
+            .filter((file) => file.endsWith(".jsonl"))
+            .map((file) => join(resolvedSessionDir, file))
+            .map((path) => ({ path, mtime: statSync(path).mtimeMs }))
+            .sort((a, b) => b.mtime - a.mtime);
+        for (const { path } of files) {
+            const header = readSessionHeaderForDiscovery(path);
+            if (header && (!resolvedCwd || sessionCwdMatches(getSessionHeaderCwd(header), resolvedCwd)))
+                return path;
+        }
+        return null;
     }
     catch {
         // Directory access and stat races make recent-session discovery unavailable.
@@ -439,9 +444,9 @@ function getMessageActivityTime(entry) {
     const t = new Date(entry.timestamp).getTime();
     return Number.isNaN(t) ? undefined : t;
 }
-async function buildSessionInfo(filePath) {
+async function buildSessionInfo(filePath, signal, fileStats) {
     try {
-        const stats = await stat(filePath);
+        const stats = fileStats ?? (await stat(filePath));
         let header = null;
         let messageCount = 0;
         let firstMessage = "";
@@ -449,7 +454,7 @@ async function buildSessionInfo(filePath) {
         let name;
         let lastActivityTime;
         const rl = createInterface({
-            input: createReadStream(filePath, { encoding: "utf8" }),
+            input: createReadStream(filePath, { encoding: "utf8", signal }),
             crlfDelay: Infinity,
         });
         for await (const line of rl) {
@@ -510,67 +515,63 @@ async function buildSessionInfo(filePath) {
         };
     }
     catch {
+        signal?.throwIfAborted();
         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();
+const MAX_CONCURRENT_SESSION_DISCOVERY_LOADS = 64;
+const CURRENT_SESSION_LIST_PUBLISH_INTERVAL = 10;
+const ALL_SESSION_LIST_PUBLISH_INTERVAL = 100;
+async function mapWithConcurrency(items, limit, map, signal) {
+    const results = new Array(items.length);
     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);
+    const worker = async () => {
+        while (nextIndex < items.length) {
+            signal?.throwIfAborted();
+            const index = nextIndex++;
+            results[index] = await map(items[index], index);
         }
-    }
+    };
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
     return results;
 }
-async function listSessionsFromDir(dir, onProgress, progressOffset = 0, progressTotal) {
-    const sessions = [];
-    if (!existsSync(dir)) {
-        return sessions;
-    }
+function sortSessionInfos(sessions) {
+    return sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+}
+function buildSessionInfosWithConcurrency(files, onLoaded, signal) {
+    return mapWithConcurrency(files, MAX_CONCURRENT_SESSION_INFO_LOADS, async (file, index) => {
+        const info = await buildSessionInfo(file.path, signal, file.stats);
+        onLoaded(info, index);
+        return info;
+    }, signal);
+}
+async function listSessionsFromDir(dir, onProgress, signal) {
+    signal?.throwIfAborted();
+    if (!existsSync(dir))
+        return [];
     try {
         const dirEntries = await readdir(dir);
-        const files = dirEntries.filter((f) => f.endsWith(".jsonl")).map((f) => join(dir, f));
-        const total = progressTotal ?? files.length;
+        const files = dirEntries
+            .filter((file) => file.endsWith(".jsonl"))
+            .sort((a, b) => b.localeCompare(a))
+            .map((file) => ({ path: join(dir, file) }));
+        const total = files.length;
+        const partialSessions = [];
         let loaded = 0;
-        const results = await buildSessionInfosWithConcurrency(files, () => {
+        const results = await buildSessionInfosWithConcurrency(files, (info) => {
             loaded++;
-            onProgress?.(progressOffset + loaded, total);
-        });
-        for (const info of results) {
-            if (info) {
-                sessions.push(info);
-            }
-        }
+            if (info)
+                partialSessions.push(info);
+            const publishPartial = loaded === 1 || loaded % CURRENT_SESSION_LIST_PUBLISH_INTERVAL === 0 || loaded === files.length;
+            onProgress?.(loaded, total, publishPartial ? sortSessionInfos([...partialSessions]) : undefined);
+        }, signal);
+        return results.filter((info) => info !== null);
     }
     catch {
-        // Return empty list on error
+        signal?.throwIfAborted();
+        return [];
     }
-    return sessions;
 }
 /**
  * Manages conversation sessions as append-only trees stored in JSONL files.
@@ -814,19 +815,38 @@ export class SessionManager {
         this._appendEntry(entry);
         return entry.id;
     }
+    /** Append model-attributed usage that does not participate in LLM context. Returns the appended entry. */
+    appendUsage(kind, provider, model, usage, note) {
+        const entry = {
+            type: "usage",
+            id: generateId(this.byId),
+            parentId: this.leafId,
+            timestamp: new Date().toISOString(),
+            kind,
+            provider,
+            model,
+            usage,
+            ...(note ? { note } : {}),
+        };
+        this._appendEntry(entry);
+        return entry;
+    }
     /** Append a compaction summary as child of current leaf, then advance leaf. Returns entry id. */
     appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromHook, usage) {
+        const timestamp = new Date().toISOString();
+        const systemMessage = getCurrentSystemMessage(this.buildSessionContext().messages);
         const entry = {
             type: "compaction",
             id: generateId(this.byId),
             parentId: this.leafId,
-            timestamp: new Date().toISOString(),
+            timestamp,
             summary,
             firstKeptEntryId,
             tokensBefore,
             details,
             usage,
             fromHook,
+            ...(systemMessage ? { systemMessage: { ...systemMessage, timestamp: new Date(timestamp).getTime() } } : {}),
         };
         this._appendEntry(entry);
         return entry.id;
@@ -1302,67 +1322,110 @@ export class SessionManager {
         }
         return new SessionManager(resolvedTargetCwd, dir, newSessionFile, true);
     }
+    /**
+     * Find an exact session ID without loading transcript bodies.
+     * @param cwd Working directory (used to compute default session directory)
+     * @param id Exact session ID
+     * @param sessionDir Optional session directory. If omitted, uses default (~/.pi/agent/sessions/<encoded-cwd>/).
+     */
+    static findById(cwd, id, sessionDir) {
+        const dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd);
+        const filterCwd = sessionDir !== undefined && dir !== getDefaultSessionDirPath(cwd);
+        const resolvedCwd = resolvePath(cwd);
+        try {
+            for (const file of readdirSync(dir)) {
+                if (!file.endsWith(".jsonl"))
+                    continue;
+                const path = join(dir, file);
+                const header = readSessionHeaderForDiscovery(path);
+                if (header?.id !== id)
+                    continue;
+                if (filterCwd && !sessionCwdMatches(getSessionHeaderCwd(header), resolvedCwd))
+                    continue;
+                return path;
+            }
+        }
+        catch {
+            // Exact session discovery is best-effort, matching list().
+        }
+        return undefined;
+    }
     /**
      * List all sessions for a directory.
      * @param cwd Working directory (used to compute default session directory)
      * @param sessionDir Optional session directory. If omitted, uses default (~/.pi/agent/sessions/<encoded-cwd>/).
      * @param onProgress Optional callback for progress updates (loaded, total)
      */
-    static async list(cwd, sessionDir, onProgress) {
+    static async list(cwd, sessionDir, onProgress, signal) {
         const dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd);
         const filterCwd = sessionDir !== undefined && dir !== getDefaultSessionDirPath(cwd);
         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;
-    }
-    static async listAll(sessionDirOrOnProgress, onProgress) {
+        const includeSession = (session) => !filterCwd || sessionCwdMatches(session.cwd, resolvedCwd);
+        const progress = onProgress
+            ? (loaded, total, partialSessions) => onProgress(loaded, total, partialSessions?.filter(includeSession))
+            : undefined;
+        const sessions = (await listSessionsFromDir(dir, progress, signal)).filter(includeSession);
+        return sortSessionInfos(sessions);
+    }
+    static async listAll(sessionDirOrOnProgress, onProgressOrSignal, signal) {
         const customSessionDir = typeof sessionDirOrOnProgress === "string" ? normalizePath(sessionDirOrOnProgress) : undefined;
-        const progress = typeof sessionDirOrOnProgress === "function" ? sessionDirOrOnProgress : onProgress;
+        const progress = typeof sessionDirOrOnProgress === "function"
+            ? sessionDirOrOnProgress
+            : typeof onProgressOrSignal === "function"
+                ? onProgressOrSignal
+                : undefined;
+        const abortSignal = typeof sessionDirOrOnProgress === "string" || typeof onProgressOrSignal === "function"
+            ? signal
+            : (onProgressOrSignal ?? signal);
+        abortSignal?.throwIfAborted();
         if (customSessionDir) {
-            const sessions = await listSessionsFromDir(customSessionDir, progress);
-            sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
-            return sessions;
+            return sortSessionInfos(await listSessionsFromDir(customSessionDir, progress, abortSignal));
         }
         const sessionsDir = getSessionsDir();
         try {
-            if (!existsSync(sessionsDir)) {
+            if (!existsSync(sessionsDir))
                 return [];
-            }
             const entries = await readdir(sessionsDir, { withFileTypes: true });
             const dirs = entries
                 .filter((entry) => entry.isDirectory() || entry.isSymbolicLink())
                 .map((entry) => join(sessionsDir, entry.name));
-            // Count total files first for accurate progress
-            let totalFiles = 0;
-            const dirFiles = [];
-            for (const dir of dirs) {
+            const dirFiles = await mapWithConcurrency(dirs, MAX_CONCURRENT_SESSION_DISCOVERY_LOADS, async (dir) => {
                 try {
-                    const files = (await readdir(dir)).filter((f) => f.endsWith(".jsonl"));
-                    dirFiles.push(files.map((f) => join(dir, f)));
-                    totalFiles += files.length;
+                    return (await readdir(dir)).filter((file) => file.endsWith(".jsonl")).map((file) => join(dir, file));
                 }
                 catch {
-                    dirFiles.push([]);
+                    return [];
                 }
-            }
-            // Process all files with progress tracking
-            let loaded = 0;
-            const sessions = [];
+            }, abortSignal);
             const allFiles = dirFiles.flat();
-            const results = await buildSessionInfosWithConcurrency(allFiles, () => {
-                loaded++;
-                progress?.(loaded, totalFiles);
-            });
-            for (const info of results) {
-                if (info) {
-                    sessions.push(info);
+            const candidates = await mapWithConcurrency(allFiles, MAX_CONCURRENT_SESSION_DISCOVERY_LOADS, async (path) => {
+                try {
+                    return { path, stats: await stat(path) };
                 }
-            }
-            sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
-            return sessions;
+                catch {
+                    return { path };
+                }
+            }, abortSignal);
+            candidates.sort((a, b) => (b.stats?.mtimeMs ?? Number.NEGATIVE_INFINITY) - (a.stats?.mtimeMs ?? Number.NEGATIVE_INFINITY) ||
+                basename(b.path).localeCompare(basename(a.path)));
+            const totalFiles = candidates.length;
+            let loaded = 0;
+            let firstCandidateLoaded = false;
+            const partialSessions = [];
+            const results = await buildSessionInfosWithConcurrency(candidates, (info, index) => {
+                loaded++;
+                if (index === 0)
+                    firstCandidateLoaded = true;
+                if (info)
+                    partialSessions.push(info);
+                const publishPartial = firstCandidateLoaded &&
+                    (index === 0 || loaded % ALL_SESSION_LIST_PUBLISH_INTERVAL === 0 || loaded === totalFiles);
+                progress?.(loaded, totalFiles, publishPartial ? sortSessionInfos([...partialSessions]) : undefined);
+            }, abortSignal);
+            return sortSessionInfos(results.filter((info) => info !== null));
         }
         catch {
+            abortSignal?.throwIfAborted();
             return [];
         }
     }