@ikyyofc/gemini-cli 1.0.1 → 1.0.3

package/index.js

@@ -19,8 +19,7 @@ import {
     printError, printInfo, printSuccess, printWarning
 } from "./src/renderer.js";
 import {
-    PasteTransform, restorePaste,
-    enableBracketedPaste, disableBracketedPaste
+    enableBracketedPaste, disableBracketedPaste, setupPaste
 } from "./src/input.js";
 
 // ─────────────────────────────────────────────────────────────────
@@ -34,8 +33,7 @@ let memoryContext = null;
 
 function reloadAll() {
     extensions    = loadExtensions();
-    const extra   = getExtensionContextDirs(extensions);
-    memoryLoaded  = loadMemory(extra);
+    memoryLoaded  = loadMemory(getExtensionContextDirs(extensions));
     memoryContext = buildContextString(memoryLoaded);
 }
 reloadAll();
@@ -51,49 +49,59 @@ let processing    = false;
 let agentMode     = true;
 let autoApprove   = false;
 
-function systemInstruction() {
+function sysInstruction() {
     return [memoryContext, sessionSystem].filter(Boolean).join("\n\n") || null;
 }
 
 // ─────────────────────────────────────────────────────────────────
-//  Readline — pipe stdin through PasteTransform first
+//  Readline — directly on process.stdin, NO transform stream
 // ─────────────────────────────────────────────────────────────────
-enableBracketedPaste();
-process.on("exit", disableBracketedPaste);
-
-const pasteStream = new PasteTransform();
-process.stdin.pipe(pasteStream);
-
 const rl = readline.createInterface({
-    input:     pasteStream,
-    output:    process.stdout,
-    terminal:  true,
+    input:       process.stdin,
+    output:      process.stdout,
+    terminal:    true,
     historySize: 200,
+    crlfDelay:   Infinity,
 });
 
-function prompt() {
-    const mode   = agentMode  ? chalk.hex("#4EC9B0")("agent") : chalk.dim("chat");
-    const yolo   = autoApprove ? chalk.red(" yolo") : "";
-    const file   = pendingFile ? chalk.yellow(` +${path.basename(pendingPath)}`) : "";
-    const turns  = history.length ? chalk.dim(` ${Math.ceil(history.length/2)}t`) : "";
-    const mem    = memoryLoaded.length ? chalk.dim(` m${memoryLoaded.length}`) : "";
+// 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 {}
+    }
+}
+process.on("exit", cleanup);
+process.on("SIGTERM", () => { cleanup(); process.exit(0); });
+
+// ─────────────────────────────────────────────────────────────────
+//  Prompt
+// ─────────────────────────────────────────────────────────────────
+function showPrompt() {
+    const mode  = agentMode     ? chalk.hex("#4EC9B0")("agent") : chalk.dim("chat");
+    const yolo  = autoApprove   ? chalk.red(" yolo")   : "";
+    const file  = pendingFile   ? chalk.yellow(` +${path.basename(pendingPath)}`) : "";
+    const turns = history.length ? chalk.dim(` ${Math.ceil(history.length/2)}t`)  : "";
+    const mem   = memoryLoaded.length ? chalk.dim(` m${memoryLoaded.length}`)     : "";
 
     rl.setPrompt(
-        "\n" +
-        chalk.dim("  ") + chalk.bold("❯") + " " +
-        chalk.dim("[") + mode + yolo + file + turns + mem + chalk.dim("]") +
-        " "
+        "\n  " + chalk.bold("❯") + " " +
+        chalk.dim("[") + mode + yolo + file + turns + mem + chalk.dim("]") + " "
     );
-    rl.prompt();
+    rl.prompt(true);
 }
 
 // ─────────────────────────────────────────────────────────────────
 //  File attachment
 // ─────────────────────────────────────────────────────────────────
