@ikyyofc/gemini-cli 1.0.4 → 1.0.6

package/index.js

@@ -19,7 +19,8 @@ import {
     printError, printInfo, printSuccess, printWarning
 } from "./src/renderer.js";
 import {
-    enableBracketedPaste, disableBracketedPaste, setupPaste
+    PasteTransform, restorePaste,
+    enableBracketedPaste, disableBracketedPaste
 } from "./src/input.js";
 
 // ─────────────────────────────────────────────────────────────────
@@ -54,34 +55,46 @@ function sysInstruction() {
 }
 
 // ─────────────────────────────────────────────────────────────────
-//  Readline — directly on process.stdin, NO transform stream
+//  Readline — stdin → PasteTransform → readline
+//  { end: false } prevents Ctrl+D on stdin from auto-closing readline
 // ─────────────────────────────────────────────────────────────────
+enableBracketedPaste();
+
+const pasteStream = new PasteTransform();
+process.stdin.pipe(pasteStream, { end: false });
+
+// Handle Ctrl+D (stdin end) manually
+process.stdin.once("end", () => {
+    cleanup();
+    process.exit(0);
+});
+
 const rl = readline.createInterface({
-    input:       process.stdin,
+    input:       pasteStream,
     output:      process.stdout,
     terminal:    true,
     historySize: 200,
     crlfDelay:   Infinity,
 });
 
-// Attach paste interception (keypress-based, not Transform-based)
-enableBracketedPaste();
-setupPaste(rl);
-
-// Clean up on any exit
 function cleanup() {
     disableBracketedPaste();
-    if (process.stdin.isTTY) {
-        try { process.stdin.setRawMode(false); } catch {}
-    }
+    try { if (process.stdin.isTTY) process.stdin.setRawMode(false); } catch {}
 }
-process.on("exit", cleanup);
+process.on("exit",    cleanup);
 process.on("SIGTERM", () => { cleanup(); process.exit(0); });
 
