@mariozechner/pi-coding-agent 0.27.4 → 0.27.6

package/dist/core/agent-session.js

@@ -15,10 +15,9 @@
 import { isContextOverflow, supportsXhigh } from "@mariozechner/pi-ai";
 import { getModelsPath } from "../config.js";
 import { executeBash as executeBashCommand } from "./bash-executor.js";
-import { calculateContextTokens, compact, shouldCompact } from "./compaction.js";
+import { calculateContextTokens, compact, prepareCompaction, shouldCompact } from "./compaction.js";
 import { exportSessionToHtml } from "./export-html.js";
 import { getApiKeyForModel, getAvailableModels } from "./model-config.js";
-import { loadSessionFromEntries } from "./session-manager.js";
 import { expandSlashCommand } from "./slash-commands.js";
 // ============================================================================
 // Constants
@@ -370,7 +369,7 @@ export class AgentSession {
      */
     async reset() {
         const previousSessionFile = this.sessionFile;
-        const entries = this.sessionManager.loadEntries();
+        const entries = this.sessionManager.getEntries();
         // Emit before_clear event (can be cancelled)
         if (this._hookRunner?.hasHandlers("session")) {
             const result = (await this._hookRunner.emit({
@@ -561,10 +560,8 @@ export class AgentSession {
      * @param customInstructions Optional instructions for the compaction summary
      */
     async compact(customInstructions) {
-        // Abort any running operation
         this._disconnectFromAgent();
         await this.abort();
-        // Create abort controller
         this._compactionAbortController = new AbortController();
         try {
             if (!this.model) {
@@ -574,16 +571,69 @@ export class AgentSession {
             if (!apiKey) {
                 throw new Error(`No API key for ${this.model.provider}`);
             }
-            const entries = this.sessionManager.loadEntries();
+            const entries = this.sessionManager.getEntries();
             const settings = this.settingsManager.getCompactionSettings();
-            const compactionEntry = await compact(entries, this.model, settings, apiKey, this._compactionAbortController.signal, customInstructions);
+            const preparation = prepareCompaction(entries, settings);
+            if (!preparation) {
+                throw new Error("Already compacted");
+            }
+            // Find previous compaction summary if any
+            let previousSummary;
+            for (let i = entries.length - 1; i >= 0; i--) {
+                if (entries[i].type === "compaction") {
+                    previousSummary = entries[i].summary;
+                    break;
+                }
+            }
+            let compactionEntry;
+            let fromHook = false;
+            if (this._hookRunner?.hasHandlers("session")) {
+                const result = (await this._hookRunner.emit({
+                    type: "session",
+                    entries,
+                    sessionFile: this.sessionFile,
+                    previousSessionFile: null,
+                    reason: "before_compact",
+                    cutPoint: preparation.cutPoint,
+                    previousSummary,
+                    messagesToSummarize: [...preparation.messagesToSummarize],
+                    messagesToKeep: [...preparation.messagesToKeep],
+                    tokensBefore: preparation.tokensBefore,
+                    customInstructions,
+                    model: this.model,
+                    resolveApiKey: this._resolveApiKey,
+                    signal: this._compactionAbortController.signal,
+                }));
+                if (result?.cancel) {
+                    throw new Error("Compaction cancelled");
+                }
+                if (result?.compactionEntry) {
+                    compactionEntry = result.compactionEntry;
+                    fromHook = true;
+                }
+            }
+            if (!compactionEntry) {
+                compactionEntry = await compact(entries, this.model, settings, apiKey, this._compactionAbortController.signal, customInstructions);
+            }
             if (this._compactionAbortController.signal.aborted) {
                 throw new Error("Compaction cancelled");
             }
-            // Save and reload
             this.sessionManager.saveCompaction(compactionEntry);
-            const loaded = loadSessionFromEntries(this.sessionManager.loadEntries());
-            this.agent.replaceMessages(loaded.messages);
+            const newEntries = this.sessionManager.getEntries();
+            const sessionContext = this.sessionManager.buildSessionContext();
+            this.agent.replaceMessages(sessionContext.messages);
+            if (this._hookRunner) {
+                await this._hookRunner.emit({
+                    type: "session",
+                    entries: newEntries,
+                    sessionFile: this.sessionFile,
+                    previousSessionFile: null,
+                    reason: "compact",
+                    compactionEntry,
+                    tokensBefore: compactionEntry.tokensBefore,
+                    fromHook,
+                });
+            }
             return {
                 tokensBefore: compactionEntry.tokensBefore,
                 summary: compactionEntry.summary,
@@ -657,41 +707,89 @@ export class AgentSession {
                 this._emit({ type: "auto_compaction_end", result: null, aborted: false, willRetry: false });
                 return;
             }
-            const entries = this.sessionManager.loadEntries();
-            const compactionEntry = await compact(entries, this.model, settings, apiKey, this._autoCompactionAbortController.signal);
+            const entries = this.sessionManager.getEntries();
+            const preparation = prepareCompaction(entries, settings);
+            if (!preparation) {
+                this._emit({ type: "auto_compaction_end", result: null, aborted: false, willRetry: false });
+                return;
+            }
+            // Find previous compaction summary if any
+            let previousSummary;
+            for (let i = entries.length - 1; i >= 0; i--) {
+                if (entries[i].type === "compaction") {
+                    previousSummary = entries[i].summary;
+                    break;
+                }
+            }
+            let compactionEntry;
+            let fromHook = false;
+            if (this._hookRunner?.hasHandlers("session")) {
+                const hookResult = (await this._hookRunner.emit({
+                    type: "session",
+                    entries,
+                    sessionFile: this.sessionFile,
+                    previousSessionFile: null,
+                    reason: "before_compact",
+                    cutPoint: preparation.cutPoint,
+                    previousSummary,
+                    messagesToSummarize: [...preparation.messagesToSummarize],
+                    messagesToKeep: [...preparation.messagesToKeep],
+                    tokensBefore: preparation.tokensBefore,
+                    customInstructions: undefined,
+                    model: this.model,
+                    resolveApiKey: this._resolveApiKey,
+                    signal: this._autoCompactionAbortController.signal,
+                }));
+                if (hookResult?.cancel) {
+                    this._emit({ type: "auto_compaction_end", result: null, aborted: true, willRetry: false });
+                    return;
+                }
+                if (hookResult?.compactionEntry) {
+                    compactionEntry = hookResult.compactionEntry;
+                    fromHook = true;
+                }
+            }
+            if (!compactionEntry) {
+                compactionEntry = await compact(entries, this.model, settings, apiKey, this._autoCompactionAbortController.signal);
+            }
             if (this._autoCompactionAbortController.signal.aborted) {
                 this._emit({ type: "auto_compaction_end", result: null, aborted: true, willRetry: false });
                 return;
             }
             this.sessionManager.saveCompaction(compactionEntry);
-            const loaded = loadSessionFromEntries(this.sessionManager.loadEntries());
-            this.agent.replaceMessages(loaded.messages);
+            const newEntries = this.sessionManager.getEntries();
+            const sessionContext = this.sessionManager.buildSessionContext();
+            this.agent.replaceMessages(sessionContext.messages);
+            if (this._hookRunner) {
+                await this._hookRunner.emit({
+                    type: "session",
+                    entries: newEntries,
+                    sessionFile: this.sessionFile,
+                    previousSessionFile: null,
+                    reason: "compact",
+                    compactionEntry,
+                    tokensBefore: compactionEntry.tokensBefore,
+                    fromHook,
+                });
+            }
             const result = {
                 tokensBefore: compactionEntry.tokensBefore,
                 summary: compactionEntry.summary,
             };
             this._emit({ type: "auto_compaction_end", result, aborted: false, willRetry });
-            // Auto-retry if needed - use continue() since user message is already in context
             if (willRetry) {
-                // Remove trailing error message from agent state (it's kept in session file for history)
-                // This is needed because continue() requires last message to be user or toolResult
                 const messages = this.agent.state.messages;
                 const lastMsg = messages[messages.length - 1];
                 if (lastMsg?.role === "assistant" && lastMsg.stopReason === "error") {
                     this.agent.replaceMessages(messages.slice(0, -1));
                 }
-                // Use setTimeout to break out of the event handler chain
                 setTimeout(() => {
-                    this.agent.continue().catch(() => {
-                        // Retry failed - silently ignore, user can manually retry
-                    });
+                    this.agent.continue().catch(() => { });
                 }, 100);
             }
         }
         catch (error) {
-            // Compaction failed - emit end event without retry
             this._emit({ type: "auto_compaction_end", result: null, aborted: false, willRetry: false });
-            // If this was overflow recovery and compaction failed, we have a hard stop
             if (reason === "overflow") {
                 throw new Error(`Context overflow: ${error instanceof Error ? error.message : "compaction failed"}. Your input may be too large for the context window.`);
             }
@@ -927,7 +1025,7 @@ export class AgentSession {
      */
     async switchSession(sessionPath) {
         const previousSessionFile = this.sessionFile;
-        const oldEntries = this.sessionManager.loadEntries();
+        const oldEntries = this.sessionManager.getEntries();
         // Emit before_switch event (can be cancelled)
         if (this._hookRunner?.hasHandlers("session")) {
             const result = (await this._hookRunner.emit({
@@ -947,8 +1045,8 @@ export class AgentSession {
         // Set new session
         this.sessionManager.setSessionFile(sessionPath);
         // Reload messages
-        const entries = this.sessionManager.loadEntries();
-        const loaded = loadSessionFromEntries(entries);
+        const entries = this.sessionManager.getEntries();
+        const sessionContext = this.sessionManager.buildSessionContext();
         // Emit session event to hooks
         if (this._hookRunner) {
             this._hookRunner.setSessionFile(sessionPath);
@@ -962,20 +1060,18 @@ export class AgentSession {
         }
         // Emit session event to custom tools
         await this._emitToolSessionEvent("switch", previousSessionFile);
-        this.agent.replaceMessages(loaded.messages);
+        this.agent.replaceMessages(sessionContext.messages);
         // Restore model if saved
-        const savedModel = this.sessionManager.loadModel();
-        if (savedModel) {
+        if (sessionContext.model) {
             const availableModels = (await getAvailableModels()).models;
-            const match = availableModels.find((m) => m.provider === savedModel.provider && m.id === savedModel.modelId);
+            const match = availableModels.find((m) => m.provider === sessionContext.model.provider && m.id === sessionContext.model.modelId);
             if (match) {
                 this.agent.setModel(match);
             }
         }
         // Restore thinking level if saved (setThinkingLevel clamps to model capabilities)
-        const savedThinking = this.sessionManager.loadThinkingLevel();
-        if (savedThinking) {
-            this.setThinkingLevel(savedThinking);
+        if (sessionContext.thinkingLevel) {
+            this.setThinkingLevel(sessionContext.thinkingLevel);
         }
         this._reconnectToAgent();
         return true;
@@ -991,7 +1087,7 @@ export class AgentSession {
      */
     async branch(entryIndex) {
         const previousSessionFile = this.sessionFile;
-        const entries = this.sessionManager.loadEntries();
+        const entries = this.sessionManager.getEntries();
         const selectedEntry = entries[entryIndex];
         if (!selectedEntry || selectedEntry.type !== "message" || selectedEntry.message.role !== "user") {
             throw new Error("Invalid entry index for branching");
@@ -1020,8 +1116,8 @@ export class AgentSession {
             this.sessionManager.setSessionFile(newSessionFile);
         }
         // Reload messages from entries (works for both file and in-memory mode)
-        const newEntries = this.sessionManager.loadEntries();
-        const loaded = loadSessionFromEntries(newEntries);
+        const newEntries = this.sessionManager.getEntries();
+        const sessionContext = this.sessionManager.buildSessionContext();
         // Emit branch event to hooks (after branch completes)
         if (this._hookRunner) {
             this._hookRunner.setSessionFile(newSessionFile);
@@ -1037,7 +1133,7 @@ export class AgentSession {
         // Emit session event to custom tools (with reason "branch")
         await this._emitToolSessionEvent("branch", previousSessionFile);
         if (!skipConversationRestore) {
-            this.agent.replaceMessages(loaded.messages);
+            this.agent.replaceMessages(sessionContext.messages);
         }
         return { selectedText, cancelled: false };
     }
@@ -1045,7 +1141,7 @@ export class AgentSession {
      * Get all user messages from session for branch selector.
      */
     getUserMessagesForBranching() {
-        const entries = this.sessionManager.loadEntries();
+        const entries = this.sessionManager.getEntries();
         const result = [];
         for (let i = 0; i < entries.length; i++) {
             const entry = entries[i];
@@ -1120,7 +1216,8 @@ export class AgentSession {
      * @returns Path to exported file
      */
     exportToHtml(outputPath) {
-        return exportSessionToHtml(this.sessionManager, this.state, outputPath);
+        const themeName = this.settingsManager.getTheme();
+        return exportSessionToHtml(this.sessionManager, this.state, { outputPath, themeName });
     }
     // =========================================================================
     // Utilities
@@ -1172,7 +1269,7 @@ export class AgentSession {
      */
     async _emitToolSessionEvent(reason, previousSessionFile) {
         const event = {
-            entries: this.sessionManager.loadEntries(),
+            entries: this.sessionManager.getEntries(),
             sessionFile: this.sessionFile,
             previousSessionFile,
             reason,