caroushell 0.1.0 → 0.1.2

package/README.md

@@ -1,30 +1,38 @@
 # Caroushell
 
 Caroushell is an interactive terminal carousel that suggests commands from your
-history, AI prompts, and configuration snippets so you can pick the next shell
-command without leaving the keyboard.
+history, and AI suggestions as you type.
 
 ## Features
 
-- Dual-pane carousel that combines history-based and AI-generated command
-  suggestions.
-- Runs the selected command directly in your current terminal session.
+- The top panel of the carousel shows history
+- 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.json`) so you can point the CLI
-  at different API keys or settings.
+  at different AI providers.
 
 ## Requirements
 
 - Node.js 18 or newer.
-- A `~/.caroushell/config.json` file that contains the tokens Caroushell needs.
-  Currently the file expects a Gemini API key:
+- On first launch Caroushell will prompt you for an OpenAI-compatible endpoint
+  URL, API key, and model name, then store them in `~/.caroushell/config.json`.
+- You can also create the file manually:
 
 ```json
 {
-  "GEMINI_API_KEY": "your-api-key"
+  "apiUrl": "https://openrouter.ai/api/v1",
+  "apiKey": "your-api-key",
+  "model": "gpt-4o-mini"
 }
 ```
 
+Any endpoint that implements the OpenAI Chat Completions API (OpenRouter,
+OpenAI, etc.) will work as long as the URL, key, and model are valid. If you
+only provide a Gemini API key in the config, Caroushell will default to the
+Gemini Flash Lite 2.5 endpoint and model.
+
 ## Installation
 
 Install globally (recommended):
@@ -58,9 +66,9 @@ need to debug AI suggestions or the terminal renderer. Configuration lives at
 
 ```bash
 npm install
