caroushell 0.1.20 → 0.1.23

package/README.md

@@ -3,8 +3,8 @@
 [![npm version](https://img.shields.io/npm/v/caroushell.svg)](https://www.npmjs.com/package/caroushell)
 [![npm downloads](https://img.shields.io/npm/dm/caroushell.svg)](https://www.npmjs.com/package/caroushell)
 
-Caroushell is an interactive terminal carousel that suggests commands from your
-history, and AI suggestions as you type.
+Caroushell is kind of like `bash` but you see history and AI suggestions as you
+type.
 
 ## Features
 
@@ -12,9 +12,6 @@ history, and AI suggestions as you type.
 - The bottom panel of the carousel shows AI-generated command suggestions.
 - Go up and down the carousel with arrow keys.
 - Press `Enter` to run the highlighted command.
-- Logs activity under `~/.caroushell/logs` for easy troubleshooting.
-- Extensible config file (`~/.caroushell/config.toml`) so you can point the CLI
-  at different AI providers.
 
 ## UI
 
@@ -42,12 +39,13 @@ It would look like this:
 
 ![Caroushell ai suggestion for ffmpeg slowmo](docs/assets/demo.gif)
 
-## Requirements
+## Setup
 
 - Node.js 18 or newer.
 - On first launch Caroushell will prompt you for an OpenAI-compatible endpoint
   URL, API key, and model name, then store them in `~/.caroushell/config.toml`.
 - You can also create the file manually:
+- Logs are at `~/.caroushell/logs` for easy troubleshooting.
 
 ```toml
 apiUrl = "https://openrouter.ai/api/v1"

package/dist/ai-suggester.js

@@ -80,7 +80,7 @@ async function generateContent(prompt, options) {
 async function listModels(apiUrl, apiKey) {
     const url = apiUrl.replace("/chat/completions", "") + "/models";
     const res = await fetch(url, { headers: headers(apiKey) });
-    const models = await res.json();
+    const models = (await res.json());
     return models.data.map((m) => m.id);
 }
 function headers(apiKey) {

package/dist/app.js

@@ -9,6 +9,9 @@ const ai_suggester_1 = require("./ai-suggester");
 const file_suggester_1 = require("./file-suggester");
 const spawner_1 = require("./spawner");
 const logs_1 = require("./logs");
+function collapseLineContinuations(input) {
+    return input.replace(/\\\r?\n/g, "");
+}
 class App {
     constructor(deps = {}) {
         this.usingFileSuggestions = false;
@@ -63,17 +66,12 @@ class App {
                 if (this.tryAcceptHighlightedFileSuggestion()) {
                     return;
                 }
-                const cmd = this.carousel.getCurrentRow().trim();
-                this.carousel.setInputBuffer("", 0);
-                await this.runCommand(cmd);
-                // Carousel should point to the prompt
-                this.carousel.resetIndex();
-                // After arbitrary output, reset render block tracking
-                this.terminal.resetBlockTracking();
-                // Render the prompt, without this we'd wait for the suggestions to call render
-                // and it would appear slow
-                this.render();
-                this.queueUpdateSuggestions();
+                if (this.carousel.isPromptRowSelected()) {
+                    await this.enterOnPrompt();
+                }
+                else {
+                    await this.enterOnSuggestion();
+                }
             },
             char: (evt) => {
                 this.carousel.insertAtCursor(evt.sequence);
@@ -83,10 +81,20 @@ class App {
                 this.queueUpdateSuggestions();
             },
             up: () => {
+                if (this.carousel.shouldUpMoveMultilineCursor()) {
+                    this.carousel.moveMultilineCursorUp();
+                    this.render();
+                    return;
+                }
                 this.carousel.up();
                 this.render();
             },
             down: () => {
+                if (this.carousel.shouldDownMoveMultilineCursor()) {
+                    this.carousel.moveMultilineCursorDown();
+                    this.render();
+                    return;
+                }
                 this.carousel.down();
                 this.render();
             },
@@ -136,13 +144,21 @@ class App {
     async run() {
         await this.init();
         this.keyboard.enableCapture();
-        this.keyboard.on("key", (evt) => {
+        this.onKeyHandler = (evt) => {
             void this.handleKey(evt);
-        });
+        };
+        this.keyboard.on("key", this.onKeyHandler);
         // Initial draw
         this.render();
         await this.carousel.updateSuggestions();
     }
+    end() {
+        if (this.onKeyHandler) {
+            this.keyboard.off("key", this.onKeyHandler);
+            this.onKeyHandler = undefined;
+        }
+        this.keyboard.disableCapture();
+    }
     async handleKey(evt) {
         const fn = this.handlers[evt.name];
         if (fn) {
@@ -177,13 +193,44 @@ class App {
         }
         finally {
             this.terminal.enableWrites();
+            this.terminal.reset();
             this.keyboard.enableCapture();
         }
     }
+    async enterOnPrompt() {
+        // Check for '\' line continuation
+        const lineInfo = this.carousel.getInputLineInfoAtCursor();
+        if (lineInfo.lineText.endsWith("\\") &&
+            lineInfo.column === lineInfo.lineText.length) {
+            this.carousel.insertAtCursor("\n");
+            this.render();
+            this.queueUpdateSuggestions();
+            return;
+        }
+        const rawInput = this.carousel.getInputBuffer();
+        const cmd = collapseLineContinuations(rawInput).trim();
+        await this.confirmCommandRun(cmd);
+    }
+    async enterOnSuggestion() {
+        const cmd = this.carousel.getCurrentRow().trim();
+        await this.confirmCommandRun(cmd);
+    }
+    async confirmCommandRun(cmd) {
+        this.carousel.setInputBuffer("", 0);
+        await this.runCommand(cmd);
+        // Carousel should point to the prompt
+        this.carousel.resetIndex();
+        // After arbitrary output, reset render block tracking
+        this.terminal.resetBlockTracking();
+        // Render the prompt, without this we'd wait for the suggestions to call render
+        // and it would appear slow
+        this.render();
+        this.queueUpdateSuggestions();
+    }
     exit() {
         // Clear terminal contents before shutting down to leave a clean screen.
         this.terminal.renderBlock([]);
-        this.keyboard.disableCapture();
+        this.end();
         process.exit(0);
     }
     async tryAutocompleteFile() {

package/dist/carousel.js

@@ -1,13 +1,67 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Carousel = void 0;
+exports.getDisplayWidth = getDisplayWidth;
 const logs_1 = require("./logs");
 const terminal_1 = require("./terminal");
+const ANSI_ESCAPE_REGEX = /\x1b\[[0-9;]*m/g;
+const COMBINING_MARK_REGEX = /^\p{Mark}+$/u;
+const EMOJI_REGEX = /\p{Extended_Pictographic}/u;
+const GRAPHEME_SEGMENTER = typeof Intl !== "undefined" && "Segmenter" in Intl
+    ? new Intl.Segmenter("en", { granularity: "grapheme" })
+    : null;
+function isFullWidthCodePoint(codePoint) {
+    return (codePoint >= 0x1100 &&
+        (codePoint <= 0x115f ||
+            codePoint === 0x2329 ||
+            codePoint === 0x232a ||
+            (codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f) ||
+            (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+            (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+            (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+            (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+            (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+            (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+            (codePoint >= 0x1f300 && codePoint <= 0x1f6ff) ||
+            (codePoint >= 0x1f900 && codePoint <= 0x1f9ff) ||
+            (codePoint >= 0x1fa70 && codePoint <= 0x1faff) ||
+            (codePoint >= 0x20000 && codePoint <= 0x3fffd)));
+}
+function getDisplayWidth(text) {
+    const stripped = text.replace(ANSI_ESCAPE_REGEX, "");
+    let width = 0;
+    if (GRAPHEME_SEGMENTER) {
+        for (const { segment } of GRAPHEME_SEGMENTER.segment(stripped)) {
+            if (!segment)
+                continue;
+            if (COMBINING_MARK_REGEX.test(segment))
+                continue;
+            if (EMOJI_REGEX.test(segment)) {
+                width += 2;
+                continue;
+            }
+            const codePoint = segment.codePointAt(0) ?? 0;
+            width += isFullWidthCodePoint(codePoint) ? 2 : 1;
+        }
+        return width;
+    }
+    for (const char of stripped) {
+        if (COMBINING_MARK_REGEX.test(char))
+            continue;
+        if (EMOJI_REGEX.test(char)) {
+            width += 2;
+            continue;
+        }
+        const codePoint = char.codePointAt(0) ?? 0;
+        width += isFullWidthCodePoint(codePoint) ? 2 : 1;
+    }
+    return width;
+}
 class Carousel {
     constructor(opts) {
         this.index = 0;
         this.inputBuffer = "";
-        this.inputCursor = 0;
+        this.cursorIndex = 0;
         this.terminal = opts.terminal;
         this.top = opts.top;
         this.bottom = opts.bottom;
@@ -27,6 +81,7 @@ class Carousel {
         if (this.index >= topLength) {
             this.index = topLength;
         }
+        this.clampCursorToActiveRow();
     }
     down() {
         this.index -= 1;
@@ -34,6 +89,7 @@ class Carousel {
         if (-this.index >= bottomLength) {
             this.index = -bottomLength;
         }
+        this.clampCursorToActiveRow();
     }
     getRow(rowIndex) {
         const latestTop = this.top.latest();
@@ -60,22 +116,32 @@ class Carousel {
         }
         return "$> ";
     }
-    getFormattedRow(rowIndex) {
+    getFormattedSuggestionRow(rowIndex) {
         const rowStr = this.getRow(rowIndex);
-        let prefix = this.getPrefixByIndex(rowIndex);
-        const { brightWhite, reset, dim } = terminal_1.colors;
+        let prefix = this.getSuggestionPrefix(rowIndex, rowStr);
+        const { reset, dim } = terminal_1.colors;
         let color = dim;
         if (this.index === rowIndex) {
             color = terminal_1.colors.purple;
-            if (rowIndex !== 0) {
-                prefix = "> ";
-            }
+        }
+        return `${color}${prefix}${rowStr}${reset}`;
+    }
+    getSuggestionPrefix(rowIndex, rowStr) {
+        let prefix = this.getPrefixByIndex(rowIndex);
+        if (this.index === rowIndex && rowIndex !== 0) {
+            prefix = `${prefix}> `;
         }
         if (rowIndex !== 0 && !rowStr) {
             // The edge of the top or bottom panel
             prefix = "---";
         }
-        return `${color}${prefix}${rowStr}${reset}`;
+        return prefix;
+    }
+    getFormattedPromptRow(lineIndex, lineText, promptSelected) {
+        const { reset, dim } = terminal_1.colors;
+        const color = promptSelected ? terminal_1.colors.purple : dim;
+        const prefix = this.getPromptPrefix(lineIndex);
+        return `${color}${prefix}${lineText}${reset}`;
     }
     getCurrentRow() {
         return this.getRow(this.index);
@@ -89,50 +155,67 @@ class Carousel {
     }
     setInputBuffer(value, cursorPos = value.length) {
         this.inputBuffer = value;
-        this.inputCursor = Math.max(0, Math.min(cursorPos, this.inputBuffer.length));
+        this.cursorIndex = Math.max(0, Math.min(cursorPos, this.inputBuffer.length));
+    }
+    getInputBuffer() {
+        return this.inputBuffer;
     }
     resetIndex() {
         this.index = 0;
+        this.cursorIndex = Math.min(this.cursorIndex, this.inputBuffer.length);
     }
     adoptSelectionIntoInput() {
+        // When you highlighted a suggestion row (history/AI) and then type
+        // or edit, we want to pull that selected row into the input buffer
         if (this.index === 0)
             return;
         const current = this.getRow(this.index);
-        this.setInputBuffer(current, current.length);
+        this.setInputBuffer(current, Math.min(this.cursorIndex, current.length));
         this.index = 0;
     }
+    getActiveRowLength() {
+        if (this.isPromptRowSelected())
+            return this.inputBuffer.length;
+        return this.getRow(this.index).length;
+    }
+    canMoveRight() {
+        return this.cursorIndex < this.getActiveRowLength();
+    }
+    clampCursorToActiveRow() {
+        const len = this.getActiveRowLength();
+        this.cursorIndex = Math.max(0, Math.min(this.cursorIndex, len));
+    }
     insertAtCursor(text) {
         if (!text)
             return;
         this.adoptSelectionIntoInput();
-        const before = this.inputBuffer.slice(0, this.inputCursor);
-        const after = this.inputBuffer.slice(this.inputCursor);
+        const before = this.inputBuffer.slice(0, this.cursorIndex);
+        const after = this.inputBuffer.slice(this.cursorIndex);
         this.inputBuffer = `${before}${text}${after}`;
-        this.inputCursor += text.length;
+        this.cursorIndex += text.length;
     }
     deleteBeforeCursor() {
         this.adoptSelectionIntoInput();
-        if (this.inputCursor === 0)
+        if (this.cursorIndex === 0)
             return;
-        const before = this.inputBuffer.slice(0, this.inputCursor - 1);
-        const after = this.inputBuffer.slice(this.inputCursor);
+        const before = this.inputBuffer.slice(0, this.cursorIndex - 1);
+        const after = this.inputBuffer.slice(this.cursorIndex);
         this.inputBuffer = `${before}${after}`;
-        this.inputCursor -= 1;
+        this.cursorIndex -= 1;
     }
     moveCursorLeft() {
-        this.adoptSelectionIntoInput();
-        if (this.inputCursor === 0)
+        if (this.cursorIndex === 0)
             return;
-        this.inputCursor -= 1;
+        this.cursorIndex -= 1;
     }
     isWhitespace(char) {
         return /\s/.test(char);
     }
     moveCursorWordLeft() {
         this.adoptSelectionIntoInput();
-        if (this.inputCursor === 0)
+        if (this.cursorIndex === 0)
             return;
-        let pos = this.inputCursor;
+        let pos = this.cursorIndex;
         // Skip any whitespace directly to the left of the cursor
         while (pos > 0 && this.isWhitespace(this.inputBuffer[pos - 1])) {
             pos -= 1;
@@ -141,19 +224,46 @@ class Carousel {
         while (pos > 0 && !this.isWhitespace(this.inputBuffer[pos - 1])) {
             pos -= 1;
         }
-        this.inputCursor = pos;
+        this.cursorIndex = pos;
     }
     moveCursorRight() {
+        if (!this.canMoveRight())
+            return;
+        this.cursorIndex += 1;
+    }
+    shouldUpMoveMultilineCursor() {
+        const info = this.getLineInfoAtPosition(this.cursorIndex);
+        return this.isPromptRowSelected() && info.lineIndex > 0;
+    }
+    shouldDownMoveMultilineCursor() {
+        const info = this.getLineInfoAtPosition(this.cursorIndex);
+        return this.isPromptRowSelected() && info.lineIndex < info.lines.length - 1;
+    }
+    moveMultilineCursorUp() {
+        this.adoptSelectionIntoInput();
+        const info = this.getLineInfoAtPosition(this.cursorIndex);
+        if (info.lineIndex === 0)
+            return;
+        const targetIndex = info.lineIndex - 1;
+        const targetStart = this.getLineStartIndex(targetIndex, info.lines);
+        const targetLen = info.lines[targetIndex].length;
+        this.cursorIndex = targetStart + Math.min(info.column, targetLen);
+    }
+    moveMultilineCursorDown() {
         this.adoptSelectionIntoInput();
-        if (this.inputCursor >= this.inputBuffer.length)
+        const info = this.getLineInfoAtPosition(this.cursorIndex);
+        if (info.lineIndex >= info.lines.length - 1)
             return;
-        this.inputCursor += 1;
+        const targetIndex = info.lineIndex + 1;
+        const targetStart = this.getLineStartIndex(targetIndex, info.lines);
+        const targetLen = info.lines[targetIndex].length;
+        this.cursorIndex = targetStart + Math.min(info.column, targetLen);
     }
     moveCursorWordRight() {
         this.adoptSelectionIntoInput();
-        if (this.inputCursor >= this.inputBuffer.length)
+        if (this.cursorIndex >= this.inputBuffer.length)
             return;
-        let pos = this.inputCursor;
+        let pos = this.cursorIndex;
         const len = this.inputBuffer.length;
         // Skip any whitespace to the right of the cursor
         while (pos < len && this.isWhitespace(this.inputBuffer[pos])) {
@@ -163,30 +273,35 @@ class Carousel {
         while (pos < len && !this.isWhitespace(this.inputBuffer[pos])) {
             pos += 1;
         }
-        this.inputCursor = pos;
+        this.cursorIndex = pos;
     }
     moveCursorHome() {
         this.adoptSelectionIntoInput();
-        this.inputCursor = 0;
+        this.cursorIndex = this.getLineInfoAtPosition(this.cursorIndex).lineStart;
     }
     moveCursorEnd() {
         this.adoptSelectionIntoInput();
-        this.inputCursor = this.inputBuffer.length;
+        this.cursorIndex = this.getLineInfoAtPosition(this.cursorIndex).lineEnd;
     }
     deleteAtCursor() {
         this.adoptSelectionIntoInput();
-        if (this.inputCursor >= this.inputBuffer.length)
+        if (this.cursorIndex >= this.inputBuffer.length)
             return;
-        const before = this.inputBuffer.slice(0, this.inputCursor);
-        const after = this.inputBuffer.slice(this.inputCursor + 1);
+        const before = this.inputBuffer.slice(0, this.cursorIndex);
+        const after = this.inputBuffer.slice(this.cursorIndex + 1);
         this.inputBuffer = `${before}${after}`;
     }
     deleteToLineStart() {
         this.adoptSelectionIntoInput();
-        if (this.inputCursor === 0)
+        if (this.cursorIndex === 0)
             return;
-        const after = this.inputBuffer.slice(this.inputCursor);
-        this.setInputBuffer(after, 0);
+        const info = this.getLineInfoAtPosition(this.cursorIndex);
+        if (info.column === 0)
+            return;
+        const before = this.inputBuffer.slice(0, info.lineStart);
+        const after = this.inputBuffer.slice(this.cursorIndex);
+        this.inputBuffer = `${before}${after}`;
+        this.cursorIndex = info.lineStart;
     }
     clearInput() {
         this.adoptSelectionIntoInput();
@@ -200,14 +315,14 @@ class Carousel {
         return this.index === 0;
     }
     getInputCursor() {
-        return this.inputCursor;
+        return this.cursorIndex;
     }
     getWordInfoAtCursor() {
-        let start = this.inputCursor;
+        let start = this.cursorIndex;
         while (start > 0 && !this.isWhitespace(this.inputBuffer[start - 1])) {
             start -= 1;
         }
-        let end = this.inputCursor;
+        let end = this.cursorIndex;
         const len = this.inputBuffer.length;
         while (end < len && !this.isWhitespace(this.inputBuffer[end])) {
             end += 1;
@@ -215,33 +330,98 @@ class Carousel {
         return {
             start,
             end,
-            prefix: this.inputBuffer.slice(start, this.inputCursor),
+            prefix: this.inputBuffer.slice(start, this.cursorIndex),
             word: this.inputBuffer.slice(start, end),
         };
     }
+    getInputLineInfoAtCursor() {
+        return this.getLineInfoAtPosition(this.cursorIndex);
+    }
     getPromptCursorColumn() {
-        const prefix = this.getPrefixByIndex(0);
-        return prefix.length + this.inputCursor;
+        const info = this.getLineInfoAtPosition(this.cursorIndex);
+        const prefix = this.getPromptPrefix(info.lineIndex);
+        const linePrefix = info.lineText.slice(0, info.column);
+        return getDisplayWidth(prefix) + getDisplayWidth(linePrefix);
+    }
+    getLineInfoAtPosition(pos) {
+        // Map a buffer index to its line/column and line boundaries.
+        const lines = this.getInputLines();
+        let start = 0;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const end = start + line.length;
+            if (pos <= end) {
+                // Cursor is on this line or at its end.
+                return {
+                    lines,
+                    lineIndex: i,
+                    lineText: line,
+                    lineStart: start,
+                    lineEnd: end,
+                    column: pos - start,
+                };
+            }
+            start = end + 1;
+        }
+        const lastIndex = Math.max(0, lines.length - 1);
+        const lastStart = Math.max(0, this.inputBuffer.length - lines[lastIndex].length);
+        // Fallback when pos is beyond the buffer end.
+        return {
+            lines,
+            lineIndex: lastIndex,
+            lineText: lines[lastIndex] ?? "",
+            lineStart: lastStart,
+            lineEnd: lastStart + (lines[lastIndex]?.length ?? 0),
+            column: Math.max(0, pos - lastStart),
+        };
+    }
+    getInputLines() {
+        return this.inputBuffer.split("\n");
+    }
+    getLineStartIndex(lineIndex, lines) {
+        let start = 0;
+        for (let i = 0; i < lineIndex; i++) {
+            start += lines[i].length + 1;
+        }
+        return start;
+    }
+    getPromptPrefix(lineIndex) {
+        return lineIndex === 0 ? "$> " : "> ";
     }
     render() {
         (0, logs_1.logLine)("Rendering carousel");
-        // Draw all the lines
         const width = process.stdout.columns || 80;
-        const { brightWhite, reset, dim } = terminal_1.colors;
         const lines = [];
-        const start = this.index + this.topRowCount;
         const rowCount = this.topRowCount + this.bottomRowCount + 1;
+        const start = this.index + this.topRowCount;
         const end = start - rowCount;
-        for (let i = start; i > end; i--) {
-            lines.push({
-                rowIndex: i,
-                text: this.getFormattedRow(i).slice(0, width - 2),
-            });
+        const promptLines = this.getInputLines();
+        const promptSelected = this.index === 0;
+        const lineInfo = this.getLineInfoAtPosition(this.cursorIndex);
+        let cursorRow = 0;
+        let cursorCol = 0;
+        for (let rowIndex = start; rowIndex > end; rowIndex--) {
+            if (rowIndex === 0) {
+                for (let i = 0; i < promptLines.length; i++) {
+                    if (this.index === 0 && i === lineInfo.lineIndex) {
+                        cursorRow = lines.length;
+                        cursorCol = this.getPromptCursorColumn();
+                    }
+                    lines.push(this.getFormattedPromptRow(i, promptLines[i], promptSelected));
+                }
+            }
+            else {
+                if (this.index === rowIndex) {
+                    const rowStr = this.getRow(rowIndex);
+                    const prefix = this.getSuggestionPrefix(rowIndex, rowStr);
+                    cursorRow = lines.length;
+                    const cursorText = rowStr.slice(0, Math.min(this.cursorIndex, rowStr.length));
+                    cursorCol = getDisplayWidth(prefix) + getDisplayWidth(cursorText);
+                }
+                lines.push(this.getFormattedSuggestionRow(rowIndex));
+            }
         }
-        const promptLineIndex = lines.findIndex((line) => line.rowIndex === 0);
-        const cursorRow = this.topRowCount;
-        const cursorCol = this.getPromptCursorColumn();
-        this.terminal.renderBlock(lines.map((line) => line.text), cursorRow, cursorCol);
+        this.terminal.renderBlock(lines.map((line) => line.slice(0, width - 2)), cursorRow, cursorCol);
     }
     setTopSuggester(suggester) {
         if (this.top === suggester)

package/dist/keyboard.js

@@ -1,45 +1,66 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Keyboard = void 0;
+exports.Keyboard = exports.KEY_SEQUENCES = void 0;
+exports.keySequence = keySequence;
 const events_1 = require("events");
-// Map escape/control sequences to semantic key names
-const KEYMAP = {
+// Map semantic key names to escape/control sequences
+const KEY_DEFINITIONS = {
     // Control keys
-    '\u0003': { name: 'ctrl-c', ctrl: true }, // ^C
-    '\u0004': { name: 'ctrl-d', ctrl: true }, // ^D
-    '\u0015': { name: 'ctrl-u', ctrl: true }, // ^U
-    '\t': { name: 'tab' },
-    '\r': { name: 'enter' },
-    '\n': { name: 'enter' },
-    '\u007f': { name: 'backspace' }, // DEL
-    '\u0008': { name: 'backspace' }, // BS (Windows)
-    '\u001b': { name: 'escape' },
+    'ctrl-c': [{ sequence: '\u0003', ctrl: true }], // ^C
+    'ctrl-d': [{ sequence: '\u0004', ctrl: true }], // ^D
+    'ctrl-u': [{ sequence: '\u0015', ctrl: true }], // ^U
+    tab: [{ sequence: '\t' }],
+    enter: [{ sequence: '\r' }, { sequence: '\n' }],
+    backspace: [{ sequence: '\u007f' }, { sequence: '\u0008' }], // DEL, BS (Windows)
+    escape: [{ sequence: '\u001b' }],
     // Arrows (ANSI)
-    '\u001b[A': { name: 'up' },
-    '\u001b[B': { name: 'down' },
-    '\u001b[C': { name: 'right' },
-    '\u001b[D': { name: 'left' },
-    '\u001b[1;5C': { name: 'ctrl-right', ctrl: true },
-    '\u001b[1;5D': { name: 'ctrl-left', ctrl: true },
-    '\u001b[5C': { name: 'ctrl-right', ctrl: true },
-    '\u001b[5D': { name: 'ctrl-left', ctrl: true },
-    // Option/Alt-based word jumps (macOS/iTerm send meta-modified arrows or ESC+b/f)
-    '\u001b[1;3C': { name: 'ctrl-right', meta: true },
-    '\u001b[1;3D': { name: 'ctrl-left', meta: true },
-    '\u001b[1;9C': { name: 'ctrl-right', meta: true },
-    '\u001b[1;9D': { name: 'ctrl-left', meta: true },
-    '\u001bf': { name: 'ctrl-right', meta: true },
-    '\u001bb': { name: 'ctrl-left', meta: true },
+    up: [{ sequence: '\u001b[A' }],
+    down: [{ sequence: '\u001b[B' }],
+    right: [{ sequence: '\u001b[C' }],
+    left: [{ sequence: '\u001b[D' }],
+    'ctrl-right': [
+        { sequence: '\u001b[1;5C', ctrl: true },
+        { sequence: '\u001b[5C', ctrl: true },
+        // Option/Alt-based word jumps (macOS/iTerm send meta-modified arrows or ESC+b/f)
+        { sequence: '\u001b[1;3C', meta: true },
+        { sequence: '\u001b[1;9C', meta: true },
+        { sequence: '\u001bf', meta: true },
+    ],
+    'ctrl-left': [
+        { sequence: '\u001b[1;5D', ctrl: true },
+        { sequence: '\u001b[5D', ctrl: true },
+        // Option/Alt-based word jumps (macOS/iTerm send meta-modified arrows or ESC+b/f)
+        { sequence: '\u001b[1;3D', meta: true },
+        { sequence: '\u001b[1;9D', meta: true },
+        { sequence: '\u001bb', meta: true },
+    ],
     // Home/End/Delete variants
-    '\u001b[H': { name: 'home' },
-    '\u001b[F': { name: 'end' },
-    '\u001b[1~': { name: 'home' },
-    '\u001b[4~': { name: 'end' },
-    '\u001b[3~': { name: 'delete' },
+    home: [{ sequence: '\u001b[H' }, { sequence: '\u001b[1~' }],
+    end: [{ sequence: '\u001b[F' }, { sequence: '\u001b[4~' }],
+    delete: [{ sequence: '\u001b[3~' }],
     // Focus in/out (sent by some terminals on focus change - swallow these)
-    '\u001b[I': { name: 'focus-in' },
-    '\u001b[O': { name: 'focus-out' },
+    'focus-in': [{ sequence: '\u001b[I' }],
+    'focus-out': [{ sequence: '\u001b[O' }],
 };
+exports.KEY_SEQUENCES = Object.fromEntries(Object.entries(KEY_DEFINITIONS).map(([name, defs]) => [
+    name,
+    defs.map((def) => def.sequence),
+]));
+function keySequence(name) {
+    return exports.KEY_SEQUENCES[name][0];
+}
+// Map escape/control sequences to semantic key names
+const KEYMAP = {};
+for (const [name, defs] of Object.entries(KEY_DEFINITIONS)) {
+    for (const def of defs) {
+        KEYMAP[def.sequence] = {
+            name,
+            ctrl: def.ctrl,
+            meta: def.meta,
+            shift: def.shift,
+        };
+    }
+}
 // For efficient prefix checks
 const KEY_PREFIXES = new Set();
 for (const seq of Object.keys(KEYMAP)) {

package/dist/spawner.js

@@ -7,6 +7,18 @@ const logs_1 = require("./logs");
 const isWin = process.platform === "win32";
 const shellBinary = isWin ? "cmd.exe" : "/bin/bash";
 const shellArgs = isWin ? ["/d", "/s", "/c"] : ["-lc"];
+const dirStack = [];
+// Track last-known cwd per drive so `E:` switches like cmd.exe
+// into the folder you were in before switching drives.
+const driveCwds = {};
+function updateDriveCwd(cwd = process.cwd()) {
+    if (!isWin)
+        return;
+    const drive = cwd.slice(0, 2).toUpperCase();
+    if (/^[A-Z]:$/.test(drive)) {
+        driveCwds[drive] = cwd;
+    }
+}
 const builtInCommands = {
     cd: async (args) => {
         if (args.length === 1) {
@@ -16,6 +28,7 @@ const builtInCommands = {
         const dest = expandVars(args[1]);
         try {
             process.chdir(dest);
+            updateDriveCwd();
         }
         catch (err) {
             process.stderr.write(`cd: ${err.message}\n`);
@@ -23,11 +36,66 @@ const builtInCommands = {
         }
         return true;
     },
+    pushd: async (args) => {
+        const current = process.cwd();
+        if (args.length === 1) {
+            const next = dirStack.shift();
+            if (!next) {
+                process.stderr.write("pushd: no other directory\n");
+                return false;
+            }
+            dirStack.unshift(current);
+            try {
+                process.chdir(next);
+                updateDriveCwd();
+            }
+            catch (err) {
+                process.stderr.write(`pushd: ${err.message}\n`);
+                dirStack.shift();
+                return false;
+            }
+            writeDirStack();
+            return true;
+        }
+        const dest = expandVars(args[1]);
+        try {
+            process.chdir(dest);
+            updateDriveCwd();
+        }
+        catch (err) {
+            process.stderr.write(`pushd: ${err.message}\n`);
+            return false;
+        }
+        dirStack.unshift(current);
+        writeDirStack();
+        return true;
+    },
+    popd: async () => {
+        const next = dirStack.shift();
+        if (!next) {
+            process.stderr.write("popd: directory stack empty\n");
+            return false;
+        }
+        try {
+            process.chdir(next);
+            updateDriveCwd();
+        }
+        catch (err) {
+            process.stderr.write(`popd: ${err.message}\n`);
+            return false;
+        }
+        writeDirStack();
+        return true;
+    },
     exit: async () => {
         (0, process_1.exit)(0);
         return false;
     },
 };
+function writeDirStack() {
+    const parts = [process.cwd(), ...dirStack];
+    process.stdout.write(parts.join(" ") + "\n");
+}
 function expandVars(input) {
     let out = input;
     if (isWin) {
@@ -52,6 +120,20 @@ async function runUserCommand(command) {
     const trimmed = command.trim();
     if (!trimmed)
         return false;
+    if (isWin && /^[a-zA-Z]:$/.test(trimmed)) {
+        // Windows drive switch (eg "E:") should restore that drive's last cwd.
+        const drive = trimmed.toUpperCase();
+        const target = driveCwds[drive] ?? `${drive}\\`;
+        try {
+            process.chdir(target);
+            updateDriveCwd();
+            return true;
+        }
+        catch (err) {
+            process.stderr.write(`${trimmed}: ${err.message}\n`);
+            return false;
+        }
+    }
     const args = command.split(/\s+/);
     if (typeof args[0] === "string" && builtInCommands[args[0]]) {
         return await builtInCommands[args[0]](args);
@@ -70,3 +152,4 @@ async function runUserCommand(command) {
     // many times until we fix it.
     return true;
 }
+updateDriveCwd();

package/dist/terminal.js

@@ -29,6 +29,13 @@ class Terminal {
     enableWrites() {
         this.writesDisabled = false;
     }
+    reset() {
+        // Some apps (such as vim) change the terminal cursor mode.
+        // We need to reset it to the default. To avoid arrow keys causing this:
+        // $> OAOBOCODODODODOAOAOCOB
+        const RESET_CURSOR_MODE = "\x1b[?1l";
+        this.write(RESET_CURSOR_MODE);
+    }
     canWrite() {
         return !this.writesDisabled;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "caroushell",
-  "version": "0.1.20",
+  "version": "0.1.23",
   "description": "Terminal carousel that suggests commands from history, config, and AI.",
   "type": "commonjs",
   "main": "dist/main.js",