@ikyyofc/gemini-cli 1.0.3 → 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.3",
+  "version": "1.0.5",
   "description": "AI CLI Agent powered by Gemini — your own terminal assistant",
   "type": "module",
   "main": "index.js",

package/src/agent.js

@@ -3,7 +3,7 @@ import chalk from "chalk";
 import ora   from "ora";
 import { callGemini }   from "./gemini.js";
 import { GEMINI_TOOLS, executeTool } from "./tools.js";
-import { printAssistant, printError, printWarning } from "./renderer.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).
@@ -68,15 +68,28 @@ export async function runAgentLoop(userMessage, history, {
         // ── No tool calls → final answer ────────────────────────
         if (callParts.length === 0) {
             const final = textParts.map(p => p.text).join("").trim();
+            // Close the tool section if it was opened
+            if (iteration > 1) {
+                process.stdout.write(
+                    chalk.hex("#4A9EFF")("  ╰") +
+                    chalk.hex("#555566")("─".repeat(47)) + "\n"
+                );
+            }
             if (final) printAssistant(final);
             return { finalResponse: final, iterations: iteration };
         }
 
         // ── Execute each tool call ───────────────────────────────
-        // Append the model's turn (contains functionCall parts) to history
         messages.push({ role: "model", parts });
 
-        // Build the functionResponse turn
+        // Print tool section header on first iteration
+        if (iteration === 1) {
+            process.stdout.write(
+                "\n" + chalk.hex("#4A9EFF")("  ╭─ working") +
+                chalk.hex("#555566")(" " + "─".repeat(36)) + "\n"
+            );
+        }
+
         const responseParts = [];
 
         for (const part of callParts) {
@@ -84,17 +97,13 @@ export async function runAgentLoop(userMessage, history, {
             printToolCall(name, args);
 
             const result = await executeTool(name, args ?? {}, { autoApprove });
-            printToolResult(result, name);
+            printToolResult(result);
 
             responseParts.push({
-                functionResponse: {
-                    name,
-                    response: result  // the entire result object goes here
-                }
+                functionResponse: { name, response: result }
             });
         }
 
-        // Append user turn with all function responses
         messages.push({ role: "user", parts: responseParts });
     }
 
@@ -102,39 +111,6 @@ export async function runAgentLoop(userMessage, history, {
     return { finalResponse: null, iterations: iteration };
 }
 
-// ─────────────────────────────────────────────────────────────────
-//  Terminal rendering helpers for tool calls
-// ─────────────────────────────────────────────────────────────────
-function printToolCall(name, args = {}) {
-    const preview = Object.entries(args)
-        .map(([k, v]) => {
-            const s = String(v);
-            return chalk.dim(k + ":") + (s.length > 60 ? s.slice(0, 60) + "…" : s);
-        })
-        .join("  ");
-
-    process.stdout.write(
-        "  " + 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 isErr = typeof result === "object" && result.error;
-    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(lines.join("\n       ")) + more + "\n"
-    );
-}
-
 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"); }

package/src/renderer.js

@@ -1,6 +1,23 @@
-// src/renderer.js — Clean, minimal terminal UI
+// src/renderer.js
 import chalk from "chalk";
 
+// Accent colors
+const C = {
+    blue:    "#4A9EFF",
+    teal:    "#1DB8A0",
+    dim:     "#555566",
+    code:    "#CE9178",
+    kw:      "#569CD6",
+    str:     "#CE9178",
+    comment: "#6A9955",
+    num:     "#B5CEA8",
+    fn:      "#DCDCAA",
+    green:   "#4EC9B0",
+    yellow:  "#E5C07B",
+    red:     "#E06C75",
+    white:   "#CDD6F4",
+};
+
 // ─────────────────────────────────────────────────────────────────
 //  Syntax highlighting
 // ─────────────────────────────────────────────────────────────────
@@ -9,13 +26,13 @@ const KW = {
     ts: /\b(const|let|var|function|return|if|else|for|while|switch|case|class|extends|import|export|default|async|await|try|catch|type|interface|enum|implements|declare|readonly|abstract|as|keyof|never|any|string|number|boolean|null|undefined|true|false)\b/g,
     py: /\b(def|class|return|if|elif|else|for|while|import|from|as|with|try|except|finally|raise|pass|break|continue|and|or|not|in|is|None|True|False|lambda|yield|global|async|await)\b/g,
     go: /\b(func|return|if|else|for|range|switch|var|const|type|struct|interface|import|package|defer|go|chan|map|make|new|nil|true|false)\b/g,
-    sh: /\b(if|then|else|elif|fi|for|while|do|done|case|esac|function|return|exit|export|echo|local|source)\b/g,
+    sh: /\b(if|then|else|elif|fi|for|while|do|done|case|esac|function|return|exit|export|echo|local|source|cd|mkdir|rm|cp|mv)\b/g,
     rs: /\b(fn|let|mut|return|if|else|for|match|use|mod|pub|struct|enum|impl|trait|type|const|async|await|true|false|None|Some|Ok|Err)\b/g,
 };
 const LANGMAP = {
     javascript:"js",js:"js",typescript:"ts",ts:"ts",
     python:"py",py:"py",go:"go",golang:"go",
-    rust:"rs",rs:"rs",bash:"sh",sh:"sh",shell:"sh",zsh:"sh"
+    rust:"rs",rs:"rs",bash:"sh",sh:"sh",shell:"sh",zsh:"sh",fish:"sh",
 };
 
 function highlight(code, lang = "") {
@@ -24,11 +41,11 @@ function highlight(code, lang = "") {
     const saved = [];
     const save = s => { const id = `\x00${saved.length}\x00`; saved.push(s); return id; };
 
-    r = r.replace(/(\/\/.*$|#.*$|\/\*[\s\S]*?\*\/)/gm, m => save(chalk.hex("#6A9955").italic(m)));
-    r = r.replace(/("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`)/g, m => save(chalk.hex("#CE9178")(m)));
-    if (KW[l]) r = r.replace(KW[l], m => save(chalk.hex("#569CD6")(m)));
-    r = r.replace(/\b(\d+\.?\d*)\b/g, m => save(chalk.hex("#B5CEA8")(m)));
-    r = r.replace(/\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*(?=\()/g, m => save(chalk.hex("#DCDCAA")(m)));
+    r = r.replace(/(\/\/.*$|#.*$|\/\*[\s\S]*?\*\/)/gm,  m => save(chalk.hex(C.comment).italic(m)));
+    r = r.replace(/("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`)/g, m => save(chalk.hex(C.str)(m)));
+    if (KW[l]) r = r.replace(KW[l], m => save(chalk.hex(C.kw).bold(m)));
+    r = r.replace(/\b(\d+\.?\d*)\b/g, m => save(chalk.hex(C.num)(m)));
+    r = r.replace(/\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*(?=\()/g, m => save(chalk.hex(C.fn)(m)));
     return r.replace(/\x00(\d+)\x00/g, (_, i) => saved[parseInt(i)]);
 }
 
@@ -38,22 +55,46 @@ function highlight(code, lang = "") {
 export function renderMarkdown(text) {
     let r = text;
 
-    // Fenced code blocks
+    // Fenced code blocks — with line gutter
     r = r.replace(/```(\w*)\n?([\s\S]*?)```/g, (_, lang, code) => {
-        const hl   = highlight(code.trimEnd(), lang);
-        const lbl  = lang ? chalk.dim(` ${lang} `) : "";
-        const top  = chalk.dim("┄".repeat(40)) + lbl;
-        const body = hl.split("\n").map(l => "  " + l).join("\n");
-        return `\n  ${top}\n${body}\n  ${chalk.dim("┄".repeat(40))}\n`;
+        const trimmed = code.trimEnd();
+        const lines   = trimmed.split("\n");
+        const hl      = highlight(trimmed, lang);
+        const hlLines = hl.split("\n");
+        const lbl     = lang
+            ? chalk.hex(C.blue).bold(` ${lang} `)
+            : "";
+        const gutterW = String(lines.length).length;
+
+        const header = chalk.hex(C.dim)("  ╭") +
+                       chalk.hex(C.dim)("─".repeat(2)) +
+                       lbl +
+                       chalk.hex(C.dim)("─".repeat(Math.max(0, 40 - lang.length - 2))) +
+                       "╮";
+        const footer = chalk.hex(C.dim)("  ╰" + "─".repeat(44) + "╯");
+        const body   = hlLines.map((l, i) => {
+            const n = chalk.hex(C.dim)(String(i + 1).padStart(gutterW));
+            return chalk.hex(C.dim)("  │ ") + n + chalk.hex(C.dim)(" │ ") + l;
+        }).join("\n");
+
+        return `\n${header}\n${body}\n${footer}\n`;
     });
 
     // Inline code
-    r = r.replace(/`([^`\n]+)`/g, (_, c) => chalk.hex("#CE9178")(`\`${c}\``));
+    r = r.replace(/`([^`\n]+)`/g, (_, c) =>
+        chalk.hex(C.code)("‹") + chalk.hex(C.code).bold(c) + chalk.hex(C.code)("›")
+    );
 
     // Headers
-    r = r.replace(/^### (.+)$/gm, (_, t) => "\n" + chalk.bold(t));
-    r = r.replace(/^## (.+)$/gm,  (_, t) => "\n" + chalk.bold.underline(t));
-    r = r.replace(/^# (.+)$/gm,   (_, t) => "\n" + chalk.bold.underline(t));
+    r = r.replace(/^### (.+)$/gm, (_, t) =>
+        "\n" + chalk.hex(C.yellow).bold("  › " + t)
+    );
+    r = r.replace(/^## (.+)$/gm, (_, t) =>
+        "\n" + chalk.hex(C.blue).bold("  ›› " + t)
+    );
+    r = r.replace(/^# (.+)$/gm, (_, t) =>
+        "\n" + chalk.hex(C.teal).bold("  ▸ " + t.toUpperCase())
+    );
 
     // Bold / italic
     r = r.replace(/\*\*\*(.+?)\*\*\*/g, (_, t) => chalk.bold.italic(t));
@@ -61,124 +102,225 @@ export function renderMarkdown(text) {
     r = r.replace(/\*(.+?)\*/g,          (_, t) => chalk.italic(t));
 
     // Blockquotes
-    r = r.replace(/^> (.+)$/gm, (_, t) => chalk.dim("▌ ") + chalk.italic(t));
+    r = r.replace(/^> (.+)$/gm, (_, t) =>
+        chalk.hex(C.blue)("  ▌ ") + chalk.hex(C.white).italic(t)
+    );
 
     // Lists
-    r = r.replace(/^(\s*)[*\-+] (.+)$/gm, (_, i, t) => `${i}  · ${t}`);
-    r = r.replace(/^(\s*)(\d+)\. (.+)$/gm, (_, i, n, t) => `${i}  ${chalk.bold(n+".")} ${t}`);
+    r = r.replace(/^(\s*)[*\-+] (.+)$/gm,  (_, ind, t) =>
+        ind + chalk.hex(C.teal)("  ◆ ") + t
+    );
+    r = r.replace(/^(\s*)(\d+)\. (.+)$/gm, (_, ind, n, t) =>
+        ind + chalk.hex(C.blue)("  " + n + ". ") + t
+    );
 
     // HR
-    r = r.replace(/^---+$/gm, chalk.dim("─".repeat(48)));
+    r = r.replace(/^---+$/gm,
+        chalk.hex(C.dim)("  " + "─".repeat(50))
+    );
 
     return r;
 }
 
 // ─────────────────────────────────────────────────────────────────
-//  Message printers  (clean, no heavy boxing)
+//  Message printers
 // ─────────────────────────────────────────────────────────────────
 export function printUser(text) {
-    // Show multi-line messages cleanly
     const lines = text.split("\n");
-    const prefix = chalk.hex("#4A9EFF").bold("  you  ");
-    if (lines.length === 1) {
-        process.stdout.write("\n" + prefix + chalk.white(text) + "\n");
-    } else {
-        process.stdout.write("\n" + prefix + chalk.white(lines[0]) + "\n");
-        lines.slice(1).forEach(l => process.stdout.write("         " + chalk.white(l) + "\n"));
+    const isMulti = lines.length > 1;
+
+    // Single line: compact
+    if (!isMulti) {
+        process.stdout.write(
+            "\n" +
+            chalk.hex(C.blue)("  ╸ ") +
+            chalk.hex(C.blue).bold("you  ") +
+            chalk.hex(C.white)(text) +
+            "\n"
+        );
+        return;
     }
+
+    // Multi-line (pasted code): show with left bar
+    process.stdout.write(
+        "\n" +
+        chalk.hex(C.blue)("  ╸ ") +
+        chalk.hex(C.blue).bold("you") +
+        chalk.hex(C.dim)(`  (${lines.length} lines)`) +
+        "\n"
+    );
+    lines.forEach(l =>
+        process.stdout.write(chalk.hex(C.blue)("  │ ") + chalk.hex(C.white)(l) + "\n")
+    );
+    process.stdout.write(chalk.hex(C.blue)("  ╹") + "\n");
 }
 
 export function printAssistant(text) {
-    const label = chalk.hex("#4EC9B0").bold("gemini ");
-    const lines = renderMarkdown(text).split("\n");
-    process.stdout.write("\n");
-    lines.forEach((line, i) => {
-        const pre = i === 0 ? "  " + label : "         ";
-        process.stdout.write(pre + line + "\n");
-    });
-    process.stdout.write("\n");
+    const rendered = renderMarkdown(text);
+    const lines    = rendered.split("\n");
+
+    process.stdout.write(
+        "\n" +
+        chalk.hex(C.teal)("  ╸ ") +
+        chalk.hex(C.teal).bold("gemini") +
+        "\n"
+    );
+
+    lines.forEach(l =>
+        process.stdout.write(chalk.hex(C.teal)("  │ ") + l + "\n")
+    );
+
+    process.stdout.write(chalk.hex(C.teal)("  ╹") + "\n\n");
 }
 
+// ─────────────────────────────────────────────────────────────────
+//  Status messages
+// ─────────────────────────────────────────────────────────────────
 export function printError(msg) {
-    process.stdout.write(chalk.red("  error  ") + chalk.dim(msg) + "\n");
+    process.stdout.write(
+        "\n" +
+        chalk.hex(C.red)("  ✗ ") +
+        chalk.hex(C.red).bold("error  ") +
+        chalk.white(msg) +
+        "\n\n"
+    );
 }
 export function printInfo(msg) {
-    process.stdout.write(chalk.dim("  info   ") + msg + "\n");
+    process.stdout.write(
+        chalk.hex(C.dim)("  · ") +
+        chalk.hex(C.white)(msg) +
+        "\n"
+    );
 }
 export function printSuccess(msg) {
-    process.stdout.write(chalk.green("  ✓      ") + msg + "\n");
+    process.stdout.write(
+        chalk.hex(C.teal)("  ✓ ") +
+        chalk.hex(C.teal)(msg) +
+        "\n"
+    );
 }
 export function printWarning(msg) {
-    process.stdout.write(chalk.yellow("  warn   ") + msg + "\n");
+    process.stdout.write(
+        chalk.hex(C.yellow)("  ⚠ ") +
+        chalk.hex(C.yellow)(msg) +
+        "\n"
+    );
 }
 
 // ─────────────────────────────────────────────────────────────────
-//  Welcome
+//  Tool call display (used by agent.js)
+// ─────────────────────────────────────────────────────────────────
+export function printToolCall(name, args = {}) {
+    const argStr = Object.entries(args)
+        .map(([k, v]) => {
+            const s = String(v);
+            return chalk.hex(C.dim)(k + ":") + chalk.hex(C.code)(s.length > 55 ? s.slice(0, 55) + "…" : s);
+        })
+        .join("  ");
+
+    process.stdout.write(
+        chalk.hex(C.blue)("  ├─ ") +
+        chalk.hex(C.blue).bold(name) +
+        (argStr ? "  " + argStr : "") +
+        "\n"
+    );
+}
+
+export function printToolResult(result) {
+    const isErr = typeof result === "object" && result.error;
+    const text  = typeof result === "object"
+        ? (result.result ?? result.error ?? JSON.stringify(result))
+        : String(result);
+    const color = isErr ? chalk.hex(C.red) : chalk.hex(C.dim);
+    const lines = text.split("\n");
+    const shown = lines.slice(0, 10);
+    const extra = lines.length > 10 ? chalk.hex(C.dim)(`  +${lines.length - 10} more lines`) : "";
+
+    shown.forEach(l =>
+        process.stdout.write(chalk.hex(C.dim)("  │  ") + color(l) + "\n")
+    );
+    if (extra) process.stdout.write("  " + extra + "\n");
+}
+
+// ─────────────────────────────────────────────────────────────────
+//  Welcome screen
 // ─────────────────────────────────────────────────────────────────
 export function renderWelcome(memCount = 0, extCount = 0) {
     const stats = [
-        memCount  ? `${memCount} context file${memCount > 1 ? "s" : ""}` : null,
-        extCount  ? `${extCount} extension${extCount > 1 ? "s" : ""}` : null,
-    ].filter(Boolean).join("  ·  ");
+        memCount ? `${memCount} context file${memCount > 1 ? "s" : ""}` : null,
+        extCount ? `${extCount} extension${extCount > 1 ? "s" : ""}` : null,
+    ].filter(Boolean);
+
+    const sep = chalk.hex(C.blue)("  " + "━".repeat(46));
 
     return [
         "",
-        chalk.hex("#4EC9B0").bold("  Gemini CLI") +
-            chalk.dim("  ─  AI Agent  ─  native function calling"),
-        stats ? chalk.dim("  " + stats) : "",
-        chalk.dim("  /help for commands  ·  paste code freely  ·  /agent to toggle tools"),
+        sep,
+        chalk.hex(C.teal).bold("  Gemini CLI") +
+            chalk.hex(C.dim)("  ─  AI Agent  ─  native function calling"),
+        sep,
+        stats.length
+            ? chalk.hex(C.dim)("  ") + chalk.hex(C.white)(stats.join("  ·  "))
+            : "",
+        chalk.hex(C.dim)("  /help") +
+            chalk.hex(C.dim)(" for commands  ·  ") +
+            chalk.hex(C.dim)("/agent") +
+            chalk.hex(C.dim)(" to toggle tools"),
         "",
     ].join("\n");
 }
 
 // ─────────────────────────────────────────────────────────────────
-//  Help
+//  Help screen
 // ─────────────────────────────────────────────────────────────────
 export function renderHelp(customCommands = {}) {
-    const section = (title, rows) => [
-        "",
-        chalk.dim("  " + title),
-        chalk.dim("  " + "─".repeat(48)),
-        ...rows.map(([cmd, desc]) =>
-            "  " + chalk.hex("#CE9178")(cmd.padEnd(26)) + chalk.dim(desc)
-        ),
-    ].join("\n");
+    const sep = chalk.hex(C.dim)("  " + "─".repeat(50));
+
+    const row = (cmd, desc) =>
+        "  " +
+        chalk.hex(C.blue).bold(cmd.padEnd(28)) +
+        chalk.hex(C.dim)(desc);
 
     const lines = [
-        section("COMMANDS", [
-            ["/agent",             "Toggle agent (tools) ↔ chat mode"],
-            ["/yolo",              "Skip all tool confirmations"],
-            ["/memory show",       "Show loaded GEMINI.md files"],
-            ["/memory reload",     "Reload context from disk"],
-            ["/memory add <text>", "Append to ~/.gemini/GEMINI.md"],
-            ["/ext list",          "List extensions"],
-            ["/ext install <src>", "Install extension (path or git URL)"],
-            ["/ext uninstall <n>", "Remove extension"],
-            ["/ext enable/disable <n>", "Toggle extension"],
-            ["/ext update <n>",    "Pull latest (git)"],
-            ["/file <path>",       "Attach file to next message"],
-            ["/system <text>",     "Set system instruction"],
-            ["/history",           "Show conversation turns"],
-            ["/export <file>",     "Export history to JSON"],
-            ["/cd <path>",         "Change working directory"],
-            ["/new  /clear",       "Reset conversation"],
-            ["/model",             "Show model info"],
-            ["/exit  /quit",       "Exit"],
-        ]),
+        "",
+        chalk.hex(C.teal).bold("  Commands"),
+        sep,
+        row("/agent",              "Toggle agent mode (tools on/off)"),
+        row("/yolo",               "Skip all tool confirmations"),
+        sep,
+        row("/memory show",        "Show loaded GEMINI.md files"),
+        row("/memory reload",      "Reload context from disk"),
+        row("/memory add <text>",  "Append to ~/.gemini/GEMINI.md"),
+        sep,
+        row("/ext list",           "List installed extensions"),
+        row("/ext install <src>",  "Install from path or git URL"),
+        row("/ext uninstall <n>",  "Remove extension"),
+        row("/ext enable <n>",     "Enable extension"),
+        row("/ext disable <n>",    "Disable extension"),
+        row("/ext update <n>",     "Pull latest from git"),
+        sep,
+        row("/file <path>",        "Attach file to next message"),
+        row("/system <text>",      "Set system instruction"),
+        row("/history",            "Show conversation turns"),
+        row("/export <file>",      "Export history to JSON"),
+        row("/cd <path>",          "Change working directory"),
+        row("/new  /clear",        "Reset conversation"),
+        row("/model",              "Show model & config"),
+        row("/exit  /quit",        "Exit"),
     ];
 
     const cmds = Object.entries(customCommands);
     if (cmds.length) {
-        lines.push(section("EXTENSION COMMANDS",
-            cmds.map(([k, c]) => ["/" + k, c.description ?? ""])
-        ));
+        lines.push("", chalk.hex(C.teal).bold("  Extension Commands"), sep);
+        cmds.forEach(([k, c]) => lines.push(row("/" + k, c.description ?? "")));
     }
 
     lines.push(
         "",
-        chalk.dim("  Paste multi-line code freely — input is collected until you press Enter."),
-        chalk.dim("  Ctrl+C cancel  ·  Ctrl+D exit"),
-        ""
+        chalk.hex(C.dim)("  Paste multi-line code freely — collected as one input."),
+        chalk.hex(C.dim)("  Ctrl+C  cancel/exit  ·  Ctrl+D  exit"),
+        "",
     );
+
     return lines.join("\n");
 }