@travisennis/acai 0.0.9 → 0.0.10

package/dist/{repl-new.js → repl/index.js}

@@ -1,16 +1,28 @@
-import { logger } from "./logger.js";
-import { PromptError, processPrompt } from "./mentions.js";
-import { getProjectStatus, } from "./repl/project-status.js";
-import { alert, startProgress, stopProgress } from "./terminal/control.js";
-import style from "./terminal/style.js";
-import { AssistantMessageComponent } from "./tui/components/assistant-message.js";
-import { FooterComponent } from "./tui/components/footer.js";
-import { ThinkingBlockComponent } from "./tui/components/thinking-block.js";
-import { ToolExecutionComponent } from "./tui/components/tool-execution.js";
-import { Welcome } from "./tui/components/welcome.js";
-import { launchEditor } from "./tui/editor-launcher.js";
-import { Container, Editor, Loader, NotificationComponent, ProcessTerminal, Spacer, Text, TUI, UserMessageComponent, } from "./tui/index.js";
-export class NewRepl {
+import { generateRulesFromSession } from "../commands/generate-rules/service.js";
+import { showModelSelector } from "../commands/model/model-panel.js";
+import { showReviewPanel } from "../commands/review/review-panel.js";
+import { ModeManager } from "../modes/manager.js";
+import { processPrompt } from "../prompts/mentions.js";
+import { createUserMessage } from "../sessions/manager.js";
+import { loadSkills } from "../skills/index.js";
+import { alert, setTerminalTitle, startProgress, stopProgress, } from "../terminal/control.js";
+import style from "../terminal/style.js";
+import { AttachmentProvider, CombinedProvider, CommandProvider, FileSearchProvider, SkillProvider, } from "../tui/autocomplete.js";
+import { AssistantMessageComponent } from "../tui/components/assistant-message.js";
+import { FooterComponent } from "../tui/components/footer.js";
+import { ThinkingBlockComponent } from "../tui/components/thinking-block.js";
+import { ToolExecutionComponent } from "../tui/components/tool-execution.js";
+import { Welcome } from "../tui/components/welcome.js";
+import { launchEditor } from "../tui/editor-launcher.js";
+import { Container, Editor, Loader, NotificationComponent, ProcessTerminal, Spacer, Text, TUI, UserMessageComponent, } from "../tui/index.js";
+import { logger } from "../utils/logger.js";
+import { getProjectStatus } from "./project-status.js";
+/**
+ * Interactive Read-Eval-Print Loop that provides the primary user interface
+ * for the AI assistant CLI. Manages the TUI layout, handles keyboard shortcuts,
+ * processes agent events for streaming responses, and coordinates session lifecycle.
+ */
+export class Repl {
     options;
     terminal;
     tui;
@@ -34,6 +46,16 @@ export class NewRepl {
     streamingComponent = null;
     // thinking block tracking
     thinkingBlockComponent = null;
+    // Track all verbose-aware components for re-rendering on toggle
+    allThinkingBlocks = [];
+    allToolExecutions = [];
+    // verbose mode state
+    verboseMode = false;
+    // mode manager
+    modeManager;
+    // ProjectConfig - initialized in init()
+    config;
+    /** Creates a new Repl instance, initializing the TUI layout and components. */
     constructor(options) {
         this.options = options;
         this.terminal = new ProcessTerminal(options.terminalOptions);
@@ -45,7 +67,7 @@ export class NewRepl {
         this.chatContainer = new Container();
         this.statusContainer = new Container();
         this.editorContainer = new Container(); // Container to hold editor or selector
-        this.footer = new FooterComponent(options.modelManager, {
+        this.footer = new FooterComponent(options.modelManager, options.tokenTracker, {
             projectStatus: {
                 path: "",
                 isGitRepository: false,
@@ -55,7 +77,6 @@ export class NewRepl {
             },
             currentContextWindow: 0,
             contextWindow: options.modelManager.getModelMetadata("repl").contextWindow,
-            usage: this.options.tokenTracker.getUsageByApp("repl"),
         });
         this.editorContainer.addChild(this.editor); // Start with editor
         this.editor.onRenderRequested = () => this.tui.requestRender();
@@ -69,17 +90,30 @@ export class NewRepl {
         this.isInitialized = false;
         this.pendingTools = new Map();
         this.tools = options.tools;
-        this.notification = new NotificationComponent("", { r: 64, g: 64, b: 64 }, style.yellow, 1);
+        this.modeManager = new ModeManager();
+        this.notification = new NotificationComponent("", { r: 52, g: 53, b: 65 }, style.yellow, 1, () => this.tui.requestRender());
     }
+    /**
+     * Initializes the REPL by setting up autocomplete,
+     * keyboard handlers, and the TUI component tree.
+     */
     async init() {
         if (this.isInitialized) {
+            this.notification.setMessage("initialized");
             return;
         }
-        // Setup autocomplete for file paths and slash commands
-        const { createDefaultProvider } = await import("./tui/autocomplete.js");
-        const autocompleteProvider = createDefaultProvider([...(await this.options.commands.getCompletions())], this.options.workspace.allowedDirs);
+        // Setup autocomplete for file paths, slash commands, and skills
+        const skills = await loadSkills();
+        const commandsList = await this.options.commands.getCompletions();
+        const autocompleteProvider = new CombinedProvider([
+            new CommandProvider(commandsList),
+            new AttachmentProvider(),
+            new FileSearchProvider(),
+            new SkillProvider(skills.getModelInvocable()),
+        ]);
         this.editor.setAutocompleteProvider(autocompleteProvider);
-        const { promptManager, modelManager, messageHistory, commands, promptHistory, } = this.options;
+        const { promptManager, modelManager, sessionManager, commands, promptHistory, configManager, } = this.options;
+        this.config = await configManager.getConfig();
         // Listen for session title updates
         // messageHistory.on("update-title", (title: string) => {
         //   this.footer.setTitle(title);
@@ -90,16 +124,45 @@ export class NewRepl {
             projectStatus: await getProjectStatus(),
             currentContextWindow: 0,
             contextWindow: modelConfig.contextWindow,
-            usage: this.options.tokenTracker.getUsageByApp("repl"),
+            currentMode: this.modeManager.getDisplayName(),
         });
         this.tui.onCtrlC = () => {
             this.handleCtrlC();
         };
+        this.tui.onCtrlD = () => {
+            this.handleCtrlD();
+        };
+        this.tui.onCtrlO = () => {
+            this.handleCtrlO();
+        };
+        this.tui.onCtrlN = () => {
+            void this.handleCtrlN();
+        };
+        this.tui.onCtrlR = () => {
+            void showReviewPanel(this.tui, this.chatContainer, this.editorContainer, this.editor);
+        };
+        this.tui.onCtrlM = () => {
+            void this.handleCtrlM();
+        };
+        this.tui.onShiftTab = () => {
+            this.modeManager.cycleMode();
+            this.footer.setState({
+                projectStatus: this.footer.getProjectStatus(),
+                currentContextWindow: this.options.sessionManager.getLastTurnContextWindow(),
+                contextWindow: this.options.modelManager.getModelMetadata("repl").contextWindow,
+                currentMode: this.modeManager.getDisplayName(),
+            });
+            this.tui.requestRender();
+        };
+        // Set callback for session reconstruction (used by /history command)
+        this.tui.onReconstructSession = () => this.rerender();
         this.tui.addChild(this.welcome);
         // Initialize footer with current title if one exists
         // this.footer.setTitle(messageHistory.getTitle());
         this.tui.addChild(this.chatContainer);
         this.tui.addChild(this.statusContainer);
+        // Everything below here is fixed to the bottom of the terminal
+        this.tui.setFixedFooterStart();
         this.tui.addChild(new Spacer(1));
         this.tui.addChild(this.editorContainer); // Use container that can hold editor or selector
         this.tui.addChild(this.footer);
@@ -122,38 +185,20 @@ export class NewRepl {
                     inputContainer: this.editorContainer,
                     editor: this.editor,
                 });
-                if (commandResult.break) {
-                    this.stop(true);
-                    process.exit(0);
-                }
                 if (commandResult.continue) {
                     this.editor.setText("");
                     this.tui.requestRender();
                     return;
                 }
                 if (!promptManager.isPending()) {
-                    try {
-                        const processedPrompt = await processPrompt(text, {
-                            baseDir: process.cwd(),
-                            model: modelConfig,
-                        });
-                        for (const context of processedPrompt.context) {
-                            promptManager.addContext(context);
-                        }
-                        promptManager.set(processedPrompt.message);
-                    }
-                    catch (error) {
-                        if (error instanceof PromptError) {
-                            this.chatContainer.addChild(new Text(style.red(`Prompt processing failed: ${error.message}`), 1, 1));
-                            if (error.cause &&
-                                typeof error.cause === "object" &&
-                                "command" in error.cause &&
-                                typeof error.cause.command === "string") {
-                                this.chatContainer.addChild(new Text(style.red(`Command: ${error.cause.command}`, 1, 1)));
-                            }
-                        }
-                        throw error; // Re-throw other errors
+                    const processedPrompt = await processPrompt(text, {
+                        baseDir: process.cwd(),
+                        model: modelConfig,
+                    });
+                    for (const context of processedPrompt.context) {
+                        promptManager.addContext(context);
                     }
+                    promptManager.set(processedPrompt.message);
                 }
                 else {
                     promptHistory.push(promptManager.get());
@@ -163,11 +208,34 @@ export class NewRepl {
                 const hasAddedContext = promptManager.hasContext();
                 if (hasAddedContext) {
                     const contextTokenCount = promptManager.getContextTokenCount();
-                    this.chatContainer.addChild(new Text(style.green(`Context will be added to prompt. (${contextTokenCount} tokens)`)));
+                    this.addComponentWithSpacing(new Text(style.green(`Context will be added to prompt. (${contextTokenCount} tokens)`)));
                 }
                 const userPrompt = promptManager.get();
                 const userMsg = promptManager.getUserMessage();
-                messageHistory.appendUserMessage(userMsg);
+                if (!this.modeManager.isNormal()) {
+                    if (this.modeManager.isFirstMessage()) {
+                        const initialPrompt = this.modeManager.getInitialPrompt();
+                        if (initialPrompt) {
+                            const modeMessage = createUserMessage([], initialPrompt);
+                            sessionManager.appendUserMessage(modeMessage);
+                        }
+                        sessionManager.appendUserMessage(userMsg);
+                        this.modeManager.markFirstMessageSent();
+                    }
+                    else {
+                        sessionManager.appendUserMessage(userMsg);
+                        const reminderMessage = this.modeManager.getReminderMessage();
+                        if (reminderMessage) {
+                            sessionManager.setTransientMessages([reminderMessage]);
+                        }
+                    }
+                }
+                else {
+                    sessionManager.appendUserMessage(userMsg);
+                }
+                this.addMessageToChat({ role: "user", content: userPrompt });
+                this.editor.setText("");
+                this.tui.requestRender();
                 if (this.onInputCallback) {
                     this.onInputCallback(userPrompt);
                 }
@@ -177,18 +245,25 @@ export class NewRepl {
         this.tui.start();
         this.isInitialized = true;
     }
+    /**
+     * Handles an agent event by updating the TUI accordingly.
+     * Processes events such as streaming messages, tool calls, thinking blocks,
+     * and agent lifecycle transitions (start, stop, error).
+     */
     async handle(event, state) {
         if (!this.isInitialized) {
             await this.init();
         }
         // Update footer with current stats
         // this.footer.updateState(state);
+        // Use cached project status for all events to avoid blocking on git
+        // subprocess calls; refresh asynchronously at agent-stop
         this.footer.setState({
-            projectStatus: await getProjectStatus(),
-            currentContextWindow: this.options.messageHistory.getContextWindow(),
+            projectStatus: this.footer.getProjectStatus(),
+            currentContextWindow: this.options.sessionManager.getLastTurnContextWindow(),
             contextWindow: this.options.modelManager.getModelMetadata("repl").contextWindow,
             agentState: state,
-            usage: this.options.tokenTracker.getUsageByApp("repl"),
+            currentMode: this.modeManager.getDisplayName(),
         });
         const eventType = event.type;
         switch (eventType) {
@@ -219,19 +294,13 @@ export class NewRepl {
                     // Create assistant component for streaming
                     const assistantMessageComponent = new AssistantMessageComponent();
                     this.streamingComponent = assistantMessageComponent;
-                    this.chatContainer.addChild(assistantMessageComponent);
+                    this.addComponentWithSpacing(assistantMessageComponent);
                     this.streamingComponent.updateContent(event);
                     this.tui.requestRender();
                 }
                 break;
             case "message":
-                if (event.role === "user") {
-                    // Show user message immediately and clear editor
-                    this.addMessageToChat(event);
-                    this.editor.setText("");
-                    this.tui.requestRender();
-                }
-                else if (event.role === "assistant") {
+                if (event.role === "assistant") {
                     // Update streaming component
                     if (this.streamingComponent && event.role === "assistant") {
                         this.streamingComponent.updateContent(event);
@@ -253,9 +322,12 @@ export class NewRepl {
                 }
                 else {
                     // Create tool component for new tool call
-                    const newComponent = new ToolExecutionComponent(event.events);
+                    const newComponent = new ToolExecutionComponent(event.events, {
+                        verboseMode: this.verboseMode,
+                    });
                     this.pendingTools.set(event.toolCallId, newComponent);
-                    this.chatContainer.addChild(newComponent);
+                    this.allToolExecutions.push(newComponent);
+                    this.addComponentWithSpacing(newComponent);
                 }
                 this.tui.requestRender();
                 break;
@@ -277,10 +349,30 @@ export class NewRepl {
                 }
                 this.pendingTools.clear();
                 this.editor.disableSubmit = false;
+                this.options.sessionManager.clearTransientMessages();
+                this.options.sessionManager.setMetadata("modeState", this.modeManager.toJson());
+                if (!this.options.noSession) {
+                    await this.options.sessionManager.save();
+                }
+                // Refresh project status now that agent may have modified files
+                await getProjectStatus().then((ps) => {
+                    this.footer.setState({
+                        projectStatus: ps,
+                        currentContextWindow: this.options.sessionManager.getLastTurnContextWindow(),
+                        contextWindow: this.options.modelManager.getModelMetadata("repl").contextWindow,
+                        currentMode: this.modeManager.getDisplayName(),
+                    });
+                    this.tui.requestRender();
+                });
                 this.tui.requestRender();
                 break;
             case "agent-error":
                 logger.error(event, "agent-error");
+                this.options.sessionManager.clearTransientMessages();
+                this.options.sessionManager.setMetadata("modeState", this.modeManager.toJson());
+                if (!this.options.noSession) {
+                    await this.options.sessionManager.save();
+                }
                 // Stop loading animation
                 if (this.loadingAnimation) {
                     this.loadingAnimation.stop();
@@ -296,9 +388,12 @@ export class NewRepl {
                 this.tui.requestRender();
                 break;
             case "thinking-start": {
-                const component = new ThinkingBlockComponent();
+                const component = new ThinkingBlockComponent(undefined, {
+                    verboseMode: this.verboseMode,
+                });
                 this.thinkingBlockComponent = component;
-                this.chatContainer.addChild(component);
+                this.allThinkingBlocks.push(component);
+                this.addComponentWithSpacing(component);
                 this.thinkingBlockComponent.updateContent(event);
                 this.tui.requestRender();
                 break;
@@ -311,7 +406,7 @@ export class NewRepl {
                 break;
             case "thinking-end":
                 if (this.thinkingBlockComponent) {
-                    this.thinkingBlockComponent.updateContent(event);
+                    this.thinkingBlockComponent.endThinking();
                     this.thinkingBlockComponent = null;
                     this.tui.requestRender();
                 }
@@ -320,16 +415,26 @@ export class NewRepl {
                 eventType;
         }
     }
+    /** Adds a user message component to the chat container. */
     addMessageToChat(message) {
         if (message.role === "user") {
             // Extract text content from content blocks
             const textContent = message.content;
             if (textContent) {
                 const userComponent = new UserMessageComponent(textContent);
-                this.chatContainer.addChild(userComponent);
+                this.addComponentWithSpacing(userComponent);
             }
         }
     }
+    /**
+     * Adds a component to the chat container with spacing.
+     * Adds a Spacer(1) before every component (including the first).
+     */
+    addComponentWithSpacing(component) {
+        this.chatContainer.addChild(new Spacer(1));
+        this.chatContainer.addChild(component);
+    }
+    /** Returns a promise that resolves with the user's next input submission. */
     async getUserInput() {
         return new Promise((resolve) => {
             this.onInputCallback = (text) => {
@@ -338,33 +443,75 @@ export class NewRepl {
             };
         });
     }
+    /** Clears the editor input and triggers a re-render. */
     clearEditor() {
         this.editor.setText("");
         this.tui.requestRender();
     }
+    /**
+     * Sets the callback invoked when the user presses
+     * Escape to interrupt the agent.
+     */
     setInterruptCallback(callback) {
         this.onInterruptCallback = callback;
     }
+    /** Sets the callback invoked on exit, receiving the current session ID. */
     setExitCallback(callback) {
         this.onExitCallback = callback;
     }
+    /**
+     * Re-renders the entire session by restoring mode state,
+     * replaying token usage, and reconstructing the chat
+     * display.
+     */
     async rerender() {
+        const modeState = this.options.sessionManager.getMetadata("modeState");
+        if (modeState && typeof modeState === "object" && "mode" in modeState) {
+            this.modeManager.fromJson(modeState);
+        }
+        // When resuming a session, populate tokenTracker with historical usage
+        // so the footer displays the correct total session usage
+        const totalUsage = this.options.sessionManager.getTotalTokenUsage();
+        if (totalUsage.inputTokens > 0 || totalUsage.outputTokens > 0) {
+            this.options.tokenTracker.trackUsage("repl", {
+                inputTokens: totalUsage.inputTokens,
+                outputTokens: totalUsage.outputTokens,
+                totalTokens: totalUsage.totalTokens,
+                inputTokenDetails: {
+                    noCacheTokens: totalUsage.inputTokens - totalUsage.cachedInputTokens,
+                    cacheReadTokens: totalUsage.cachedInputTokens,
+                    cacheWriteTokens: 0,
+                },
+                outputTokenDetails: {
+                    textTokens: totalUsage.outputTokens,
+                    reasoningTokens: totalUsage.reasoningTokens,
+                },
+            });
+        }
         this.footer.setState({
             projectStatus: await getProjectStatus(),
-            currentContextWindow: this.options.messageHistory.getContextWindow(),
+            currentContextWindow: this.options.sessionManager.getLastTurnContextWindow(),
             contextWindow: this.options.modelManager.getModelMetadata("repl").contextWindow,
-            usage: this.options.tokenTracker.getUsageByApp("repl"),
+            currentMode: this.modeManager.getDisplayName(),
         });
         // Reconstruct entire session display from messages
         this.reconstructSession();
+        this.tui.scrollToBottom();
         this.tui.requestRender();
     }
+    /**
+     * Rebuilds the chat container from the full session
+     * message history, including user messages, assistant
+     * responses, and tool executions.
+     */
     reconstructSession() {
         // Clear existing display
         this.pendingTools.clear();
+        this.allThinkingBlocks = [];
+        this.allToolExecutions = [];
         this.chatContainer.clear();
         // Get session messages
-        const messages = this.options.messageHistory.get();
+        const messages = this.options.sessionManager.get();
         // First pass: collect all tool results
         const toolResults = new Map();
         for (const message of messages) {
@@ -395,7 +542,7 @@ export class NewRepl {
                 const textContent = this.extractUserMessageText(message);
                 if (textContent) {
                     const userComponent = new UserMessageComponent(textContent);
-                    this.chatContainer.addChild(userComponent);
+                    this.addComponentWithSpacing(userComponent);
                 }
             }
             else if (message.role === "assistant") {
@@ -407,15 +554,22 @@ export class NewRepl {
                     const toolCallId = toolCallContent.toolCallId;
                     const events = this.createToolEvents(toolCallContent);
                     if (events.length > 0) {
-                        const component = new ToolExecutionComponent(events);
+                        const component = new ToolExecutionComponent(events, {
+                            verboseMode: this.verboseMode,
+                        });
                         this.pendingTools.set(toolCallId, component);
-                        this.chatContainer.addChild(component);
+                        this.allToolExecutions.push(component);
+                        this.addComponentWithSpacing(component);
                     }
                 }
             }
             // Tool messages are handled through their associated assistant message
         }
     }
+    /**
+     * Extracts the text content from a user message,
+     * handling both string and array content formats.
+     */
     extractUserMessageText(message) {
         if (typeof message.content === "string") {
             return message.content;
@@ -428,6 +582,10 @@ export class NewRepl {
         }
         return null;
     }
+    /**
+     * Renders an assistant message into the chat container,
+     * including reasoning/thinking blocks and text content.
+     */
     renderAssistantMessage(message) {
         if (typeof message.content === "string") {
             if (message.content.trim()) {
@@ -437,10 +595,25 @@ export class NewRepl {
                     role: "assistant",
                     content: message.content,
                 });
-                this.chatContainer.addChild(assistantComponent);
+                this.addComponentWithSpacing(assistantComponent);
             }
         }
         else if (Array.isArray(message.content)) {
+            const reasoningParts = message.content
+                .filter((part) => part.type === "reasoning" &&
+                typeof part.text === "string" &&
+                part.text.trim().length > 0)
+                .map((part) => part.text)
+                .join("\n");
+            if (reasoningParts.trim()) {
+                const thinkingComponent = new ThinkingBlockComponent(undefined, {
+                    verboseMode: this.verboseMode,
+                });
+                thinkingComponent.updateContent({ content: reasoningParts });
+                thinkingComponent.endThinking();
+                this.allThinkingBlocks.push(thinkingComponent);
+                this.addComponentWithSpacing(thinkingComponent);
+            }
             const textParts = message.content
                 .filter((part) => part.type === "text" && part.text?.trim() !== undefined)
                 .map((part) => part.text)
@@ -452,10 +625,15 @@ export class NewRepl {
                     role: "assistant",
                     content: textParts,
                 });
-                this.chatContainer.addChild(assistantComponent);
+                this.addComponentWithSpacing(assistantComponent);
             }
         }
     }
+    /**
+     * Extracts tool call content parts from an assistant
+     * message, matching them with their corresponding
+     * tool results.
+     */
     extractToolCallsFromAssistant(message, toolResults) {
         const toolCallContents = [];
         if (typeof message.content === "string") {
@@ -480,6 +658,11 @@ export class NewRepl {
         }
         return toolCallContents;
     }
+    /**
+     * Creates start and end/error ToolEvent pairs from a
+     * resolved tool call, using the tool's display function
+     * when available.
+     */
     createToolEvents(toolCallContent) {
         const events = [];
         // tool-call-start: use the tool's display function
@@ -508,6 +691,88 @@ export class NewRepl {
         });
         return events;
     }
+    /**
+     * Toggles verbose mode on/off, updating all thinking
+     * block and tool execution components.
+     */
+    handleCtrlO() {
+        this.verboseMode = !this.verboseMode;
+        const modeText = this.verboseMode ? "ON" : "OFF";
+        this.notification.setMessage(`Verbose mode: ${modeText}`);
+        // Update all verbose-aware components to reflect new verbose mode
+        for (const component of this.allThinkingBlocks) {
+            component.setVerboseMode(this.verboseMode);
+        }
+        for (const component of this.allToolExecutions) {
+            component.setVerboseMode(this.verboseMode);
+        }
+        this.tui.requestRender();
+    }
+    /**
+     * Starts a new session by saving the current one,
+     * resetting mode/tokens/UI, and clearing the chat.
+     */
+    async handleCtrlN() {
+        if (!this.options.sessionManager.isEmpty()) {
+            // Auto-generate rules before starting new session if enabled
+            // Run in background - don't block new session from starting
+            this.maybeGenerateRules().catch((err) => logger.debug({ err }, "Background rule generation failed"));
+            this.options.sessionManager.setMetadata("modeState", this.modeManager.toJson());
+            if (!this.options.noSession) {
+                await this.options.sessionManager.save();
+            }
+            this.options.sessionManager.create(this.options.modelManager.getModel("repl").modelId);
+        }
+        this.config = await this.options.configManager.getConfig();
+        this.modeManager.reset();
+        this.options.sessionManager.clearTransientMessages();
+        this.options.tokenTracker.reset();
+        setTerminalTitle(`acai: ${process.cwd()}`);
+        this.chatContainer.clear();
+        this.editor.setText("");
+        // Reset footer state to clear usage/cost/steps/tools/time
+        const footer = this.tui.children.find((child) => child.constructor.name === "FooterComponent");
+        if (footer) {
+            footer.resetState();
+        }
+        this.footer.setState({
+            projectStatus: this.footer.getProjectStatus(),
+            currentContextWindow: 0,
+            contextWindow: this.options.modelManager.getModelMetadata("repl").contextWindow,
+            currentMode: this.modeManager.getDisplayName(),
+        });
+        this.tui.requestRender();
+    }
+    handleCtrlM() {
+        showModelSelector(this.tui, this.editorContainer, this.editor, this.options.modelManager);
+    }
+    /** Handles Ctrl+D to exit the REPL when the editor is empty. */
+    handleCtrlD() {
+        // Only exit if the editor is empty
+        if (this.editor.getText().trim() !== "") {
+            // Editor has content, do nothing
+            return;
+        }
+        // Editor is empty - proceed with exit
+        // Clear any pending notification timer
+        if (this.exitNotificationTimer) {
+            clearTimeout(this.exitNotificationTimer);
+            this.exitNotificationTimer = undefined;
+        }
+        this.notification.setMessage("");
+        this.tui.requestRender();
+        this.options.sessionManager.setMetadata("modeState", this.modeManager.toJson());
+        if (!this.options.noSession) {
+            void this.options.sessionManager.save();
+        }
+        this.stop(true);
+        process.exit(0);
+    }
+    /**
+     * Handles Ctrl+C with double-press-to-exit logic.
+     * First press clears the editor; second press within
+     * 1 second exits.
+     */
     handleCtrlC() {
         // Handle Ctrl+C double-press logic
         const now = Date.now();
@@ -522,14 +787,17 @@ export class NewRepl {
             }
             this.notification.setMessage("");
             this.tui.requestRender();
-            void this.options.messageHistory.save();
+            this.options.sessionManager.setMetadata("modeState", this.modeManager.toJson());
+            if (!this.options.noSession) {
+                void this.options.sessionManager.save();
+            }
             this.stop(true);
             process.exit(0);
         }
         else {
             // First Ctrl+C - clear the editor and show notification
             this.clearEditor();
-            this.notification.setMessage("Press Ctrl+C again to exit");
+            this.notification.setMessage("Press Ctrl+C again to exit", 1000);
             this.tui.requestRender();
             this.lastSigintTime = now;
             // Clear notification after threshold if no second Ctrl+C
@@ -545,6 +813,10 @@ export class NewRepl {
             }, DoublePressThreshold);
         }
     }
+    /**
+     * Stops the REPL, cleaning up timers, animations,
+     * and the TUI. Optionally triggers the exit callback.
+     */
     stop(showExitMessage = false) {
         this.notification.setMessage("");
         // Clear any pending notification timer
@@ -553,7 +825,11 @@ export class NewRepl {
             this.exitNotificationTimer = undefined;
         }
         if (showExitMessage && this.onExitCallback) {
-            this.onExitCallback(this.options.messageHistory.getSessionId());
+            const result = this.onExitCallback(this.options.sessionManager.getSessionId());
+            // Await if the callback is async
+            if (result instanceof Promise) {
+                void result;
+            }
         }
         if (this.loadingAnimation) {
             this.loadingAnimation.stop();
@@ -564,4 +840,41 @@ export class NewRepl {
             this.isInitialized = false;
         }
     }
+    /**
+     * Generates rules automatically if autoGenerateRules is enabled
+     * and the session has messages.
+     */
+    async maybeGenerateRules() {
+        try {
+            const config = this.config;
+            if (!config.autoGenerateRules) {
+                return;
+            }
+            if (this.options.sessionManager.isEmpty()) {
+                return;
+            }
+            const { rules } = await generateRulesFromSession({
+                modelManager: this.options.modelManager,
+                messages: this.options.sessionManager.get(),
+                tokenTracker: this.options.tokenTracker,
+                config: this.options.configManager,
+                workspace: this.options.workspace,
+            });
+            if (rules.length > 0) {
+                this.notification.setMessage(`Auto-generated ${rules.length} rule(s) saved`);
+                this.tui.requestRender();
+            }
+        }
+        catch (error) {
+            // Don't fail the session transition on rule generation errors
+            logger.debug({ error }, "Auto rule generation failed");
+        }
+    }
+    /**
+     * Triggers rule generation for use before exit.
+     * Returns a promise that resolves when rules are generated.
+     */
+    async triggerRuleGeneration() {
+        await this.maybeGenerateRules();
+    }
 }