@mariozechner/pi-coding-agent 0.12.6 → 0.12.8

package/dist/tui/tui-renderer.js

@@ -3,13 +3,16 @@ import * as path from "node:path";
 import { CombinedAutocompleteProvider, Container, Input, Loader, Markdown, ProcessTerminal, Spacer, Text, TruncatedText, TUI, visibleWidth, } from "@mariozechner/pi-tui";
 import { exec } from "child_process";
 import { getChangelogPath, parseChangelog } from "../changelog.js";
+import { calculateContextTokens, compact, shouldCompact } from "../compaction.js";
 import { APP_NAME, getDebugLogPath, getModelsPath, getOAuthPath } from "../config.js";
 import { exportSessionToHtml } from "../export-html.js";
 import { getApiKeyForModel, getAvailableModels, invalidateOAuthCache } from "../model-config.js";
 import { listOAuthProviders, login, logout } from "../oauth/index.js";
+import { getLatestCompactionEntry, loadSessionFromEntries, SUMMARY_PREFIX, SUMMARY_SUFFIX, } from "../session-manager.js";
 import { expandSlashCommand, loadSlashCommands } from "../slash-commands.js";
 import { getEditorTheme, getMarkdownTheme, onThemeChange, setTheme, theme } from "../theme/theme.js";
 import { AssistantMessageComponent } from "./assistant-message.js";
+import { CompactionComponent } from "./compaction.js";
 import { CustomEditor } from "./custom-editor.js";
 import { DynamicBorder } from "./dynamic-border.js";
 import { FooterComponent } from "./footer.js";
@@ -86,6 +89,7 @@ export class TuiRenderer {
         this.editorContainer = new Container(); // Container to hold editor or selector
         this.editorContainer.addChild(this.editor); // Start with editor
         this.footer = new FooterComponent(agent.state);
+        this.footer.setAutoCompactEnabled(this.settingsManager.getCompactionEnabled());
         // Define slash commands
         const thinkingCommand = {
             name: "thinking",
@@ -131,6 +135,14 @@ export class TuiRenderer {
             name: "clear",
             description: "Clear context and start a fresh session",
         };
+        const compactCommand = {
+            name: "compact",
+            description: "Manually compact the session context",
+        };
+        const autocompactCommand = {
+            name: "autocompact",
+            description: "Toggle automatic context compaction",
+        };
         // Load file-based slash commands
         this.fileCommands = loadSlashCommands();
         // Convert file commands to SlashCommand format
@@ -151,6 +163,8 @@ export class TuiRenderer {
             logoutCommand,
             queueCommand,
             clearCommand,
+            compactCommand,
+            autocompactCommand,
             ...fileSlashCommands,
         ], process.cwd(), fdPath);
         this.editor.setAutocompleteProvider(autocompleteProvider);
@@ -322,6 +336,19 @@ export class TuiRenderer {
                 this.editor.setText("");
                 return;
             }
+            // Check for /compact command
+            if (text === "/compact" || text.startsWith("/compact ")) {
+                const customInstructions = text.startsWith("/compact ") ? text.slice(9).trim() : undefined;
+                this.handleCompactCommand(customInstructions);
+                this.editor.setText("");
+                return;
+            }
+            // Check for /autocompact command
+            if (text === "/autocompact") {
+                this.handleAutocompactCommand();
+                this.editor.setText("");
+                return;
+            }
             // Check for /debug command
             if (text === "/debug") {
                 this.handleDebugCommand();
@@ -396,9 +423,39 @@ export class TuiRenderer {
                 if (this.sessionManager.shouldInitializeSession(this.agent.state.messages)) {
                     this.sessionManager.startSession(this.agent.state);
                 }
+                // Check for auto-compaction after assistant messages
+                if (event.message.role === "assistant") {
+                    await this.checkAutoCompaction();
+                }
             }
         });
     }
