caroushell 0.1.21 → 0.1.24

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

@@ -5,24 +5,26 @@ const terminal_1 = require("./terminal");
 const keyboard_1 = require("./keyboard");
 const carousel_1 = require("./carousel");
 const history_suggester_1 = require("./history-suggester");
-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;
         this.terminal = deps.terminal ?? new terminal_1.Terminal();
         this.keyboard = deps.keyboard ?? new keyboard_1.Keyboard();
         this.history = deps.topPanel ?? new history_suggester_1.HistorySuggester();
-        this.ai = deps.bottomPanel ?? new ai_suggester_1.AISuggester();
+        this.bottomSuggester = deps.bottomPanel ?? new carousel_1.NullSuggester();
         this.files = deps.files ?? new file_suggester_1.FileSuggester();
-        this.suggesters = deps.suggesters ?? [this.history, this.ai, this.files];
+        this.suggesters = deps.suggesters ?? [this.history, this.bottomSuggester, this.files];
         this.carousel = new carousel_1.Carousel({
             top: this.history,
-            bottom: this.ai,
+            bottom: this.bottomSuggester,
             topRows: 2,
-            bottomRows: 2,
+            bottomRows: this.bottomSuggester instanceof carousel_1.NullSuggester ? 0 : 2,
             terminal: this.terminal,
         });
         this.queueUpdateSuggestions = () => {
@@ -63,17 +65,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 +80,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();
             },
