@mariozechner/pi-coding-agent 0.25.4 → 0.26.1

package/dist/core/session-manager.js

@@ -1,7 +1,7 @@
 import { randomBytes } from "crypto";
 import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync } from "fs";
 import { join, resolve } from "path";
-import { getAgentDir } from "../config.js";
+import { getAgentDir as getDefaultAgentDir } from "../config.js";
 function uuidv4() {
     const bytes = randomBytes(16);
     bytes[6] = (bytes[6] & 0x0f) | 0x40;
@@ -15,9 +15,6 @@ export const SUMMARY_PREFIX = `The conversation history before this point was co
 `;
 export const SUMMARY_SUFFIX = `
 </summary>`;
-/**
- * Create a user message containing the summary with the standard prefix.
- */
 export function createSummaryMessage(summary) {
     return {
         role: "user",
@@ -25,9 +22,6 @@ export function createSummaryMessage(summary) {
         timestamp: Date.now(),
     };
 }
-/**
- * Parse session file content into entries.
- */
 export function parseSessionEntries(content) {
     const entries = [];
     const lines = content.trim().split("\n");
@@ -44,17 +38,6 @@ export function parseSessionEntries(content) {
     }
     return entries;
 }
-/**
- * Load session from entries, handling compaction events.
- *
- * Algorithm:
- * 1. Find latest compaction event (if any)
- * 2. Keep all entries from firstKeptEntryIndex onwards (extracting messages)
- * 3. Prepend summary as user message
- */
-/**
- * Get the latest compaction entry from session entries, if any.
- */
 export function getLatestCompactionEntry(entries) {
     for (let i = entries.length - 1; i >= 0; i--) {
         if (entries[i].type === "compaction") {
@@ -64,22 +47,19 @@ export function getLatestCompactionEntry(entries) {
     return null;
 }
 export function loadSessionFromEntries(entries) {
-    // Find model and thinking level (always scan all entries)
     let thinkingLevel = "off";
     let model = null;
     for (const entry of entries) {
-        if (entry.type === "session") {
-            thinkingLevel = entry.thinkingLevel;
-            model = { provider: entry.provider, modelId: entry.modelId };
-        }
-        else if (entry.type === "thinking_level_change") {
+        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 };
+        }
     }
-    // Find latest compaction event
     let latestCompactionIndex = -1;
     for (let i = entries.length - 1; i >= 0; i--) {
         if (entries[i].type === "compaction") {
@@ -87,7 +67,6 @@ export function loadSessionFromEntries(entries) {
             break;
         }
     }
-    // No compaction: return all messages
     if (latestCompactionIndex === -1) {
         const messages = [];
         for (const entry of entries) {
@@ -98,7 +77,6 @@ export function loadSessionFromEntries(entries) {
         return { messages, thinkingLevel, model };
     }
     const compactionEvent = entries[latestCompactionIndex];
-    // Extract messages from firstKeptEntryIndex to end (skipping compaction entries)
     const keptMessages = [];
     for (let i = compactionEvent.firstKeptEntryIndex; i < entries.length; i++) {
         const entry = entries[i];
@@ -106,146 +84,137 @@ export function loadSessionFromEntries(entries) {
             keptMessages.push(entry.message);
         }
     }
-    // Build final messages: summary + kept messages
     const messages = [];
     messages.push(createSummaryMessage(compactionEvent.summary));
     messages.push(...keptMessages);
     return { messages, thinkingLevel, model };
 }
+function getSessionDirectory(cwd, agentDir) {
+    const safePath = `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+    const sessionDir = join(agentDir, "sessions", safePath);
+    if (!existsSync(sessionDir)) {
+        mkdirSync(sessionDir, { recursive: true });
+    }
+    return sessionDir;
+}
+function loadEntriesFromFile(filePath) {
+    if (!existsSync(filePath))
+        return [];
+    const content = readFileSync(filePath, "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
+        }
+    }
+    return entries;
+}
+function findMostRecentSession(sessionDir) {
+    try {
+        const files = readdirSync(sessionDir)
+            .filter((f) => f.endsWith(".jsonl"))
+            .map((f) => ({
+            path: join(sessionDir, f),
+            mtime: statSync(join(sessionDir, f)).mtime,
+        }))
+            .sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+        return files[0]?.path || null;
+    }
+    catch {
+        return null;
+    }
+}
 export class SessionManager {
-    sessionId;
-    sessionFile;
+    sessionId = "";
+    sessionFile = "";
     sessionDir;
-    enabled = true;
-    sessionInitialized = false;
-    pendingEntries = [];
-    // In-memory entries for --no-session mode (when enabled=false)
+    cwd;
+    persist;
+    flushed = false;
     inMemoryEntries = [];
-    constructor(continueSession = false, customSessionPath) {
-        this.sessionDir = this.getSessionDirectory();
-        if (customSessionPath) {
-            // Use custom session file path
-            this.sessionFile = resolve(customSessionPath);
-            this.loadSessionId();
-            // If file doesn't exist, loadSessionId() won't set sessionId, so generate one
-            if (!this.sessionId) {
-                this.sessionId = uuidv4();
-            }
-            // Mark as initialized since we're loading an existing session
-            this.sessionInitialized = existsSync(this.sessionFile);
-            // Load entries into memory
-            if (this.sessionInitialized) {
-                this.inMemoryEntries = this.loadEntriesFromFile();
-            }
-        }
-        else if (continueSession) {
-            const mostRecent = this.findMostRecentlyModifiedSession();
-            if (mostRecent) {
-                this.sessionFile = mostRecent;
-                this.loadSessionId();
-                // Mark as initialized since we're loading an existing session
-                this.sessionInitialized = true;
-                // Load entries into memory
-                this.inMemoryEntries = this.loadEntriesFromFile();
-            }
-            else {
-                this.initNewSession();
-            }
+    constructor(cwd, agentDir, sessionFile, persist) {
+        this.cwd = cwd;
+        this.sessionDir = getSessionDirectory(cwd, agentDir);
+        this.persist = persist;
+        if (sessionFile) {
+            this.setSessionFile(sessionFile);
         }
         else {
-            this.initNewSession();
+            this.sessionId = uuidv4();
+            const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+            const sessionFile = join(this.sessionDir, `${timestamp}_${this.sessionId}.jsonl`);
+            this.setSessionFile(sessionFile);
         }
     }
-    /** Disable session saving (for --no-session mode) */
-    disable() {
-        this.enabled = false;
-    }
-    /** Check if session persistence is enabled */
-    isEnabled() {
-        return this.enabled;
-    }
-    getSessionDirectory() {
-        const cwd = process.cwd();
-        // Replace all path separators and colons (for Windows drive letters) with dashes
-        const safePath = `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
-        const configDir = getAgentDir();
-        const sessionDir = join(configDir, "sessions", safePath);
-        if (!existsSync(sessionDir)) {
-            mkdirSync(sessionDir, { recursive: true });
+    /** Switch to a different session file (used for resume and branching) */
+    setSessionFile(sessionFile) {
+        this.sessionFile = resolve(sessionFile);
+        if (existsSync(this.sessionFile)) {
+            this.inMemoryEntries = loadEntriesFromFile(this.sessionFile);
+            const header = this.inMemoryEntries.find((e) => e.type === "session");
+            this.sessionId = header ? header.id : uuidv4();
+            this.flushed = true;
+        }
+        else {
+            this.sessionId = uuidv4();
+            this.inMemoryEntries = [];
+            this.flushed = false;
+            const entry = {
+                type: "session",
+                id: this.sessionId,
+                timestamp: new Date().toISOString(),
+                cwd: this.cwd,
+            };
+            this.inMemoryEntries.push(entry);
         }
-        return sessionDir;
     }
-    initNewSession() {
-        this.sessionId = uuidv4();
-        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-        this.sessionFile = join(this.sessionDir, `${timestamp}_${this.sessionId}.jsonl`);
+    isPersisted() {
+        return this.persist;
     }
-    /** Reset to a fresh session. Clears pending entries and starts a new session file. */
-    reset() {
-        this.pendingEntries = [];
-        this.inMemoryEntries = [];
-        this.sessionInitialized = false;
-        this.initNewSession();
+    getCwd() {
+        return this.cwd;
     }
-    findMostRecentlyModifiedSession() {
-        try {
-            const files = readdirSync(this.sessionDir)
-                .filter((f) => f.endsWith(".jsonl"))
-                .map((f) => ({
-                name: f,
-                path: join(this.sessionDir, f),
-                mtime: statSync(join(this.sessionDir, f)).mtime,
-            }))
-                .sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-            return files[0]?.path || null;
-        }
-        catch {
-            return null;
-        }
+    getSessionId() {
+        return this.sessionId;
     }
-    loadSessionId() {
-        if (!existsSync(this.sessionFile))
-            return;
-        const lines = readFileSync(this.sessionFile, "utf8").trim().split("\n");
-        for (const line of lines) {
-            try {
-                const entry = JSON.parse(line);
-                if (entry.type === "session") {
-                    this.sessionId = entry.id;
-                    return;
-                }
-            }
-            catch {
-                // Skip malformed lines
-            }
-        }
-        this.sessionId = uuidv4();
+    getSessionFile() {
+        return this.sessionFile;
     }
-    startSession(state) {
-        if (this.sessionInitialized)
+    reset() {
+        this.sessionId = uuidv4();
+        this.flushed = false;
+        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+        this.sessionFile = join(this.sessionDir, `${timestamp}_${this.sessionId}.jsonl`);
+        this.inMemoryEntries = [
+            {
+                type: "session",
+                id: this.sessionId,
+                timestamp: new Date().toISOString(),
+                cwd: this.cwd,
+            },
+        ];
+    }
+    _persist(entry) {
+        if (!this.persist)
             return;
-        this.sessionInitialized = true;
-        const entry = {
-            type: "session",
-            id: this.sessionId,
-            timestamp: new Date().toISOString(),
-            cwd: process.cwd(),
-            provider: state.model.provider,
-            modelId: state.model.id,
-            thinkingLevel: state.thinkingLevel,
-        };
-        // Always track in memory
-        this.inMemoryEntries.push(entry);
-        for (const pending of this.pendingEntries) {
-            this.inMemoryEntries.push(pending);
+        const hasAssistant = this.inMemoryEntries.some((e) => e.type === "message" && e.message.role === "assistant");
+        if (!hasAssistant)
+            return;
+        if (!this.flushed) {
+            for (const e of this.inMemoryEntries) {
+                appendFileSync(this.sessionFile, `${JSON.stringify(e)}\n`);
+            }
+            this.flushed = true;
         }
-        this.pendingEntries = [];
-        // Write to file only if enabled
-        if (this.enabled) {
+        else {
             appendFileSync(this.sessionFile, `${JSON.stringify(entry)}\n`);
-            for (const memEntry of this.inMemoryEntries.slice(1)) {
-                appendFileSync(this.sessionFile, `${JSON.stringify(memEntry)}\n`);
-            }
         }
     }
     saveMessage(message) {
@@ -254,17 +223,8 @@ export class SessionManager {
             timestamp: new Date().toISOString(),
             message,
         };
-        if (!this.sessionInitialized) {
-            this.pendingEntries.push(entry);
-        }
-        else {
-            // Always track in memory
-            this.inMemoryEntries.push(entry);
-            // Write to file only if enabled
-            if (this.enabled) {
-                appendFileSync(this.sessionFile, `${JSON.stringify(entry)}\n`);
-            }
-        }
+        this.inMemoryEntries.push(entry);
+        this._persist(entry);
     }
     saveThinkingLevelChange(thinkingLevel) {
         const entry = {
@@ -272,17 +232,8 @@ export class SessionManager {
             timestamp: new Date().toISOString(),
             thinkingLevel,
         };
-        if (!this.sessionInitialized) {
-            this.pendingEntries.push(entry);
-        }
-        else {
-            // Always track in memory
-            this.inMemoryEntries.push(entry);
-            // Write to file only if enabled
-            if (this.enabled) {
-                appendFileSync(this.sessionFile, `${JSON.stringify(entry)}\n`);
-            }
-        }
+        this.inMemoryEntries.push(entry);
+        this._persist(entry);
     }
     saveModelChange(provider, modelId) {
         const entry = {
@@ -291,101 +242,96 @@ export class SessionManager {
             provider,
             modelId,
         };
-        if (!this.sessionInitialized) {
-            this.pendingEntries.push(entry);
-        }
-        else {
-            // Always track in memory
-            this.inMemoryEntries.push(entry);
-            // Write to file only if enabled
-            if (this.enabled) {
-                appendFileSync(this.sessionFile, `${JSON.stringify(entry)}\n`);
-            }
-        }
+        this.inMemoryEntries.push(entry);
+        this._persist(entry);
     }
     saveCompaction(entry) {
-        // Always track in memory
         this.inMemoryEntries.push(entry);
-        // Write to file only if enabled
-        if (this.enabled) {
-            appendFileSync(this.sessionFile, `${JSON.stringify(entry)}\n`);
-        }
+        this._persist(entry);
     }
-    /**
-     * Load session data (messages, model, thinking level) with compaction support.
-     */
     loadSession() {
         const entries = this.loadEntries();
         return loadSessionFromEntries(entries);
     }
-    /**
-     * @deprecated Use loadSession().messages instead
-     */
     loadMessages() {
         return this.loadSession().messages;
     }
-    /**
-     * @deprecated Use loadSession().thinkingLevel instead
-     */
     loadThinkingLevel() {
         return this.loadSession().thinkingLevel;
     }
-    /**
-     * @deprecated Use loadSession().model instead
-     */
     loadModel() {
         return this.loadSession().model;
     }
-    getSessionId() {
-        return this.sessionId;
-    }
-    getSessionFile() {
-        return this.sessionFile;
+    loadEntries() {
+        if (this.inMemoryEntries.length > 0) {
+            return [...this.inMemoryEntries];
+        }
+        else {
+            return loadEntriesFromFile(this.sessionFile);
+        }
     }
-    /**
-     * Load entries directly from the session file (internal helper).
-     */
-    loadEntriesFromFile() {
-        if (!existsSync(this.sessionFile))
-            return [];
-        const content = readFileSync(this.sessionFile, "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);
+    createBranchedSessionFromEntries(entries, branchBeforeIndex) {
+        const newSessionId = uuidv4();
+        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+        const newSessionFile = join(this.sessionDir, `${timestamp}_${newSessionId}.jsonl`);
+        const newEntries = [];
+        for (let i = 0; i < branchBeforeIndex; i++) {
+            const entry = entries[i];
+            if (entry.type === "session") {
+                newEntries.push({
+                    ...entry,
+                    id: newSessionId,
+                    timestamp: new Date().toISOString(),
+                    branchedFrom: this.persist ? this.sessionFile : undefined,
+                });
             }
-            catch {
-                // Skip malformed lines
+            else {
+                newEntries.push(entry);
             }
         }
-        return entries;
-    }
-    /**
-     * Load all entries from the session file or in-memory store.
-     * When file persistence is enabled, reads from file (source of truth for resumed sessions).
-     * When disabled (--no-session), returns in-memory entries.
-     */
-    loadEntries() {
-        // If file persistence is enabled and file exists, read from file
-        if (this.enabled && existsSync(this.sessionFile)) {
-            return this.loadEntriesFromFile();
+        if (this.persist) {
+            for (const entry of newEntries) {
+                appendFileSync(newSessionFile, `${JSON.stringify(entry)}\n`);
+            }
+            return newSessionFile;
         }
-        // Otherwise return in-memory entries (for --no-session mode)
-        return [...this.inMemoryEntries];
-    }
-    /**
-     * Load all sessions for the current directory with metadata
-     */
-    loadAllSessions() {
+        this.inMemoryEntries = newEntries;
+        this.sessionId = newSessionId;
+        return null;
+    }
+    /** Create a new session for the given directory */
+    static create(cwd, agentDir = getDefaultAgentDir()) {
+        return new SessionManager(cwd, agentDir, null, true);
+    }
+    /** Open a specific session file */
+    static open(path, agentDir = getDefaultAgentDir()) {
+        // Extract cwd from session header if possible, otherwise use process.cwd()
+        const entries = loadEntriesFromFile(path);
+        const header = entries.find((e) => e.type === "session");
+        const cwd = header?.cwd ?? process.cwd();
+        return new SessionManager(cwd, agentDir, path, true);
+    }
+    /** Continue the most recent session for the given directory, or create new if none */
+    static continueRecent(cwd, agentDir = getDefaultAgentDir()) {
+        const sessionDir = getSessionDirectory(cwd, agentDir);
+        const mostRecent = findMostRecentSession(sessionDir);
+        if (mostRecent) {
+            return new SessionManager(cwd, agentDir, mostRecent, true);
+        }
+        return new SessionManager(cwd, agentDir, null, true);
+    }
+    /** Create an in-memory session (no file persistence) */
+    static inMemory() {
+        return new SessionManager(process.cwd(), getDefaultAgentDir(), null, false);
+    }
+    /** List all sessions for a directory */
+    static list(cwd, agentDir = getDefaultAgentDir()) {
+        const sessionDir = getSessionDirectory(cwd, agentDir);
         const sessions = [];
         try {
-            const files = readdirSync(this.sessionDir)
+            const files = readdirSync(sessionDir)
                 .filter((f) => f.endsWith(".jsonl"))
-                .map((f) => join(this.sessionDir, f));
+                .map((f) => join(sessionDir, f));
             for (const file of files) {
                 try {
                     const stats = statSync(file);
@@ -399,15 +345,12 @@ export class SessionManager {
                     for (const line of lines) {
                         try {
                             const entry = JSON.parse(line);
-                            // Extract session ID from first session entry
                             if (entry.type === "session" && !sessionId) {
                                 sessionId = entry.id;
                                 created = new Date(entry.timestamp);
                             }
-                            // Count messages and collect all text
                             if (entry.type === "message") {
                                 messageCount++;
-                                // Extract text from user and assistant messages
                                 if (entry.message.role === "user" || entry.message.role === "assistant") {
                                     const textContent = entry.message.content
                                         .filter((c) => c.type === "text")
@@ -415,7 +358,6 @@ export class SessionManager {
                                         .join(" ");
                                     if (textContent) {
                                         allMessages.push(textContent);
-                                        // Get first user message for display
                                         if (!firstMessage && entry.message.role === "user") {
                                             firstMessage = textContent;
                                         }
@@ -437,123 +379,16 @@ export class SessionManager {
                         allMessagesText: allMessages.join(" "),
                     });
                 }
-                catch (error) {
+                catch {
                     // Skip files that can't be read
-                    console.error(`Failed to read session file ${file}:`, error);
                 }
             }
-            // Sort by modified date (most recent first)
             sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
         }
-        catch (error) {
-            console.error("Failed to load sessions:", error);
+        catch {
+            // Return empty list on error
         }
         return sessions;
     }
-    /**
-     * Set the session file to an existing session
-     */
-    setSessionFile(path) {
-        this.sessionFile = path;
-        this.loadSessionId();
-        // Mark as initialized since we're loading an existing session
-        this.sessionInitialized = existsSync(path);
-        // Load entries into memory for consistency
-        if (this.sessionInitialized) {
-            this.inMemoryEntries = this.loadEntriesFromFile();
-        }
-        else {
-            this.inMemoryEntries = [];
-        }
-        this.pendingEntries = [];
-    }
-    /**
-     * Check if we should initialize the session based on message history.
-     * Session is initialized when we have at least 1 user message and 1 assistant message.
-     */
-    shouldInitializeSession(messages) {
-        if (this.sessionInitialized)
-            return false;
-        const userMessages = messages.filter((m) => m.role === "user");
-        const assistantMessages = messages.filter((m) => m.role === "assistant");
-        return userMessages.length >= 1 && assistantMessages.length >= 1;
-    }
-    /**
-     * Create a branched session from a specific message index.
-     * If branchFromIndex is -1, creates an empty session.
-     * Returns the new session file path.
-     */
-    createBranchedSession(state, branchFromIndex) {
-        // Create a new session ID for the branch
-        const newSessionId = uuidv4();
-        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-        const newSessionFile = join(this.sessionDir, `${timestamp}_${newSessionId}.jsonl`);
-        // Write session header
-        const entry = {
-            type: "session",
-            id: newSessionId,
-            timestamp: new Date().toISOString(),
-            cwd: process.cwd(),
-            provider: state.model.provider,
-            modelId: state.model.id,
-            thinkingLevel: state.thinkingLevel,
-            branchedFrom: this.sessionFile,
-        };
-        appendFileSync(newSessionFile, `${JSON.stringify(entry)}\n`);
-        // Write messages up to and including the branch point (if >= 0)
-        if (branchFromIndex >= 0) {
-            const messagesToWrite = state.messages.slice(0, branchFromIndex + 1);
-            for (const message of messagesToWrite) {
-                const messageEntry = {
-                    type: "message",
-                    timestamp: new Date().toISOString(),
-                    message,
-                };
-                appendFileSync(newSessionFile, `${JSON.stringify(messageEntry)}\n`);
-            }
-        }
-        return newSessionFile;
-    }
-    /**
-     * Create a branched session from session entries up to (but not including) a specific entry index.
-     * This preserves compaction events and all entry types.
-     * Returns the new session file path, or null if in --no-session mode (in-memory only).
-     */
-    createBranchedSessionFromEntries(entries, branchBeforeIndex) {
-        const newSessionId = uuidv4();
-        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-        const newSessionFile = join(this.sessionDir, `${timestamp}_${newSessionId}.jsonl`);
-        // Build new entries list (up to but not including branch point)
-        const newEntries = [];
-        for (let i = 0; i < branchBeforeIndex; i++) {
-            const entry = entries[i];
-            if (entry.type === "session") {
-                // Rewrite session header with new ID and branchedFrom
-                newEntries.push({
-                    ...entry,
-                    id: newSessionId,
-                    timestamp: new Date().toISOString(),
-                    branchedFrom: this.enabled ? this.sessionFile : undefined,
-                });
-            }
-            else {
-                // Copy other entries as-is
-                newEntries.push(entry);
-            }
-        }
-        if (this.enabled) {
-            // Write to file
-            for (const entry of newEntries) {
-                appendFileSync(newSessionFile, `${JSON.stringify(entry)}\n`);
-            }
-            return newSessionFile;
-        }
-        else {
-            // In-memory mode: replace inMemoryEntries, no file created
-            this.inMemoryEntries = newEntries;
-            this.sessionId = newSessionId;
-            return null;
-        }
-    }
 }
 //# sourceMappingURL=session-manager.js.map