-function attachFile(filePath) {
-    const p = path.resolve(filePath.trim().replace(/^['"]|['"]$/g, ""));
-    if (!fs.existsSync(p))                    { printError(`not found: ${p}`); return; }
-    if (fs.statSync(p).size > 20*1024*1024)   { printError("file too large (max 20MB)"); return; }
+function attachFile(fp) {
+    const p = path.resolve(fp.trim().replace(/^['"]|['"]$/g, ""));
+    if (!fs.existsSync(p))                  { printError(`not found: ${p}`); return; }
+    if (fs.statSync(p).size > 20*1024*1024) { printError("file too large (max 20MB)"); return; }
     pendingFile = fs.readFileSync(p);
     pendingPath = p;
     printSuccess(`attached ${path.basename(p)}`);
@@ -102,16 +110,14 @@ function attachFile(filePath) {
 // ─────────────────────────────────────────────────────────────────
 //  Send message
 // ─────────────────────────────────────────────────────────────────
-async function send(rawInput) {
-    // restorePaste turns \x00 back into \n (from bracketed paste)
-    const userText = restorePaste(rawInput).trim();
-    if (!userText) return;
+async function send(userText) {
+    if (!userText.trim()) return;
 
     printUser(userText + (pendingFile ? chalk.dim(` [${path.basename(pendingPath)}]`) : ""));
 
     if (agentMode) {
         const res = await runAgentLoop(userText, history, {
-            systemInstruction: systemInstruction(),
+            systemInstruction: sysInstruction(),
             autoApprove,
             maxIterations: 40,
         });
@@ -121,9 +127,9 @@ async function send(rawInput) {
         }
     } else {
         const { default: ora } = await import("ora");
-        const sp = ora({ text: "thinking…", spinner: "dots", color: "cyan", prefixText: "  " }).start();
+        const sp = ora({ text: "thinking…", spinner: "dots", color: "cyan", prefixText: "  ", discardStdin: false }).start();
         const msgs = [];
-        if (systemInstruction()) msgs.push({ role: "system", content: systemInstruction() });
+        if (sysInstruction()) msgs.push({ role: "system", content: sysInstruction() });
         msgs.push(...history, { role: "user", content: userText });
         try {
             const t0    = Date.now();
@@ -144,15 +150,14 @@ async function send(rawInput) {
 // ─────────────────────────────────────────────────────────────────
 //  Commands
 // ─────────────────────────────────────────────────────────────────
-async function command(input) {
+async function handleCommand(input) {
     const tokens = input.trim().split(/\s+/);
     const cmd    = tokens[0].toLowerCase();
     const arg    = tokens.slice(1).join(" ").trim();
 
-    // /memory
     if (cmd === "/memory") {
         const sub = tokens[1];
-        if (sub === "show")   { console.log(memoryShow(memoryLoaded)); }
+        if      (sub === "show")   { console.log(memoryShow(memoryLoaded)); }
         else if (sub === "reload") { reloadAll(); printSuccess(`reloaded — ${memoryLoaded.length} file(s)`); }
         else if (sub === "add") {
             const t = tokens.slice(2).join(" ");
@@ -162,7 +167,6 @@ async function command(input) {
         return;
     }
 
-    // /ext
     if (cmd === "/ext") {
         const sub  = tokens[1];
         const name = tokens[2];
@@ -172,29 +176,29 @@ async function command(input) {
             console.log("");
             list.forEach(e => {
                 const s = e.enabled ? chalk.green("✓") : chalk.dim("○");
-                console.log(`  ${s} ${chalk.bold(e.name)} ${chalk.dim("v"+e.version)} ${chalk.dim(e.description)}`);
+                console.log(`  ${s} ${chalk.bold(e.name)} ${chalk.dim("v"+e.version)}  ${chalk.dim(e.description)}`);
             });
             console.log("");
         } else if (sub === "install") {
             const src = tokens.slice(2).join(" ");
             if (!src) { printError("usage: /ext install <path-or-url>"); return; }
-            printInfo(`installing ${src}…`);
+            printInfo(`installing…`);
             const r = await installExtension(src);
             r.error ? printError(r.error) : (printSuccess(`installed: ${r.name}`), reloadAll());
         } else if (sub === "uninstall") {
-            if (!name) { printError("usage: /ext uninstall <name>"); return; }
+            if (!name) { printError("usage: /ext uninstall <n>"); return; }
             const r = await uninstallExtension(name);
             r.error ? printError(r.error) : (printSuccess(`removed: ${name}`), reloadAll());
         } else if (sub === "enable") {
-            if (!name) { printError("usage: /ext enable <name>"); return; }
+            if (!name) { printError("usage: /ext enable <n>"); return; }
             const r = enableExtension(name, true);
             r.error ? printError(r.error) : (printSuccess(`enabled: ${name}`), reloadAll());
         } else if (sub === "disable") {
-            if (!name) { printError("usage: /ext disable <name>"); return; }
+            if (!name) { printError("usage: /ext disable <n>"); return; }
             const r = enableExtension(name, false);
             r.error ? printError(r.error) : (printSuccess(`disabled: ${name}`), reloadAll());
         } else if (sub === "update") {
-            if (!name) { printError("usage: /ext update <name>"); return; }
+            if (!name) { printError("usage: /ext update <n>"); return; }
             printInfo(`updating ${name}…`);
             const r = await updateExtension(name);
             r.error ? printError(r.error) : (printSuccess(`updated: ${name}`), reloadAll());
@@ -220,12 +224,14 @@ async function command(input) {
 
         case "/agent":
             agentMode = !agentMode;
-            printInfo(`mode: ${agentMode ? chalk.hex("#4EC9B0")("agent") + " (tools on)" : chalk.dim("chat") + " (tools off)"}`);
+            printInfo(`mode → ${agentMode ? chalk.hex("#4EC9B0")("agent") : chalk.dim("chat")}`);
             break;
 
         case "/yolo":
             autoApprove = !autoApprove;
-            autoApprove ? printWarning("yolo on — no confirmations") : printInfo("yolo off — confirmations restored");
+            autoApprove
+                ? printWarning("yolo on — all tool actions auto-approved")
+                : printInfo("yolo off — confirmations restored");
             break;
 
         case "/history":
@@ -233,8 +239,8 @@ async function command(input) {
             console.log("");
             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, 80);
-                console.log(chalk.dim(`  [${i+1}] `) + who + chalk.dim(": ") + body);
+                const body = String(m.content).replace(/\n/g, " ").slice(0, 90);
+                console.log(`  ${chalk.dim("["+( i+1)+"]")} ${who}  ${chalk.dim(body)}`);
             });
             console.log("");
             break;
@@ -244,13 +250,14 @@ async function command(input) {
             fs.writeFileSync(path.resolve(arg), JSON.stringify({
                 exported_at: new Date().toISOString(),
                 mode: agentMode ? "agent" : "chat",
-                system: systemInstruction(),
-                messages: history
+                system: sysInstruction(),
+                messages: history,
             }, null, 2));
-            printSuccess(`exported to ${arg}`);
+            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; }
@@ -262,31 +269,29 @@ async function command(input) {
             printInfo(`model      gemini-pro-latest`);
             printInfo(`tools      ${agentMode ? "on (native function calling)" : "off"}`);
             printInfo(`yolo       ${autoApprove ? "on" : "off"}`);
-            printInfo(`memory     ${memoryLoaded.length} file(s)  |  extensions: ${extensions.length}`);
+            printInfo(`memory     ${memoryLoaded.length} file(s)  ·  extensions: ${extensions.length}`);
             printInfo(`config     ${GLOBAL_DIR}`);
             break;
 
         case "/exit": case "/quit":
-            printInfo("bye"); rl.close(); process.exit(0); break;
+            cleanup();
+            printInfo("bye");
+            process.exit(0);
+            break;
 
         default:
-            // Custom extension commands: /namespace:cmd <args>
-            if (cmd.slice(1).includes(":")) {
-                printError(`unknown command: ${cmd}  —  type /help`);
-            } else {
-                printError(`unknown command: ${cmd}  —  type /help`);
-            }
+            printError(`unknown command: ${cmd}  —  /help for list`);
     }
 }
 
 // ─────────────────────────────────────────────────────────────────
-//  Main
+//  Main REPL loop
 // ─────────────────────────────────────────────────────────────────
 async function main() {
     process.stdout.write("\x1Bc");
     console.log(renderWelcome(memoryLoaded.length, extensions.length));
 
-    // Parse CLI flags
+    // Parse flags
     const argv = process.argv.slice(2);
     const positional = [];
     for (let i = 0; i < argv.length; i++) {
@@ -294,40 +299,65 @@ async function main() {
         if      (a === "--system" && argv[i+1]) { sessionSystem = argv[++i]; }
         else if (a === "--file"   && argv[i+1]) { attachFile(argv[++i]); }
         else if (a === "--yolo")                { autoApprove = true; printWarning("yolo on"); }
-        else if (a === "--chat")                { agentMode   = false; }
+        else if (a === "--chat")                { agentMode = false; }
         else if (!a.startsWith("--"))           { positional.push(a); }
     }
 
     // One-shot mode
     if (positional.length > 0) {
         await send(positional.join(" "));
+        cleanup();
         process.exit(0);
     }
 
-    prompt();
+    showPrompt();
+
+    rl.on("line", async (input) => {
+        // If already processing, just show prompt again — do NOT block or pause stream
+        if (processing) {
+            printWarning("still thinking…");
+            showPrompt();
+            return;
+        }
 
-    rl.on("line", async raw => {
-        const input = restorePaste(raw).trim();
-        if (!input) { prompt(); return; }
-        if (processing) { printWarning("still thinking…"); prompt(); return; }
+        const text = input.trim();
+        if (!text) { showPrompt(); return; }
 
         processing = true;
-        rl.pause();
         try {
-            if (input.startsWith("/")) await command(input);
-            else                       await send(raw);   // pass raw so send() can restorePaste
+            if (text.startsWith("/")) await handleCommand(text);
+            else                      await send(input); // preserve original (may have \n from paste)
+        } catch (e) {
+            printError(e.message);
         } finally {
             processing = false;
-            rl.resume();
-            prompt();
+            showPrompt();
         }
     });
 
-    rl.on("close", () => { console.log(""); process.exit(0); });
+    // 'close' fires on Ctrl+D — exit gracefully
+    rl.on("close", () => {
+        cleanup();
+        console.log("");
+        process.exit(0);
+    });
+
+    // SIGINT (Ctrl+C) — cancel current operation or exit
     rl.on("SIGINT", () => {
-        if (processing) { printWarning("press Ctrl+C again to force quit"); return; }
-        rl.close();
+        if (processing) {
+            process.stdout.write("\n");
+            printWarning("ctrl+c again or /exit to quit");
+            showPrompt();
+            return;
+        }
+        // Not processing — treat as exit intent
+        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.1",
+  "version": "1.0.3",
   "description": "AI CLI Agent powered by Gemini — your own terminal assistant",
   "type": "module",
   "main": "index.js",

package/src/agent.js

@@ -34,10 +34,11 @@ export async function runAgentLoop(userMessage, history, {
 
         // ── Call Gemini API with tools ──────────────────────────
         const spinner = ora({
-            text:       chalk.hex("#858585")(iteration === 1 ? " Thinking…" : ` Step ${iteration}…`),
-            spinner:    "dots12",
-            color:      "cyan",
-            prefixText: " "
+            text:         chalk.dim(iteration === 1 ? "thinking…" : `step ${iteration}…`),
+            spinner:      "dots",
+            color:        "cyan",
+            prefixText:   "  ",
+            discardStdin: false,   // prevent ora from pausing stdin after stop
         }).start();
 
         let parts;
@@ -60,9 +61,7 @@ export async function runAgentLoop(userMessage, history, {
         const textContent = textParts.map(p => p.text).join("").trim();
         if (textContent && callParts.length > 0) {
             process.stdout.write(
-                "\n" + chalk.hex("#858585").italic(
-                    "  💭 " + textContent.replace(/\n/g, "\n     ")
-                ) + "\n\n"
+                chalk.dim("  …  " + textContent.replace(/\n/g, "\n       ")) + "\n"
             );
         }
 
@@ -110,32 +109,32 @@ function printToolCall(name, args = {}) {
     const preview = Object.entries(args)
         .map(([k, v]) => {
             const s = String(v);
-            return chalk.hex("#9CDCFE")(k) + chalk.hex("#858585")(":") +
-                   chalk.hex("#CE9178")(s.length > 60 ? s.slice(0, 60) + "…" : s);
+            return chalk.dim(k + ":") + (s.length > 60 ? s.slice(0, 60) + "…" : s);
         })
         .join("  ");
 
     process.stdout.write(
-        chalk.hex("#DCDCAA")("  ⚙ ") +
-        chalk.hex("#569CD6").bold(name) +
-        (preview ? chalk.hex("#858585")("  (" + preview + ")") : "") + "\n"
+        "  " + chalk.dim("run") + "  " +
+        chalk.hex("#569CD6")(name) +
+        (preview ? chalk.dim("  " + preview) : "") + "\n"
     );
 }
 
 function printToolResult(result, name) {
-    const text  = typeof result === "object" ? (result.result ?? result.error ?? JSON.stringify(result)) : String(result);
+    const text  = typeof result === "object"
+        ? (result.result ?? result.error ?? JSON.stringify(result))
+        : String(result);
     const isErr = typeof result === "object" && result.error;
-    const color = isErr ? chalk.hex("#F44747") : chalk.hex("#6A9955");
-    const lines = text.split("\n").slice(0, 15);
-    const more  = text.split("\n").length > 15 ? `\n    … (+${text.split("\n").length - 15} lines)` : "";
+    const color = isErr ? chalk.red : chalk.dim;
+    const lines = text.split("\n").slice(0, 12);
+    const more  = text.split("\n").length > 12
+        ? chalk.dim(`\n       … +${text.split("\n").length - 12} lines`) : "";
 
     process.stdout.write(
-        color("  └ ") +
-        chalk.hex("#858585")(lines.join("\n    ")) +
-        more + "\n\n"
+        "       " + color(lines.join("\n       ")) + more + "\n"
     );
 }
 
 function clearLine() {
     if (process.stdout.clearLine) { process.stdout.clearLine(0); process.stdout.cursorTo(0); }
-}
+}

package/src/input.js

@@ -1,88 +1,60 @@
-// src/input.js — Bracketed paste mode via Transform stream
+// src/input.js — Bracketed paste via keypress interception
 //
-// How it works:
-//   Terminal sends:  \x1b[200~ <pasted text with \n> \x1b[201~
-//   We detect start/end, collect paste buffer, replace \n with \x00
-//   so readline treats it as ONE line, then restore \n in the handler.
+// 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
 //
-import { Transform } from "stream";
+import readline from "readline";
 
-const PASTE_START = "\x1b[200~";
-const PASTE_END   = "\x1b[201~";
-
-export class PasteTransform extends Transform {
-    constructor() {
-        super();
-        this._pasting = false;
-        this._pasteBuf = "";
-        this._raw = "";  // accumulate raw bytes for sequence detection
-    }
-
-    _transform(chunk, _enc, cb) {
-        this._raw += chunk.toString("utf8");
-
-        let out = "";
-
-        while (this._raw.length > 0) {
-            // ── Paste START ──────────────────────────────────────────
-            const si = this._raw.indexOf(PASTE_START);
-            if (!this._pasting && si !== -1) {
-                // pass through everything before the sequence
-                out += this._raw.slice(0, si);
-                this._pasting  = true;
-                this._pasteBuf = "";
-                this._raw      = this._raw.slice(si + PASTE_START.length);
-                continue;
-            }
-
-            // ── Paste END ────────────────────────────────────────────
-            const ei = this._raw.indexOf(PASTE_END);
-            if (this._pasting && ei !== -1) {
-                // collect everything up to end marker
-                this._pasteBuf += this._raw.slice(0, ei);
-                this._raw       = this._raw.slice(ei + PASTE_END.length);
-                this._pasting   = false;
-
-                // Replace newlines with \x00 so readline sees ONE line
-                // (\x00 is a null byte readline won't split on)
-                const safe = this._pasteBuf.replace(/\r\n/g, "\x00").replace(/\n/g, "\x00");
-                out += safe + "\n";   // the trailing \n makes readline fire one line event
-                this._pasteBuf = "";
-                continue;
-            }
-
-            // ── Inside paste, no end yet — wait for more data ────────
-            if (this._pasting) {
-                this._pasteBuf += this._raw;
-                this._raw = "";
-                break;
-            }
+export function enableBracketedPaste()  { process.stdout.write("\x1b[?2004h"); }
+export function disableBracketedPaste() { process.stdout.write("\x1b[?2004l"); }
 
-            // ── Partial escape sequence at end — wait for more data ──
-            if (this._raw.startsWith("\x1b") && this._raw.length < PASTE_START.length) {
-                break;
-            }
+/**
+ * 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;
+        }
 
-            // ── Normal data ──────────────────────────────────────────
-            out += this._raw;
-            this._raw = "";
+        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);
         }
+    };
 
-        if (out) this.push(out);
-        cb();
-    }
+    process.stdin.on("keypress", onKeypress);
 
-    _flush(cb) {
-        if (this._pasteBuf) this.push(this._pasteBuf);
-        cb();
-    }
-}
+    // 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;
+        }
+        return _emit(event, ...args);
+    };
 
-/** Restore \x00 → \n in a line received from readline */
-export function restorePaste(line) {
-    return line.replace(/\x00/g, "\n");
+    return () => {
+        process.stdin.off("keypress", onKeypress);
+        rl.emit = _emit;
+    };
 }
-
-/** Enable/disable bracketed paste mode on the terminal */
-export function enableBracketedPaste()  { process.stdout.write("\x1b[?2004h"); }
-export function disableBracketedPaste() { process.stdout.write("\x1b[?2004l"); }