-npm run dev        # tsx watch mode
-npm run build      # emits dist/
-npm run test:generate
+npm run dev
+npm run build
+npm run test:generate  # tests ai text generation
 npm publish --dry-run  # verify package contents before publishing
 ```
 

package/dist/ai-suggester.js

@@ -2,87 +2,128 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AISuggester = void 0;
 exports.generateContent = generateContent;
+exports.listModels = listModels;
 const logs_1 = require("./logs");
 const config_1 = require("./config");
 async function generateContent(prompt, options) {
-    const apiKey = options?.apiKey || process.env.GEMINI_API_KEY;
-    const model = options?.model || "gemini-2.5-flash-lite";
+    const apiKey = options?.apiKey ||
+        process.env.CAROUSHELL_API_KEY ||
+        process.env.GEMINI_API_KEY;
+    const apiUrl = options?.apiUrl || process.env.CAROUSHELL_API_URL;
+    const model = options?.model || process.env.CAROUSHELL_MODEL || process.env.OPENAI_MODEL;
     const temperature = options?.temperature ?? 0.3;
     const maxOutputTokens = options?.maxOutputTokens ?? 256;
     if (!apiKey) {
         (0, logs_1.logLine)("AI generation skipped: missing API key");
         return "";
     }
+    if (!apiUrl) {
+        (0, logs_1.logLine)("AI generation skipped: missing API URL");
+        return "";
+    }
+    if (!model) {
+        (0, logs_1.logLine)("AI generation skipped: missing model");
+        return "";
+    }
     if (!prompt.trim()) {
         (0, logs_1.logLine)("AI generation skipped: empty prompt");
         return "";
     }
     try {
         const start = Date.now();
-        const fetchImpl = globalThis.fetch;
-        if (!fetchImpl)
-            return "";
-        const res = await fetchImpl(`https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`, {
+        const request = buildRequest({
+            apiKey,
+            apiUrl,
+            model,
+            prompt,
+            temperature,
+            maxOutputTokens,
+        });
+        const res = await fetch(request.url, request.init);
+        if (!res.ok) {
+            return "ai fetch error: " + res.statusText;
+        }
+        const out = await extractText(await res.json());
+        const text = typeof out === "string" ? out : "";
+        const duration = Date.now() - start;
+        (0, logs_1.logLine)(`AI duration: ${duration} ms`);
+        return text;
+    }
+    catch (err) {
+        return "ai error: " + err.message;
+    }
+}
+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();
+    return models.data.map((m) => m.id);
+}
+function headers(apiKey) {
+    return {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`,
+        "HTTP-Referer": "https://github.com/ubershmekel/caroushell",
+        "X-Title": "Caroushell",
+    };
+}
+function buildRequest(args) {
+    return {
+        url: args.apiUrl + "/chat/completions",
+        init: {
             method: "POST",
-            headers: { "Content-Type": "application/json" },
+            headers: headers(args.apiKey),
             body: JSON.stringify({
-                contents: [
+                model: args.model,
+                temperature: args.temperature,
+                max_tokens: args.maxOutputTokens,
+                messages: [
                     {
-                        role: "user",
-                        parts: [{ text: prompt }],
+                        role: "system",
+                        content: "You are a shell assistant that suggests terminal command completions.",
                     },
+                    { role: "user", content: args.prompt },
                 ],
-                generationConfig: {
-                    temperature,
-                    maxOutputTokens,
-                },
             }),
-        });
-        if (!res.ok)
-            return "";
-        const json = (await res.json());
-        const text = json?.candidates?.[0]?.content?.parts?.[0]?.text || "";
-        const out = typeof text === "string" ? text : "";
-        const duration = Date.now() - start;
-        // Log duration and each non-empty line of the AI text
-        try {
-            await (0, logs_1.logLine)(`AI duration: ${duration} ms`);
-            if (out.trim()) {
-                const lines = out
-                    .split(/\r?\n/)
-                    .map((s) => s.trim())
-                    .filter(Boolean);
-                // .map((s) => `AI text: ${s}`);
-                // await logLines(lines);
-            }
-        }
-        catch {
-            // best-effort logging; ignore failures
-        }
-        return out;
-    }
-    catch {
-        return "";
-    }
+        },
+    };
+}
+async function extractText(json) {
+    const typed = json;
+    return typed?.choices?.[0]?.message?.content || "";
 }
 class AISuggester {
     constructor(opts) {
         this.prefix = "🤖";
         this.apiKey = opts?.apiKey;
-        this.model = opts?.model || "gemini-2.5-flash-lite";
+        this.apiUrl = opts?.apiUrl;
+        this.model = opts?.model;
     }
     async init() {
+        const config = await (0, config_1.getConfig)();
         this.apiKey =
             this.apiKey ||
-                (await (0, config_1.getConfig)()).GEMINI_API_KEY ||
+                config.apiKey ||
+                config.GEMINI_API_KEY ||
                 process.env.GEMINI_API_KEY;
+        this.apiUrl =
+            this.apiUrl || config.apiUrl || process.env.CAROUSHELL_API_URL;
+        this.model = this.model || config.model || process.env.CAROUSHELL_MODEL;
+        // If the user provided only a Gemini key, default the URL/model accordingly.
+        if (!this.apiUrl && config.GEMINI_API_KEY) {
+            this.apiUrl =
+                "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-lite:generateContent";
+        }
+        if (!this.model && config.GEMINI_API_KEY) {
+            this.model = "gemini-2.5-flash-lite";
+        }
     }
     descriptionForAi() {
         return "";
     }
     async suggest(carousel, maxDisplayed) {
-        if (!this.apiKey) {
-            (0, logs_1.logLine)("AI generation skipped: missing API key");
+        if (!this.apiKey || !this.apiUrl || !this.model) {
+            (0, logs_1.logLine)("AI generation skipped: missing API configuration");
             return [];
         }
         const descriptions = [];
@@ -95,6 +136,7 @@ class AISuggester {
         const prompt = `You are a shell assistant. Given a partial shell input, suggest ${maxDisplayed}\
 useful, concise shell commands that the user might run next.\
 Return one suggestion per line, no numbering, no extra text.
+Return the whole suggestion, not just what remains to type out.
 
 The current line is: "${carousel.getCurrentRow()}
 
@@ -103,6 +145,7 @@ ${descriptions.join("\n\n")}
         (0, logs_1.logLine)(prompt);
         const text = await generateContent(prompt, {
             apiKey: this.apiKey,
+            apiUrl: this.apiUrl,
             model: this.model,
             temperature: 0.3,
             maxOutputTokens: 128,

package/dist/app.js

@@ -6,7 +6,7 @@ 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 child_process_1 = require("child_process");
+const spawner_1 = require("./spawner");
 function debounce(fn, ms) {
     // Debounce function to limit the rate at which a function can fire
     let t = null;
@@ -29,43 +29,53 @@ class App {
             bottomRows: 2,
             terminal: this.terminal,
         });
-    }
-    async init() {
-        await this.history.init();
-        await this.ai.init();
-    }
-    async run() {
-        await this.init();
-        this.keyboard.start();
-        const updateSuggestions = debounce(async () => {
+        this.queueUpdateSuggestions = debounce(async () => {
             await this.carousel.updateSuggestions();
         }, 300);
-        const handlers = {
-            "ctrl-c": () => this.exit(),
+        this.handlers = {
+            "ctrl-c": () => {
+                if (this.carousel.isPromptRowSelected() && !this.carousel.hasInput()) {
+                    this.exit();
+                    return;
+                }
+                this.carousel.clearInput();
+                this.render();
+                this.queueUpdateSuggestions();
+            },
             "ctrl-d": () => {
-                if (this.carousel.getCurrentRow().length === 0)
+                if (this.carousel.isPromptRowSelected() && !this.carousel.hasInput()) {
                     this.exit();
+                    return;
+                }
+                this.carousel.deleteAtCursor();
+                this.render();
+                this.queueUpdateSuggestions();
+            },
+            "ctrl-u": () => {
+                this.carousel.deleteToLineStart();
+                this.render();
+                this.queueUpdateSuggestions();
             },
             backspace: () => {
                 this.carousel.deleteBeforeCursor();
                 // Immediate prompt redraw with existing suggestions
                 this.render();
                 // Async fetch of new suggestions
-                updateSuggestions();
+                this.queueUpdateSuggestions();
             },
             enter: async () => {
                 const cmd = this.carousel.getCurrentRow().trim();
                 this.carousel.setInputBuffer("", 0);
                 await this.runCommand(cmd);
                 this.carousel.resetIndex();
-                updateSuggestions();
+                this.queueUpdateSuggestions();
             },
             char: (evt) => {
                 this.carousel.insertAtCursor(evt.sequence);
                 // Immediate prompt redraw with existing suggestions
                 this.render();
                 // Async fetch of new suggestions
-                updateSuggestions();
+                this.queueUpdateSuggestions();
             },
             up: () => {
                 this.carousel.up();
@@ -83,20 +93,43 @@ class App {
                 this.carousel.moveCursorRight();
                 this.render();
             },
-            home: () => { },
-            end: () => { },
-            delete: () => { },
+            home: () => {
+                this.carousel.moveCursorHome();
+                this.render();
+            },
+            end: () => {
+                this.carousel.moveCursorEnd();
+                this.render();
+            },
+            delete: () => {
+                this.carousel.deleteAtCursor();
+                this.render();
+                this.queueUpdateSuggestions();
+            },
             escape: () => { },
         };
-        this.keyboard.on("key", async (evt) => {
-            const fn = handlers[evt.name];
-            if (fn)
-                await fn(evt);
+    }
+    async init() {
+        await this.history.init();
+        await this.ai.init();
+    }
+    async run() {
+        await this.init();
+        this.keyboard.start();
+        this.keyboard.on("key", (evt) => {
+            void this.handleKey(evt);
         });
         // Initial draw
         this.render();
         await this.carousel.updateSuggestions();
     }
+    async handleKey(evt) {
+        const fn = this.handlers[evt.name];
+        if (fn) {
+            await fn(evt);
+        }
+    }
+    queueUpdateSuggestions() { }
     render() {
         this.carousel.render();
         // Cursor placement handled inside carousel render.
@@ -116,17 +149,16 @@ class App {
         this.terminal.renderBlock(lines);
         // Ensure command output starts on the next line
         this.terminal.write("\n");
-        await this.history.add(cmd);
-        // Spawn shell
-        const isWin = process.platform === "win32";
-        const proc = (0, child_process_1.spawn)(isWin ? "cmd.exe" : "/bin/bash", [isWin ? "/c" : "-lc", cmd], {
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        await new Promise((resolve) => {
-            proc.stdout.on("data", (d) => process.stdout.write(d));
-            proc.stderr.on("data", (d) => process.stderr.write(d));
-            proc.on("close", () => resolve());
-        });
+        this.keyboard.pause();
+        try {
+            const success = await (0, spawner_1.runUserCommand)(cmd);
+            if (success) {
+                await this.history.add(cmd);
+            }
+        }
+        finally {
+            this.keyboard.resume();
+        }
         // After arbitrary output, reset render block tracking
         this.terminal.resetBlockTracking();
     }

package/dist/carousel.js

@@ -75,11 +75,15 @@ class Carousel {
         const { brightWhite, reset, dim } = terminal_1.colors;
         let color = dim;
         if (this.index === rowIndex) {
-            color = brightWhite;
+            color = terminal_1.colors.purple;
             if (rowIndex !== 0) {
                 prefix = "> ";
             }
         }
+        if (rowIndex !== 0 && !rowStr) {
+            // The edge of the top or bottom panel
+            prefix = "---";
+        }
         return `${color}${prefix}${rowStr}${reset}`;
     }
     getCurrentRow() {
@@ -129,6 +133,40 @@ class Carousel {
             return;
         this.inputCursor += 1;
     }
+    moveCursorHome() {
+        this.adoptSelectionIntoInput();
+        this.inputCursor = 0;
+    }
+    moveCursorEnd() {
+        this.adoptSelectionIntoInput();
+        this.inputCursor = this.inputBuffer.length;
+    }
+    deleteAtCursor() {
+        this.adoptSelectionIntoInput();
+        if (this.inputCursor >= this.inputBuffer.length)
+            return;
+        const before = this.inputBuffer.slice(0, this.inputCursor);
+        const after = this.inputBuffer.slice(this.inputCursor + 1);
+        this.inputBuffer = `${before}${after}`;
+    }
+    deleteToLineStart() {
+        this.adoptSelectionIntoInput();
+        if (this.inputCursor === 0)
+            return;
+        const after = this.inputBuffer.slice(this.inputCursor);
+        this.setInputBuffer(after, 0);
+    }
+    clearInput() {
+        this.adoptSelectionIntoInput();
+        this.setInputBuffer("", 0);
+        this.index = 0;
+    }
+    hasInput() {
+        return this.inputBuffer.length > 0;
+    }
+    isPromptRowSelected() {
+        return this.index === 0;
+    }
     getPromptCursorColumn() {
         const prefix = this.getPrefixByIndex(0);
         return prefix.length + this.inputCursor;

package/dist/config.js

@@ -34,18 +34,74 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.configFolder = configFolder;
+exports.getConfigPath = getConfigPath;
+exports.doesConfigExist = doesConfigExist;
 exports.getConfig = getConfig;
 const fs_1 = require("fs");
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
+const GEMINI_DEFAULT_API_URL = "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-lite:generateContent";
+const GEMINI_DEFAULT_MODEL = "gemini-2.5-flash-lite";
 function configFolder(subpath) {
     const home = os.homedir();
-    // Default path: ~/.caroushell/history
+    // Default path: ~/.caroushell/<subpath>
     return path.join(home, ".caroushell", subpath);
 }
+function getConfigPath() {
+    return process.env.CAROUSHELL_CONFIG_PATH || configFolder("config.json");
+}
+async function readConfigFile() {
+    const configPath = getConfigPath();
+    const raw = await fs_1.promises.readFile(configPath, "utf8");
+    return JSON.parse(raw);
+}
+async function doesConfigExist() {
+    const configPath = getConfigPath();
+    try {
+        await fs_1.promises.access(configPath);
+        const raw = await readConfigFile();
+        if (!raw)
+            return false;
+        return true;
+    }
+    catch (err) {
+        if (err?.code === "ENOENT") {
+            return false;
+        }
+        // detect empty json file syntax error
+        if (err instanceof SyntaxError) {
+            return false;
+        }
+        throw err;
+    }
+}
 async function getConfig() {
-    // Load config from ~/.caroushell/config.json
-    const configPath = process.env.CAROUSHELL_CONFIG_PATH || configFolder("config.json");
-    const config = JSON.parse(await fs_1.promises.readFile(configPath, "utf8"));
-    return config;
+    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;
+    const envModel = process.env.CAROUSHELL_MODEL || undefined;
+    const geminiApiKey = raw.GEMINI_API_KEY || process.env.GEMINI_API_KEY || undefined;
+    const resolved = {
+        ...raw,
+        apiUrl: raw.apiUrl || envApiUrl,
+        apiKey: raw.apiKey || raw.GEMINI_API_KEY || envApiKey,
+        model: raw.model || envModel,
+    };
+    // If the user only supplied a Gemini key, assume the Gemini defaults.
+    if (!resolved.apiUrl && geminiApiKey) {
+        resolved.apiUrl = GEMINI_DEFAULT_API_URL;
+    }
+    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) {
+    const lower = url.toLowerCase();
+    return (lower.includes("generativelanguage.googleapis.com") ||
+        lower.includes("gemini"));
 }

package/dist/hello-new-user.js

@@ -0,0 +1,120 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runHelloNewUserFlow = runHelloNewUserFlow;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const readline_1 = __importDefault(require("readline"));
+const ai_suggester_1 = require("./ai-suggester");
+function isInteractive() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+async function prompt(question, rl) {
+    return await new Promise((resolve) => {
+        rl.question(question, (answer) => resolve(answer));
+    });
+}
+async function runHelloNewUserFlow(configPath) {
+    if (!isInteractive()) {
+        throw new Error(`Missing config at ${configPath} and no interactive terminal is available.\n` +
+            "Create the file manually or run Caroushell from a TTY.");
+    }
+    const dir = path.dirname(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("");
+    console.log("Some example endpoints you can paste:");
+    console.log("  - OpenRouter: https://openrouter.ai/api/v1");
+    console.log("  - OpenAI:     https://api.openai.com/v1");
+    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();
+        if (answer) {
+            apiUrl = answer;
+        }
+        else {
+            console.log("Please enter a URL (example: https://openrouter.ai/api/v1)");
+        }
+    }
+    let apiKey = "";
+    while (!apiKey) {
+        const answer = (await prompt("API key: ", rl)).trim();
+        if (answer) {
+            apiKey = answer;
+        }
+        else {
+            console.log("Please enter an API key (the value stays local on this machine).");
+        }
+    }
+    const models = await (0, ai_suggester_1.listModels)(apiUrl, apiKey);
+    if (models.length > 0) {
+        console.log("Here are a few example model ids.");
+        for (const model of models.slice(0, 5)) {
+            console.log(`  - ${model}`);
+        }
+    }
+    let model = "";
+    while (!model) {
+        const answer = (await prompt("Model (e.g. gpt-4o-mini, google/gemini-2.5-flash-lite): ", rl)).trim();
+        if (answer) {
+            model = answer;
+        }
+        else {
+            console.log("Please enter a model name (example: mistralai/mistral-small-24b-instruct-2501).");
+        }
+    }
+    rl.close();
+    const config = {
+        apiUrl,
+        apiKey,
+        model,
+    };
+    await fs_1.promises.writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+    console.log(`\nSaved config to ${configPath}`);
+    console.log("You can edit this file later if you want to switch providers.\n");
+    return config;
+}

package/dist/history-suggester.js

@@ -32,16 +32,17 @@ class HistorySuggester {
     async add(command) {
         if (!command.trim())
             return;
-        // Deduplicate recent duplicate
-        if (this.items[this.items.length - 1] !== command) {
-            this.items.push(command);
-            if (this.items.length > this.maxItems)
-                this.items.shift();
-            await fs_1.promises
-                .mkdir(path_1.default.dirname(this.filePath), { recursive: true })
-                .catch(() => { });
-            await fs_1.promises.writeFile(this.filePath, this.items.join("\n"), "utf8");
+        if (this.items[this.items.length - 1] === command) {
+            // Deduplicate recent duplicate
+            return;
         }
+        this.items.push(command);
+        if (this.items.length > this.maxItems)
+            this.items.shift();
+        await fs_1.promises
+            .mkdir(path_1.default.dirname(this.filePath), { recursive: true })
+            .catch(() => { });
+        await fs_1.promises.writeFile(this.filePath, this.items.join("\n"), "utf8");
     }
     async suggest(carousel, maxDisplayed) {
         const input = carousel.getCurrentRow();

package/dist/keyboard.js

@@ -7,6 +7,7 @@ const KEYMAP = {
     // Control keys
     '\u0003': { name: 'ctrl-c', ctrl: true }, // ^C
     '\u0004': { name: 'ctrl-d', ctrl: true }, // ^D
+    '\u0015': { name: 'ctrl-u', ctrl: true }, // ^U
     '\r': { name: 'enter' },
     '\n': { name: 'enter' },
     '\u007f': { name: 'backspace' }, // DEL
@@ -35,30 +36,52 @@ class Keyboard extends events_1.EventEmitter {
     constructor() {
         super(...arguments);
         this.active = false;
+        this.capturing = false;
         this.buffer = '';
+        this.stdin = process.stdin;
+        this.onData = (data) => this.handleData(data);
     }
     start() {
         if (this.active)
             return;
         this.active = true;
-        const stdin = process.stdin;
-        stdin.setEncoding('utf8');
-        if (stdin.isTTY)
-            stdin.setRawMode(true);
-        stdin.resume();
-        const onData = (data) => this.handleData(data);
-        stdin.on('data', onData);
-        this.once('stop', () => {
-            stdin.off('data', onData);
-            if (stdin.isTTY)
-                stdin.setRawMode(false);
-        });
+        this.stdin.setEncoding('utf8');
+        this.enableCapture();
     }
     stop() {
         if (!this.active)
             return;
         this.active = false;
-        this.emit('stop');
+        this.disableCapture();
+    }
+    pause() {
+        if (!this.active)
+            return;
+        this.disableCapture();
+    }
+    resume() {
+        if (!this.active)
+            return;
+        this.enableCapture();
+    }
+    enableCapture() {
+        if (this.capturing)
+            return;
+        if (this.stdin.isTTY)
+            this.stdin.setRawMode(true);
+        this.stdin.on('data', this.onData);
+        this.stdin.resume();
+        this.capturing = true;
+    }
+    disableCapture() {
+        if (!this.capturing)
+            return;
+        this.stdin.off('data', this.onData);
+        if (this.stdin.isTTY)
+            this.stdin.setRawMode(false);
+        this.stdin.pause();
+        this.buffer = '';
+        this.capturing = false;
     }
     handleData(data) {
         this.buffer += data;

package/dist/logs.js

@@ -53,13 +53,19 @@ function timestamp(date = new Date()) {
     // local time iso string
     return date.toISOString();
 }
-async function logLine(message, when = new Date()) {
+async function writeLogLine(message, when) {
     const dir = getLogDir();
     await ensureDir(dir);
     const file = getLogFilePath(when);
     const line = `[${timestamp(when)}] ${message}\n`;
     await fs_1.promises.appendFile(file, line, "utf8");
 }
+function logLine(message, when = new Date()) {
+    // Fire-and-forget logging so callers do not need to await.
+    void writeLogLine(message, when).catch((err) => {
+        console.error("CRITICAL: Logger itself failed:", err.message);
+    });
+}
 // Ensure the ~/.caroushell/logs folder exists early in app startup
 async function ensureLogFolderExists() {
     const dir = getLogDir();

package/dist/main.js

@@ -2,10 +2,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const app_1 = require("./app");
+const hello_new_user_1 = require("./hello-new-user");
 const logs_1 = require("./logs");
+const config_1 = require("./config");
 async function main() {
     await (0, logs_1.ensureLogFolderExists)();
     (0, logs_1.logLine)("Caroushell started");
+    if (!(await (0, config_1.doesConfigExist)())) {
+        await (0, hello_new_user_1.runHelloNewUserFlow)((0, config_1.getConfigPath)());
+    }
     const app = new app_1.App();
     await app.run();
 }

package/dist/spawner.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runUserCommand = runUserCommand;
+const child_process_1 = require("child_process");
+const process_1 = require("process");
+const isWin = process.platform === "win32";
+const shellBinary = isWin ? "cmd.exe" : "/bin/bash";
+const shellArgs = isWin ? ["/c"] : ["-lc"];
+const builtInCommands = {
+    cd: async (args) => {
+        if (args.length === 1) {
+            process.stdout.write(process.cwd() + "\n");
+            return true;
+        }
+        const dest = expandVars(args[1]);
+        try {
+            process.chdir(dest);
+        }
+        catch (err) {
+            process.stderr.write(`cd: ${err.message}\n`);
+            return false;
+        }
+        return true;
+    },
+    exit: async () => {
+        (0, process_1.exit)(0);
+        return false;
+    },
+};
+function expandVars(input) {
+    let out = input;
+    if (isWin) {
+        // cmd-style %VAR% expansion
+        out = out.replace(/%([^%]+)%/g, (_m, name) => {
+            const v = process.env[String(name)];
+            return v !== undefined ? v : "";
+        });
+    }
+    else {
+        // POSIX-style $VAR and ${VAR} expansion
+        out = out.replace(/\$(\w+)|\${(\w+)}/g, (_m, a, b) => {
+            const name = a || b;
+            const v = process.env[name];
+            return v !== undefined ? v : "";
+        });
+    }
+    return out;
+}
+async function runUserCommand(command) {
+    const trimmed = command.trim();
+    if (!trimmed)
+        return false;
+    const args = command.split(/\s+/);
+    if (typeof args[0] === "string" && builtInCommands[args[0]]) {
+        return await builtInCommands[args[0]](args);
+    }
+    const proc = (0, child_process_1.spawn)(shellBinary, [...shellArgs, command], {
+        stdio: "inherit",
+    });
+    await new Promise((resolve, reject) => {
+        proc.on("error", reject);
+        proc.on("close", () => resolve());
+    });
+    return proc.exitCode === 0;
+}

package/dist/terminal.js

@@ -10,7 +10,9 @@ exports.colors = {
     reset: "\x1b[0m",
     white: "\x1b[37m",
     brightWhite: "\x1b[97m",
-    dim: "\x1b[2m",
+    dimmest: "\x1b[2m",
+    dim: "\x1b[37m",
+    purple: "\x1b[95m",
     yellow: "\x1b[33m",
 };
 class Terminal {

package/dist/test-generate.js

@@ -1,12 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const ai_suggester_1 = require("./ai-suggester");
+const config_1 = require("./config");
 async function main() {
-    if (!process.env.GEMINI_API_KEY) {
-        console.warn("Warning: GEMINI_API_KEY is not set. The answer may be empty.");
+    const config = await (0, config_1.getConfig)();
+    if (!config.apiKey) {
+        console.warn("Warning: no API key configured. The answer may be empty.");
     }
+    const models = await (0, ai_suggester_1.listModels)(config.apiUrl || "", config.apiKey || "");
+    console.log("Available models:", models);
     const question = "What is the capital of France?";
-    const answer = await (0, ai_suggester_1.generateContent)(question);
+    const answer = await (0, ai_suggester_1.generateContent)(question, {
+        apiKey: config.apiKey,
+        apiUrl: config.apiUrl,
+        model: config.model,
+    });
     console.log(`Q: ${question}`);
     console.log(`A: ${answer.trim()}`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "caroushell",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Terminal carousel that suggests commands from history, config, and AI.",
   "type": "commonjs",
   "main": "dist/main.js",
@@ -40,6 +40,10 @@
   },
   "devDependencies": {
     "@types/node": "^24.10.0",
+    "@types/shell-quote": "^1.7.5",
+    "@typescript-eslint/eslint-plugin": "^8.46.4",
+    "@typescript-eslint/parser": "^8.46.4",
+    "eslint": "^9.39.1",
     "tsx": "^4.19.2",
     "typescript": "^5.6.3"
   }