+// When terminal is resized (or focus returns on some terminals),
+// only redraw prompt if we are NOT currently processing
+process.on("SIGWINCH", () => { if (!processing) showPrompt(); });
+
 // ─────────────────────────────────────────────────────────────────
 //  Prompt
 // ─────────────────────────────────────────────────────────────────
 function showPrompt() {
+    // Never redraw prompt while a request is in flight
+    if (processing) return;
+
     const mode  = agentMode     ? chalk.hex("#4EC9B0")("agent") : chalk.dim("chat");
     const yolo  = autoApprove   ? chalk.red(" yolo")   : "";
     const file  = pendingFile   ? chalk.yellow(` +${path.basename(pendingPath)}`) : "";
@@ -96,7 +109,7 @@ function showPrompt() {
 }
 
 // ─────────────────────────────────────────────────────────────────
-//  File attachment
+//  Attach file
 // ─────────────────────────────────────────────────────────────────
 function attachFile(fp) {
     const p = path.resolve(fp.trim().replace(/^['"]|['"]$/g, ""));
@@ -110,8 +123,10 @@ function attachFile(fp) {
 // ─────────────────────────────────────────────────────────────────
 //  Send message
 // ─────────────────────────────────────────────────────────────────
-async function send(userText) {
-    if (!userText.trim()) return;
+async function send(rawLine) {
+    // Decode \x00 → \n from paste encoding
+    const userText = restorePaste(rawLine).trim();
+    if (!userText) return;
 
     printUser(userText + (pendingFile ? chalk.dim(` [${path.basename(pendingPath)}]`) : ""));
 
@@ -126,19 +141,20 @@ async function send(userText) {
             history.push({ role: "assistant", content: res.finalResponse });
         }
     } else {
-        const { default: ora } = await import("ora");
-        const sp = ora({ text: "thinking…", spinner: "dots", color: "cyan", prefixText: "  ", discardStdin: false }).start();
+        process.stdout.write(chalk.hex("#555566")("  ⋯ ") + chalk.dim("thinking…") + "\n");
         const msgs = [];
         if (sysInstruction()) msgs.push({ role: "system", content: sysInstruction() });
         msgs.push(...history, { role: "user", content: userText });
         try {
             const t0    = Date.now();
             const reply = await chat(msgs, pendingFile || null);
-            sp.succeed(chalk.dim(`done (${((Date.now()-t0)/1000).toFixed(1)}s)`));
+            // clear "thinking…" line, print done
+            if (process.stdout.isTTY) process.stdout.write("\x1b[1A\x1b[2K");
+            process.stdout.write(chalk.hex("#555566")("  ⋯ ") + chalk.dim(`done (${((Date.now()-t0)/1000).toFixed(1)}s)`) + "\n");
             history.push({ role: "user", content: userText }, { role: "assistant", content: reply });
             printAssistant(reply);
         } catch (e) {
-            sp.fail("failed");
+            if (process.stdout.isTTY) process.stdout.write("\x1b[1A\x1b[2K");
             printError(e.message);
         }
     }
@@ -182,7 +198,7 @@ async function handleCommand(input) {
         } else if (sub === "install") {
             const src = tokens.slice(2).join(" ");
             if (!src) { printError("usage: /ext install <path-or-url>"); return; }
-            printInfo(`installing…`);
+            printInfo("installing…");
             const r = await installExtension(src);
             r.error ? printError(r.error) : (printSuccess(`installed: ${r.name}`), reloadAll());
         } else if (sub === "uninstall") {
@@ -240,7 +256,7 @@ async function handleCommand(input) {
             history.forEach((m, i) => {
                 const who  = m.role === "user" ? chalk.hex("#4A9EFF")("you") : chalk.hex("#4EC9B0")("gemini");
                 const body = String(m.content).replace(/\n/g, " ").slice(0, 90);
-                console.log(`  ${chalk.dim("["+( i+1)+"]")} ${who}  ${chalk.dim(body)}`);
+                console.log(`  ${chalk.dim("["+(i+1)+"]")} ${who}  ${chalk.dim(body)}`);
             });
             console.log("");
             break;
@@ -256,8 +272,7 @@ async function handleCommand(input) {
             printSuccess(`exported → ${arg}`);
             break;
 
-        case "/cwd":
-            printInfo(process.cwd()); break;
+        case "/cwd":   printInfo(process.cwd()); break;
 
         case "/cd":
             if (!arg) { printError("usage: /cd <path>"); break; }
@@ -274,10 +289,7 @@ async function handleCommand(input) {
             break;
 
         case "/exit": case "/quit":
-            cleanup();
-            printInfo("bye");
-            process.exit(0);
-            break;
+            cleanup(); console.log(""); process.exit(0); break;
 
         default:
             printError(`unknown command: ${cmd}  —  /help for list`);
@@ -285,13 +297,12 @@ async function handleCommand(input) {
 }
 
 // ─────────────────────────────────────────────────────────────────
-//  Main REPL loop
+//  Main
 // ─────────────────────────────────────────────────────────────────
 async function main() {
     process.stdout.write("\x1Bc");
     console.log(renderWelcome(memoryLoaded.length, extensions.length));
 
-    // Parse flags
     const argv = process.argv.slice(2);
     const positional = [];
     for (let i = 0; i < argv.length; i++) {
@@ -303,30 +314,30 @@ async function main() {
         else if (!a.startsWith("--"))           { positional.push(a); }
     }
 
-    // One-shot mode
     if (positional.length > 0) {
         await send(positional.join(" "));
-        cleanup();
-        process.exit(0);
+        cleanup(); process.exit(0);
     }
 
     showPrompt();
 
-    rl.on("line", async (input) => {
-        // If already processing, just show prompt again — do NOT block or pause stream
+    rl.on("line", async (rawLine) => {
+        // Decode paste encoding before doing anything else
+        const text = restorePaste(rawLine).trim();
+
+        if (!text) { showPrompt(); return; }
+
+        // Don't queue — just warn and re-prompt
         if (processing) {
             printWarning("still thinking…");
             showPrompt();
             return;
         }
 
-        const text = input.trim();
-        if (!text) { showPrompt(); return; }
-
         processing = true;
         try {
             if (text.startsWith("/")) await handleCommand(text);
-            else                      await send(input); // preserve original (may have \n from paste)
+            else                      await send(rawLine); // send rawLine; send() decodes internally
         } catch (e) {
             printError(e.message);
         } finally {
@@ -335,14 +346,9 @@ async function main() {
         }
     });
 
-    // 'close' fires on Ctrl+D — exit gracefully
-    rl.on("close", () => {
-        cleanup();
-        console.log("");
-        process.exit(0);
-    });
+    // readline 'close' = Ctrl+D via our manual handler, or rl.close() call
+    rl.on("close", () => { cleanup(); console.log(""); process.exit(0); });
 
-    // SIGINT (Ctrl+C) — cancel current operation or exit
     rl.on("SIGINT", () => {
         if (processing) {
             process.stdout.write("\n");
@@ -350,14 +356,8 @@ async function main() {
             showPrompt();
             return;
         }
-        // Not processing — treat as exit intent
-        cleanup();
-        console.log("");
-        process.exit(0);
+        cleanup(); console.log(""); process.exit(0);
     });
 }
 
-main().catch(e => {
-    console.error(chalk.red("fatal:"), e.message);
-    process.exit(1);
-});
+main().catch(e => { console.error(chalk.red("fatal:"), e.message); process.exit(1); });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ikyyofc/gemini-cli",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "AI CLI Agent powered by Gemini — your own terminal assistant",
   "type": "module",
   "main": "index.js",

package/src/agent.js

@@ -1,116 +1,115 @@
-// src/agent.js — ReAct agent loop using NATIVE Gemini function calling
+// src/agent.js — ReAct agent loop, native Gemini function calling
 import chalk from "chalk";
-import ora   from "ora";
 import { callGemini }   from "./gemini.js";
 import { GEMINI_TOOLS, executeTool } from "./tools.js";
 import { printAssistant, printError, printWarning, printToolCall, printToolResult } from "./renderer.js";
 
-/**
- * Run the agent loop until the model gives a final text answer (no more tool calls).
- *
- * Native function calling flow:
- *   1. Send contents + tools (functionDeclarations) to Gemini
- *   2. Response parts may contain: { functionCall: { name, args } }
- *   3. Execute the tool → get result
- *   4. Append model turn (with functionCall) + user turn (with functionResponse)
- *   5. Repeat until response has only text parts → done
- */
+// ─────────────────────────────────────────────────────────────────
+//  Static progress line — write once, no continuous redraw
+//  Safe when terminal loses focus (no ANSI overwrite loops)
+// ─────────────────────────────────────────────────────────────────
+function printStep(n, label) {
+    process.stdout.write(
+        chalk.hex("#555566")("  ⋯ ") +
+        chalk.dim(label) +
+        (n > 1 ? chalk.hex("#555566")(` (step ${n})`) : "") +
+        "\n"
+    );
+}
+
+function clearLastLine() {
+    // Move cursor up one line and clear it — only called right after printStep
+    // so we can replace "thinking…" with the actual tool section header
+    if (process.stdout.isTTY) {
+        process.stdout.write("\x1b[1A\x1b[2K");
+    }
+}
+
 export async function runAgentLoop(userMessage, history, {
     systemInstruction = null,
     autoApprove       = false,
     maxIterations     = 40,
 } = {}) {
 
-    // Build initial message list
     const messages = [
         ...history,
         { role: "user", content: userMessage }
     ];
 
-    let iteration = 0;
+    let iteration    = 0;
+    let sectionOpen  = false;
 
     while (iteration < maxIterations) {
         iteration++;
 
-        // ── Call Gemini API with tools ──────────────────────────
-        const spinner = ora({
-            text:         chalk.dim(iteration === 1 ? "thinking…" : `step ${iteration}…`),
-            spinner:      "dots",
-            color:        "cyan",
-            prefixText:   "  ",
-            discardStdin: false,   // prevent ora from pausing stdin after stop
-        }).start();
+        // Print a static "thinking…" line — written once, not looping
+        printStep(iteration, iteration === 1 ? "thinking…" : "thinking…");
 
         let parts;
         try {
             const res = await callGemini({ messages, tools: GEMINI_TOOLS, systemInstruction });
             parts = res.parts;
-            spinner.stop();
-            clearLine();
+            // Clear the "thinking…" line now that we have a response
+            clearLastLine();
         } catch (err) {
-            spinner.fail(chalk.hex("#F44747")("API error"));
+            clearLastLine();
             printError(err.message);
             return null;
         }
 
-        // ── Separate text parts from functionCall parts ─────────
-        const textParts = parts.filter(p => p.text != null);
+        const textParts = parts.filter(p => p.text   != null);
         const callParts = parts.filter(p => p.functionCall != null);
 
-        // Print any accompanying text (model thinking aloud)
+        // Model thinking aloud alongside tool calls
         const textContent = textParts.map(p => p.text).join("").trim();
         if (textContent && callParts.length > 0) {
             process.stdout.write(
-                chalk.dim("  …  " + textContent.replace(/\n/g, "\n       ")) + "\n"
+                chalk.hex("#555566")("  ┄ ") +
+                chalk.dim(textContent.split("\n")[0].slice(0, 80)) +
+                "\n"
             );
         }
 
-        // ── No tool calls → final answer ────────────────────────
+        // ── Final answer (no more tool calls) ─────────────────────
         if (callParts.length === 0) {
             const final = textParts.map(p => p.text).join("").trim();
-            // Close the tool section if it was opened
-            if (iteration > 1) {
+            if (sectionOpen) {
                 process.stdout.write(
                     chalk.hex("#4A9EFF")("  ╰") +
                     chalk.hex("#555566")("─".repeat(47)) + "\n"
                 );
+                sectionOpen = false;
             }
             if (final) printAssistant(final);
             return { finalResponse: final, iterations: iteration };
         }
 
-        // ── Execute each tool call ───────────────────────────────
+        // ── Tool calls ─────────────────────────────────────────────
         messages.push({ role: "model", parts });
 
-        // Print tool section header on first iteration
-        if (iteration === 1) {
+        if (!sectionOpen) {
             process.stdout.write(
                 "\n" + chalk.hex("#4A9EFF")("  ╭─ working") +
                 chalk.hex("#555566")(" " + "─".repeat(36)) + "\n"
             );
+            sectionOpen = true;
         }
 
         const responseParts = [];
-
         for (const part of callParts) {
             const { name, args } = part.functionCall;
             printToolCall(name, args);
-
             const result = await executeTool(name, args ?? {}, { autoApprove });
             printToolResult(result);
-
-            responseParts.push({
-                functionResponse: { name, response: result }
-            });
+            responseParts.push({ functionResponse: { name, response: result } });
         }
 
         messages.push({ role: "user", parts: responseParts });
     }
 
-    printWarning(`Max iterations (${maxIterations}) reached.`);
+    if (sectionOpen) {
+        process.stdout.write(chalk.hex("#4A9EFF")("  ╰") + chalk.hex("#555566")("─".repeat(47)) + "\n");
+    }
+    printWarning(`max iterations (${maxIterations}) reached`);
     return { finalResponse: null, iterations: iteration };
 }
-
-function clearLine() {
-    if (process.stdout.clearLine) { process.stdout.clearLine(0); process.stdout.cursorTo(0); }
-}

package/src/input.js

@@ -1,60 +1,96 @@
-// src/input.js — Bracketed paste via keypress interception
+// src/input.js — Bracketed paste via Transform stream (byte-level interception)
 //
-// No Transform stream. We intercept keypress events directly:
-//   \x1b[200~  → enter paste mode, start buffering lines
-//   \x1b[201~  → end paste mode, emit full buffer as one line
+// Keypress-based approach is unreliable because keypress events for \x1b[200~
+// may arrive AFTER readline has already fired 'line' events for the pasted lines.
+// Byte-level interception via Transform is the only reliable approach.
 //
-import readline from "readline";
+import { Transform } from "stream";
 
-export function enableBracketedPaste()  { process.stdout.write("\x1b[?2004h"); }
-export function disableBracketedPaste() { process.stdout.write("\x1b[?2004l"); }
+const PASTE_START = "\x1b[200~";
+const PASTE_END   = "\x1b[201~";
 
-/**
- * Attach bracketed paste interception to an existing readline interface.
- * readline must be created BEFORE calling this.
- */
-export function setupPaste(rl) {
-    // Make stdin emit 'keypress' events (readline may have already done this)
-    readline.emitKeypressEvents(process.stdin, rl);
-
-    let pasting  = false;
-    let pasteBuf = [];
-
-    // Watch for paste start/end escape sequences
-    const onKeypress = (_str, key) => {
-        if (!key) return;
-        const seq = key.sequence ?? "";
-
-        if (seq === "\x1b[200~") {
-            pasting  = true;
-            pasteBuf = [];
-            return;
-        }
+export class PasteTransform extends Transform {
+    constructor() {
+        super();
+        this._buf      = "";   // raw accumulator
+        this._pasting  = false;
+        this._pasteBuf = "";   // paste content accumulator
+    }
 
-        if (seq === "\x1b[201~") {
-            pasting = false;
-            const full = pasteBuf.join("\n");
-            pasteBuf = [];
-            // Fire the complete paste as one synthetic 'line' event
-            rl.emit("line", full);
-        }
-    };
+    _transform(chunk, _enc, cb) {
+        this._buf += chunk.toString("utf8");
+
+        let output = "";
+
+        while (this._buf.length > 0) {
+
+            if (!this._pasting) {
+                const si = this._buf.indexOf(PASTE_START);
+
+                if (si === -1) {
+                    // No paste start found — check for partial escape at tail
+                    const esc = this._buf.lastIndexOf("\x1b");
+                    if (esc !== -1 && (this._buf.length - esc) < PASTE_START.length) {
+                        // Could be partial escape sequence — flush safe part, hold rest
+                        output   += this._buf.slice(0, esc);
+                        this._buf = this._buf.slice(esc);
+                        break;
+                    }
+                    // No escape at all, pass through
+                    output   += this._buf;
+                    this._buf = "";
+                    break;
+                }
+
+                // Found paste start
+                output        += this._buf.slice(0, si);     // pass through text before it
+                this._buf      = this._buf.slice(si + PASTE_START.length);
+                this._pasting  = true;
+                this._pasteBuf = "";
 
-    process.stdin.on("keypress", onKeypress);
+            } else {
+                // Inside paste — look for end marker
+                const ei = this._buf.indexOf(PASTE_END);
 
-    // Patch rl.emit to swallow 'line' events while pasting
-    // (readline fires one per \n inside the paste — we buffer them)
-    const _emit = rl.emit.bind(rl);
-    rl.emit = function (event, ...args) {
-        if (event === "line" && pasting) {
-            pasteBuf.push(args[0] ?? "");
-            return false;
+                if (ei === -1) {
+                    // End not here yet — buffer everything and wait
+                    this._pasteBuf += this._buf;
+                    this._buf       = "";
+                    break;
+                }
+
+                // Found paste end
+                this._pasteBuf += this._buf.slice(0, ei);
+                this._buf       = this._buf.slice(ei + PASTE_END.length);
+                this._pasting   = false;
+
+                // Replace newlines with \x00 so readline treats whole paste as ONE line
+                const encoded = this._pasteBuf
+                    .replace(/\r\n/g, "\x00")
+                    .replace(/\r/g,   "\x00")
+                    .replace(/\n/g,   "\x00");
+
+                output        += encoded + "\n";  // \n makes readline fire one 'line' event
+                this._pasteBuf = "";
+            }
         }
-        return _emit(event, ...args);
-    };
 
-    return () => {
-        process.stdin.off("keypress", onKeypress);
-        rl.emit = _emit;
-    };
+        if (output) this.push(output);
+        cb();
+    }
+
+    _flush(cb) {
+        // Flush anything remaining
+        if (this._buf)      this.push(this._buf);
+        if (this._pasteBuf) this.push(this._pasteBuf);
+        cb();
+    }
 }
+
+/** Decode: \x00 → \n  (undo the encoding done above) */
+export function restorePaste(line) {
+    return line.replace(/\x00/g, "\n");
+}
+
+export function enableBracketedPaste()  { process.stdout.write("\x1b[?2004h"); }
+export function disableBracketedPaste() { process.stdout.write("\x1b[?2004l"); }