@ikyyofc/gemini-cli 1.0.4 → 1.0.5

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,26 +55,31 @@ 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("SIGTERM", () => { cleanup(); process.exit(0); });
@@ -96,7 +102,7 @@ function showPrompt() {
 }
 
 // ─────────────────────────────────────────────────────────────────
-//  File attachment
+//  Attach file
 // ─────────────────────────────────────────────────────────────────
 function attachFile(fp) {
     const p = path.resolve(fp.trim().replace(/^['"]|['"]$/g, ""));
@@ -110,8 +116,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)}]`) : ""));
 
@@ -127,7 +135,10 @@ async function send(userText) {
         }
     } else {
         const { default: ora } = await import("ora");
-        const sp = ora({ text: "thinking…", spinner: "dots", color: "cyan", prefixText: "  ", discardStdin: false }).start();
+        const sp = ora({
+            text: "thinking…", spinner: "dots", color: "cyan",
+            prefixText: "  ", discardStdin: false
+        }).start();
         const msgs = [];
         if (sysInstruction()) msgs.push({ role: "system", content: sysInstruction() });
         msgs.push(...history, { role: "user", content: userText });
@@ -182,7 +193,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 +251,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 +267,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 +284,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 +292,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 +309,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 +341,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 +351,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.5",
   "description": "AI CLI Agent powered by Gemini — your own terminal assistant",
   "type": "module",
   "main": "index.js",

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"); }