+    async checkAutoCompaction() {
+        const settings = this.settingsManager.getCompactionSettings();
+        if (!settings.enabled)
+            return;
+        // Get last non-aborted assistant message from agent state
+        const messages = this.agent.state.messages;
+        let lastAssistant = null;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const msg = messages[i];
+            if (msg.role === "assistant") {
+                const assistantMsg = msg;
+                if (assistantMsg.stopReason !== "aborted") {
+                    lastAssistant = assistantMsg;
+                    break;
+                }
+            }
+        }
+        if (!lastAssistant)
+            return;
+        const contextTokens = calculateContextTokens(lastAssistant.usage);
+        const contextWindow = this.agent.state.model.contextWindow;
+        if (!shouldCompact(contextTokens, contextWindow, settings))
+            return;
+        // Trigger auto-compaction
+        await this.executeCompaction(undefined, true);
+    }
     async handleEvent(event, state) {
         if (!this.isInitialized) {
             await this.init();
@@ -422,7 +479,9 @@ export class TuiRenderer {
                 if (event.message.role === "user") {
                     // Check if this is a queued message
                     const userMsg = event.message;
-                    const textBlocks = userMsg.content.filter((c) => c.type === "text");
+                    const textBlocks = typeof userMsg.content === "string"
+                        ? [{ type: "text", text: userMsg.content }]
+                        : userMsg.content.filter((c) => c.type === "text");
                     const messageText = textBlocks.map((c) => c.text).join("");
                     const queuedIndex = this.queuedMessages.indexOf(messageText);
                     if (queuedIndex !== -1) {
@@ -550,7 +609,9 @@ export class TuiRenderer {
         if (message.role === "user") {
             const userMsg = message;
             // Extract text content from content blocks
-            const textBlocks = userMsg.content.filter((c) => c.type === "text");
+            const textBlocks = typeof userMsg.content === "string"
+                ? [{ type: "text", text: userMsg.content }]
+                : userMsg.content.filter((c) => c.type === "text");
             const textContent = textBlocks.map((c) => c.text).join("");
             if (textContent) {
                 const userComponent = new UserMessageComponent(textContent, this.isFirstUserMessage);
@@ -574,17 +635,30 @@ export class TuiRenderer {
         this.footer.updateState(state);
         // Update editor border color based on current thinking level
         this.updateEditorBorderColor();
+        // Get compaction info if any
+        const compactionEntry = getLatestCompactionEntry(this.sessionManager.loadEntries());
         // Render messages
         for (let i = 0; i < state.messages.length; i++) {
             const message = state.messages[i];
             if (message.role === "user") {
                 const userMsg = message;
-                const textBlocks = userMsg.content.filter((c) => c.type === "text");
+                const textBlocks = typeof userMsg.content === "string"
+                    ? [{ type: "text", text: userMsg.content }]
+                    : userMsg.content.filter((c) => c.type === "text");
                 const textContent = textBlocks.map((c) => c.text).join("");
                 if (textContent) {
-                    const userComponent = new UserMessageComponent(textContent, this.isFirstUserMessage);
-                    this.chatContainer.addChild(userComponent);
-                    this.isFirstUserMessage = false;
+                    // Check if this is a compaction summary message
+                    if (textContent.startsWith(SUMMARY_PREFIX) && compactionEntry) {
+                        const summary = textContent.slice(SUMMARY_PREFIX.length, -SUMMARY_SUFFIX.length);
+                        const component = new CompactionComponent(compactionEntry.tokensBefore, summary);
+                        component.setExpanded(this.toolOutputExpanded);
+                        this.chatContainer.addChild(component);
+                    }
+                    else {
+                        const userComponent = new UserMessageComponent(textContent, this.isFirstUserMessage);
+                        this.chatContainer.addChild(userComponent);
+                        this.isFirstUserMessage = false;
+                    }
                 }
             }
             else if (message.role === "assistant") {
@@ -639,6 +713,61 @@ export class TuiRenderer {
             };
         });
     }
+    rebuildChatFromMessages() {
+        // Reset state and re-render messages from agent state
+        this.isFirstUserMessage = true;
+        this.pendingTools.clear();
+        // Get compaction info if any
+        const compactionEntry = getLatestCompactionEntry(this.sessionManager.loadEntries());
+        for (const message of this.agent.state.messages) {
+            if (message.role === "user") {
+                const userMsg = message;
+                const textBlocks = typeof userMsg.content === "string"
+                    ? [{ type: "text", text: userMsg.content }]
+                    : userMsg.content.filter((c) => c.type === "text");
+                const textContent = textBlocks.map((c) => c.text).join("");
+                if (textContent) {
+                    // Check if this is a compaction summary message
+                    if (textContent.startsWith(SUMMARY_PREFIX) && compactionEntry) {
+                        const summary = textContent.slice(SUMMARY_PREFIX.length, -SUMMARY_SUFFIX.length);
+                        const component = new CompactionComponent(compactionEntry.tokensBefore, summary);
+                        component.setExpanded(this.toolOutputExpanded);
+                        this.chatContainer.addChild(component);
+                    }
+                    else {
+                        const userComponent = new UserMessageComponent(textContent, this.isFirstUserMessage);
+                        this.chatContainer.addChild(userComponent);
+                        this.isFirstUserMessage = false;
+                    }
+                }
+            }
+            else if (message.role === "assistant") {
+                const assistantMsg = message;
+                const assistantComponent = new AssistantMessageComponent(assistantMsg);
+                this.chatContainer.addChild(assistantComponent);
+                for (const content of assistantMsg.content) {
+                    if (content.type === "toolCall") {
+                        const component = new ToolExecutionComponent(content.name, content.arguments);
+                        this.chatContainer.addChild(component);
+                        this.pendingTools.set(content.id, component);
+                    }
+                }
+            }
+            else if (message.role === "toolResult") {
+                const component = this.pendingTools.get(message.toolCallId);
+                if (component) {
+                    component.updateResult({
+                        content: message.content,
+                        details: message.details,
+                        isError: message.isError,
+                    });
+                    this.pendingTools.delete(message.toolCallId);
+                }
+            }
+        }
+        this.pendingTools.clear();
+        this.ui.requestRender();
+    }
     handleCtrlC() {
         // Handle Ctrl+C double-press logic
         const now = Date.now();
@@ -771,11 +900,14 @@ export class TuiRenderer {
     }
     toggleToolOutputExpansion() {
         this.toolOutputExpanded = !this.toolOutputExpanded;
-        // Update all tool execution components
+        // Update all tool execution and compaction components
         for (const child of this.chatContainer.children) {
             if (child instanceof ToolExecutionComponent) {
                 child.setExpanded(this.toolOutputExpanded);
             }
+            else if (child instanceof CompactionComponent) {
+                child.setExpanded(this.toolOutputExpanded);
+            }
         }
         this.ui.requestRender();
     }
@@ -795,6 +927,14 @@ export class TuiRenderer {
         this.chatContainer.addChild(new Text(theme.fg("warning", `Warning: ${warningMessage}`), 1, 0));
         this.ui.requestRender();
     }
+    showSuccess(message, detail) {
+        this.chatContainer.addChild(new Spacer(1));
+        const text = detail
+            ? `${theme.fg("success", message)}\n${theme.fg("muted", detail)}`
+            : theme.fg("success", message);
+        this.chatContainer.addChild(new Text(text, 1, 1));
+        this.ui.requestRender();
+    }
     showThinkingSelector() {
         // Create thinking selector with current level
         this.thinkingSelector = new ThinkingSelectorComponent(this.agent.state.thinkingLevel, (level) => {
@@ -945,17 +1085,30 @@ export class TuiRenderer {
         this.ui.setFocus(this.editor);
     }
     showUserMessageSelector() {
-        // Extract all user messages from the current state
+        // Read from session file directly to see ALL historical user messages
+        // (including those before compaction events)
+        const entries = this.sessionManager.loadEntries();
         const userMessages = [];
-        for (let i = 0; i < this.agent.state.messages.length; i++) {
-            const message = this.agent.state.messages[i];
-            if (message.role === "user") {
-                const userMsg = message;
-                const textBlocks = userMsg.content.filter((c) => c.type === "text");
-                const textContent = textBlocks.map((c) => c.text).join("");
-                if (textContent) {
-                    userMessages.push({ index: i, text: textContent });
-                }
+        const getUserMessageText = (content) => {
+            if (typeof content === "string")
+                return content;
+            if (Array.isArray(content)) {
+                return content
+                    .filter((c) => c.type === "text")
+                    .map((c) => c.text)
+                    .join("");
+            }
+            return "";
+        };
+        for (let i = 0; i < entries.length; i++) {
+            const entry = entries[i];
+            if (entry.type !== "message")
+                continue;
+            if (entry.message.role !== "user")
+                continue;
+            const textContent = getUserMessageText(entry.message.content);
+            if (textContent) {
+                userMessages.push({ index: i, text: textContent });
             }
         }
         // Don't show selector if there are no messages or only one message
@@ -966,26 +1119,28 @@ export class TuiRenderer {
             return;
         }
         // Create user message selector
-        this.userMessageSelector = new UserMessageSelectorComponent(userMessages, (messageIndex) => {
+        this.userMessageSelector = new UserMessageSelectorComponent(userMessages, (entryIndex) => {
             // Get the selected user message text to put in the editor
-            const selectedMessage = this.agent.state.messages[messageIndex];
-            const selectedUserMsg = selectedMessage;
-            const textBlocks = selectedUserMsg.content.filter((c) => c.type === "text");
-            const selectedText = textBlocks.map((c) => c.text).join("");
-            // Create a branched session with messages UP TO (but not including) the selected message
-            const newSessionFile = this.sessionManager.createBranchedSession(this.agent.state, messageIndex - 1);
+            const selectedEntry = entries[entryIndex];
+            if (selectedEntry.type !== "message")
+                return;
+            if (selectedEntry.message.role !== "user")
+                return;
+            const selectedText = getUserMessageText(selectedEntry.message.content);
+            // Create a branched session by copying entries up to (but not including) the selected entry
+            const newSessionFile = this.sessionManager.createBranchedSessionFromEntries(entries, entryIndex);
             // Set the new session file as active
             this.sessionManager.setSessionFile(newSessionFile);
-            // Truncate messages in agent state to before the selected message
-            const truncatedMessages = this.agent.state.messages.slice(0, messageIndex);
-            this.agent.replaceMessages(truncatedMessages);
+            // Reload the session
+            const loaded = loadSessionFromEntries(this.sessionManager.loadEntries());
+            this.agent.replaceMessages(loaded.messages);
             // Clear and re-render the chat
             this.chatContainer.clear();
             this.isFirstUserMessage = true;
             this.renderInitialMessages(this.agent.state);
             // Show confirmation message
             this.chatContainer.addChild(new Spacer(1));
-            this.chatContainer.addChild(new Text(theme.fg("dim", `Branched to new session from message ${messageIndex}`), 1, 0));
+            this.chatContainer.addChild(new Text(theme.fg("dim", "Branched to new session"), 1, 0));
             // Put the selected message in the editor
             this.editor.setText(selectedText);
             // Hide selector and show editor again
@@ -1260,6 +1415,109 @@ export class TuiRenderer {
         this.chatContainer.addChild(new Text(theme.fg("accent", "✓ Debug log written") + "\n" + theme.fg("muted", debugLogPath), 1, 1));
         this.ui.requestRender();
     }
+    compactionAbortController = null;
+    /**
+     * Shared logic to execute context compaction.
+     * Handles aborting agent, showing loader, performing compaction, updating session/UI.
+     */
+    async executeCompaction(customInstructions, isAuto = false) {
+        // Unsubscribe first to prevent processing events during compaction
+        this.unsubscribe?.();
+        // Abort and wait for completion
+        this.agent.abort();
+        await this.agent.waitForIdle();
+        // Stop loading animation
+        if (this.loadingAnimation) {
+            this.loadingAnimation.stop();
+            this.loadingAnimation = null;
+        }
+        this.statusContainer.clear();
+        // Create abort controller for compaction
+        this.compactionAbortController = new AbortController();
+        // Set up escape handler during compaction
+        const originalOnEscape = this.editor.onEscape;
+        this.editor.onEscape = () => {
+            if (this.compactionAbortController) {
+                this.compactionAbortController.abort();
+            }
+        };
+        // Show compacting status with loader
+        this.chatContainer.addChild(new Spacer(1));
+        const label = isAuto ? "Auto-compacting context... (esc to cancel)" : "Compacting context... (esc to cancel)";
+        const compactingLoader = new Loader(this.ui, (spinner) => theme.fg("accent", spinner), (text) => theme.fg("muted", text), label);
+        this.statusContainer.addChild(compactingLoader);
+        this.ui.requestRender();
+        try {
+            // Get API key for current model
+            const apiKey = await getApiKeyForModel(this.agent.state.model);
+            if (!apiKey) {
+                throw new Error(`No API key for ${this.agent.state.model.provider}`);
+            }
+            // Perform compaction with abort signal
+            const entries = this.sessionManager.loadEntries();
+            const settings = this.settingsManager.getCompactionSettings();
+            const compactionEntry = await compact(entries, this.agent.state.model, settings, apiKey, this.compactionAbortController.signal, customInstructions);
+            // Check if aborted after compact returned
+            if (this.compactionAbortController.signal.aborted) {
+                throw new Error("Compaction cancelled");
+            }
+            // Save compaction to session
+            this.sessionManager.saveCompaction(compactionEntry);
+            // Reload session
+            const loaded = loadSessionFromEntries(this.sessionManager.loadEntries());
+            this.agent.replaceMessages(loaded.messages);
+            // Rebuild UI
+            this.chatContainer.clear();
+            this.rebuildChatFromMessages();
+            // Add compaction component at current position so user can see/expand the summary
+            const compactionComponent = new CompactionComponent(compactionEntry.tokensBefore, compactionEntry.summary);
+            compactionComponent.setExpanded(this.toolOutputExpanded);
+            this.chatContainer.addChild(compactionComponent);
+            // Update footer with new state (fixes context % display)
+            this.footer.updateState(this.agent.state);
+            // Show success message
+            const successTitle = isAuto ? "✓ Context auto-compacted" : "✓ Context compacted";
+            this.showSuccess(successTitle, `Reduced from ${compactionEntry.tokensBefore.toLocaleString()} tokens`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (message === "Compaction cancelled" || (error instanceof Error && error.name === "AbortError")) {
+                this.showError("Compaction cancelled");
+            }
+            else {
+                this.showError(`Compaction failed: ${message}`);
+            }
+        }
+        finally {
+            // Clean up
+            compactingLoader.stop();
+            this.statusContainer.clear();
+            this.compactionAbortController = null;
+            this.editor.onEscape = originalOnEscape;
+        }
+        // Resubscribe to agent
+        this.subscribeToAgent();
+    }
+    async handleCompactCommand(customInstructions) {
+        // Check if there are any messages to compact
+        const entries = this.sessionManager.loadEntries();
+        const messageCount = entries.filter((e) => e.type === "message").length;
+        if (messageCount < 2) {
+            this.showWarning("Nothing to compact (no messages yet)");
+            return;
+        }
+        await this.executeCompaction(customInstructions, false);
+    }
+    handleAutocompactCommand() {
+        const currentEnabled = this.settingsManager.getCompactionEnabled();
+        const newState = !currentEnabled;
+        this.settingsManager.setCompactionEnabled(newState);
+        this.footer.setAutoCompactEnabled(newState);
+        // Show brief notification (same style as thinking level toggle)
+        this.chatContainer.addChild(new Spacer(1));
+        this.chatContainer.addChild(new Text(theme.fg("dim", `Auto-compaction: ${newState ? "on" : "off"}`), 1, 0));
+        this.ui.requestRender();
+    }
     updatePendingMessagesDisplay() {
         this.pendingMessagesContainer.clear();
         if (this.queuedMessages.length > 0) {