@@ -129,20 +136,28 @@ class App {
         };
     }
     async init() {
-        await this.history.init();
-        await this.ai.init();
-        await this.files.init();
+        for (const s of this.suggesters) {
+            await s.init();
+        }
     }
     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) {
@@ -169,6 +184,7 @@ class App {
         this.terminal.write("\n");
         this.keyboard.disableCapture();
         this.terminal.disableWrites();
+        await this.preBroadcastCommand(cmd);
         try {
             const storeInHistory = await (0, spawner_1.runUserCommand)(cmd);
             if (storeInHistory) {
@@ -181,10 +197,40 @@ class App {
             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() {
@@ -245,6 +291,19 @@ class App {
         this.usingFileSuggestions = true;
         this.carousel.setTopSuggester(this.files);
     }
+    async preBroadcastCommand(cmd) {
+        const listeners = this.suggesters
+            .map((suggester) => suggester.onCommandWillRun?.(cmd))
+            .filter(Boolean);
+        if (listeners.length === 0)
+            return;
+        try {
+            await Promise.all(listeners);
+        }
+        catch (err) {
+            (0, logs_1.logLine)("suggester onCommandWillRun error: " + err?.message);
+        }
+    }
     async broadcastCommand(cmd) {
         const listeners = this.suggesters
             .map((suggester) => suggester.onCommandRan?.(cmd))

package/dist/carousel.js

@@ -1,13 +1,77 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Carousel = void 0;
+exports.Carousel = exports.NullSuggester = 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 NullSuggester {
+    constructor() {
+        this.prefix = "";
+    }
+    async init() { }
+    async refreshSuggestions() { }
+    latest() { return []; }
+    descriptionForAi() { return ""; }
+}
+exports.NullSuggester = NullSuggester;
 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 +91,7 @@ class Carousel {
         if (this.index >= topLength) {
             this.index = topLength;
         }
+        this.clampCursorToActiveRow();
     }
     down() {
         this.index -= 1;
@@ -34,6 +99,7 @@ class Carousel {
         if (-this.index >= bottomLength) {
             this.index = -bottomLength;
         }
+        this.clampCursorToActiveRow();
     }
     getRow(rowIndex) {
         const latestTop = this.top.latest();
@@ -60,22 +126,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 +165,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 +234,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 +283,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 +325,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 +340,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/config.js

@@ -88,7 +88,6 @@ async function doesConfigExist() {
     }
 }
 async function getConfig() {
-    const configPath = getConfigPath();
     const raw = await readConfigFile();
     const envApiKey = process.env.CAROUSHELL_API_KEY || process.env.GEMINI_API_KEY || undefined;
     const envApiUrl = process.env.CAROUSHELL_API_URL || undefined;
@@ -107,9 +106,6 @@ async function getConfig() {
     if (!resolved.model && geminiApiKey) {
         resolved.model = GEMINI_DEFAULT_MODEL;
     }
-    if (!resolved.apiUrl || !resolved.apiKey || !resolved.model) {
-        throw new Error(`Config at ${configPath} is missing required fields. Please include apiUrl, apiKey, and model (or just GEMINI_API_KEY).`);
-    }
     return resolved;
 }
 function isGeminiUrl(url) {

package/dist/hello-new-user.js

@@ -70,7 +70,23 @@ async function runHelloNewUserFlow(configPath) {
     await fs_1.promises.mkdir(dir, { recursive: true });
     console.log("");
     console.log("Welcome to Caroushell!");
-    console.log(`Let's set up AI suggestions. You'll need an API endpoint URL, a key, and model id. These will be stored at ${configPath}`);
+    console.log("");
+    const rl = readline_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const wantsAi = (await prompt("Do you want to set up AI auto-complete? (y/n): ", rl))
+        .trim()
+        .toLowerCase();
+    if (wantsAi !== "y" && wantsAi !== "yes") {
+        rl.close();
+        // Writing noAi or any key will skip the new user flow next run
+        await fs_1.promises.writeFile(configPath, "noAi = true\n", "utf8");
+        console.log("\nSkipping AI setup. You can set it up later by editing " + configPath);
+        console.log("");
+        return null;
+    }
+    console.log(`\nLet's set up AI suggestions. You'll need an API endpoint URL, a key, and model id. These will be stored at ${configPath}`);
     console.log("");
     console.log("Some example endpoints you can paste:");
     console.log("  - OpenRouter: https://openrouter.ai/api/v1");
@@ -78,10 +94,6 @@ async function runHelloNewUserFlow(configPath) {
     console.log("  - Google:     https://generativelanguage.googleapis.com/v1beta/openai");
     console.log("");
     console.log("Press Ctrl+C any time to abort.\n");
-    const rl = readline_1.default.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
     let apiUrl = "";
     while (!apiUrl) {
         const answer = (await prompt("API URL: ", rl)).trim();

package/dist/history-suggester.js

@@ -48,9 +48,10 @@ class HistorySuggester {
             .catch(() => { });
         await fs_1.promises.appendFile(this.filePath, this.serializeHistoryEntry(command), "utf8");
     }
-    async onCommandRan(command) {
+    async onCommandWillRun(command) {
         await this.add(command);
     }
+    async onCommandRan(command) { }
     latest() {
         return this.filteredItems;
     }

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/main.js

@@ -4,6 +4,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = require("fs");
 const path_1 = require("path");
 const app_1 = require("./app");
+const ai_suggester_1 = require("./ai-suggester");
+const carousel_1 = require("./carousel");
 const hello_new_user_1 = require("./hello-new-user");
 const logs_1 = require("./logs");
 const config_1 = require("./config");
@@ -25,7 +27,11 @@ async function main() {
     if (!(await (0, config_1.doesConfigExist)())) {
         await (0, hello_new_user_1.runHelloNewUserFlow)((0, config_1.getConfigPath)());
     }
-    const app = new app_1.App();
+    const config = await (0, config_1.getConfig)();
+    const bottomPanel = config.apiUrl && config.apiKey && config.model
+        ? new ai_suggester_1.AISuggester()
+        : new carousel_1.NullSuggester();
+    const app = new app_1.App({ bottomPanel });
     await app.run();
 }
 main().catch((err) => {

package/dist/spawner.js

@@ -144,10 +144,19 @@ async function runUserCommand(command) {
         stdio: "inherit",
         windowsVerbatimArguments: true,
     });
-    await new Promise((resolve, reject) => {
-        proc.on("error", reject);
-        proc.on("close", () => resolve());
-    });
+    // While a user command owns the terminal, Ctrl+C should interrupt that command
+    // without taking down the parent Caroushell process.
+    const ignoreSigint = () => { };
+    process.on("SIGINT", ignoreSigint);
+    try {
+        await new Promise((resolve, reject) => {
+            proc.on("error", reject);
+            proc.on("close", () => resolve());
+        });
+    }
+    finally {
+        process.off("SIGINT", ignoreSigint);
+    }
     // Why save failed commands? Well eg sometimes we want to run a test
     // many times until we fix it.
     return true;

package/package.json

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