@oxecli/oxe 1.0.65 → 1.0.67

package/dist/cli.js

@@ -466,7 +466,10 @@ export class CLI {
                         this.story[this.story.length - 1]["type"] === "user") {
                         this.story.pop();
                     }
-                    if (this.interruptPending) {
+                    // Exit cleanly on: a second Ctrl+C, or a first Ctrl+C while idle
+                    // (no active query). Only an in-flight query's first Ctrl+C keeps
+                    // running so the agent can be interrupted without a stray key exiting.
+                    if (this.interruptPending || !wasActive) {
                         this.saveSession(engine);
                         await engine.cleanupStoredResponses();
                         process.stdout.write("\nClosing terminal session. Goodbye!\n\n");
@@ -474,9 +477,7 @@ export class CLI {
                     }
                     this.interruptPending = true;
                     process.stdout.write("\n");
-                    process.stdout.write(wasActive
-                        ? "\x1b[2mInterrupted agent. Press Ctrl+C again to exit, or type a new prompt.\x1b[0m\n"
-                        : "\x1b[2mNo active query. Press Ctrl+C again to exit.\x1b[0m\n");
+                    process.stdout.write("\x1b[2mInterrupted agent. Press Ctrl+C again to exit, or type a new prompt.\x1b[0m\n");
                     continue;
                 }
                 throw err;

package/dist/tools.js

@@ -72,9 +72,12 @@ function displayDiff(pathName, oldContent, newContent) {
         const limit = kind === " " ? max_diff_context_lines : max_diff_lines;
         const hidden = run.length - limit;
         for (const r of run.slice(0, limit))
-            shown.push(truncateDiffLine(r.line));
+            shown.push({ kind, line: truncateDiffLine(r.line) });
         if (hidden > 0) {
-            shown.push(`… (${hidden} ${hidden === 1 ? "line" : "lines"} of diff hidden) …`);
+            shown.push({
+                kind: "~",
+                line: `… (${hidden} ${hidden === 1 ? "line" : "lines"} of diff hidden) …`,
+            });
         }
         run = [];
     };
@@ -87,9 +90,12 @@ function displayDiff(pathName, oldContent, newContent) {
     }
     flush();
     // Build the lines, stripping the leading + / - / space marker for display.
-    const visible = shown.map((l) => {
-        const kind = l[0] === "+" ? "+" : l[0] === "-" ? "-" : " ";
-        return { kind, body: l.slice(1) };
+    // Summary lines ("~") are already plain text and are kept whole.
+    const visible = shown.map(({ kind, line }) => {
+        if (kind === "~")
+            return { kind, body: line };
+        const k = line[0] === "+" ? "+" : line[0] === "-" ? "-" : " ";
+        return { kind: k, body: line.slice(1) };
     });
     // A "… (N lines hidden) …" summary line is neutral context.
     const termW = terminalWidth();
@@ -110,7 +116,11 @@ function displayDiff(pathName, oldContent, newContent) {
     pendingDiffOutput.push(`\x1b[90m${top}\x1b[0m`);
     for (const v of visible) {
         let line;
-        if (v.kind === "+") {
+        if (v.kind === "~") {
+            const body = truncateStyled(v.body, innerW - 2);
+            line = `\x1b[2m  ${body}\x1b[0m`;
+        }
+        else if (v.kind === "+") {
             const body = truncateStyled(v.body, innerW - 2);
             line = `\x1b[32m+ ${body}\x1b[0m`;
         }

package/dist/ui.js

@@ -9,7 +9,7 @@ export function enableRawStdin() {
         readline.emitKeypressEvents(process.stdin);
         if (process.stdin.isTTY) {
             process.stdin.setRawMode(true);
-            process.stdout.write("\x1b[<u\x1b[>1u");
+            process.stdout.write("\x1b[?9001h\x1b[>1u");
         }
         process.stdin.resume();
         hideCursor();
@@ -259,7 +259,7 @@ export function markdownToAnsi(text) {
             const highlighted = highlightCodeLine(cline, codeLang);
             out.push(`\x1b[90m│\x1b[0m  ${highlighted}`);
         }
-        out.push(`\x1b[90m╰${"─".repeat(barLen + plainLen(badge) + 2)}╯\x1b[0m`);
+        out.push(`\x1b[90m╰${"─".repeat(barLen + plainLen(badge) + 1)}╯\x1b[0m`);
         codeBuffer = [];
         codeLang = "";
     };
@@ -911,27 +911,63 @@ export function renderBufferWithCursor(buffer, pasteSpans, prefix, label, cursor
  *   modifyOtherKeys:     ESC [ 27 ; M ; 13 ~
  *   application:         ESC O M
  */
-function csiShiftEnter(seq) {
-    if (seq === "\x1bOM")
-        return true;
-    // modifyOtherKeys: ESC [ 27 ; M ; 13 ~
-    const mod = seq.match(/^\x1b\[27;(\d+);13[~_]$/);
-    if (mod) {
-        const m = parseInt(mod[1], 10);
-        return Number.isInteger(m) && ((m - 1) & 1) === 1;
+/**
+ * Parses a complete (reassembled) escape-sequence encoding of Enter and
+ * classifies it as a newline (Shift+Enter) or a submit (plain Enter).
+ *
+ * Return values:
+ *   "newline" — Shift+Enter (insert a new row)
+ *   "submit"  — plain Enter (submit the prompt)
+ *   null      — not an Enter sequence
+ *
+ * Handles every encoding a terminal can produce:
+ *   CSI-u:                    ESC [ 13 ; M u        (M = xterm bitmask + 1)
+ *   legacy / kitty:           ESC [ 13 ; M ~   /   ESC [ 13 ; M _
+ *   modifyOtherKeys:          ESC [ 27 ; M ; 13 ~
+ *   application (SS3):        ESC O M
+ *   win32-input-mode:         ESC [ G ; R ; C ; VK ; MOD u
+ *                             (VK = 13 for Enter, MOD = raw bitmask where
+ *                              bit0 = Shift)
+ */
+function parseEnterSequence(seq) {
+    if (!seq)
+        return null;
+    // win32-input-mode: ESC [ guard ; row ; col ; vk ; mod u
+    let m = seq.match(/^\x1b\[(\d+);(\d+);(\d+);(\d+);(\d+)u$/);
+    if (m) {
+        const vk = parseInt(m[4], 10);
+        if (vk !== 13)
+            return null;
+        const mod = parseInt(m[5], 10);
+        return mod & 1 ? "newline" : "submit";
     }
-    // CSI-u / legacy: ESC [ 13 ; M u  (or ~ or _)
-    const csi = seq.match(/^\x1b\[13;(\d+)[~u_]$/);
-    if (csi) {
-        const m = parseInt(csi[1], 10);
-        return Number.isInteger(m) && ((m - 1) & 1) === 1;
+    // modifyOtherKeys / kitty: ESC [ 27 ; M ; 13 ~ (or _)
+    m = seq.match(/^\x1b\[27;(\d+);13[~_]$/);
+    if (m) {
+        const mod = parseInt(m[1], 10);
+        if (mod > 0)
+            return (mod - 1) & 1 ? "newline" : "submit";
+        return null;
     }
-    return false;
+    // CSI-u / legacy: ESC [ 13 ; M u (or ~ or _)
+    m = seq.match(/^\x1b\[13;(\d+)[~u_]$/);
+    if (m) {
+        const mod = parseInt(m[1], 10);
+        if (mod > 0)
+            return (mod - 1) & 1 ? "newline" : "submit";
+        return null;
+    }
+    // Application keypad Enter (SS3)
+    if (seq === "\x1bOM")
+        return "newline";
+    return null;
 }
 export function isShiftEnterKey(str, key) {
     if (!key)
         return false;
     const seq = key.sequence || str || "";
+    if (parseEnterSequence(seq) === "newline")
+        return true;
     // Shift modifier reported by readline on a return/enter/linefeed key.
     if (key.shift &&
         (key.name === "return" ||
@@ -941,8 +977,6 @@ export function isShiftEnterKey(str, key) {
             seq === "\n")) {
         return true;
     }
-    if (csiShiftEnter(seq))
-        return true;
     return false;
 }
 export const isNewlineKey = isShiftEnterKey;
@@ -952,6 +986,8 @@ export function isSubmitEnterKey(str, key) {
     if (isShiftEnterKey(str, key))
         return false;
     const seq = key.sequence || str || "";
+    if (parseEnterSequence(seq) === "submit")
+        return true;
     if ((key.name === "return" ||
         seq === "\r" ||
         seq === "\x1b[13u" ||
@@ -961,6 +997,115 @@ export function isSubmitEnterKey(str, key) {
     }
     return false;
 }
+/**
+ * Maps a Windows virtual-key code + shift state to a printable character, or
+ * null if the code isn't a printable character. US-layout approximation (the
+ * common case); enough for a text prompt.
+ */
+function vkToChar(vk, shift) {
+    if (vk >= 48 && vk <= 57) {
+        const symbols = [")", "!", "@", "#", "$", "%", "^", "&", "*", "("];
+        return shift ? symbols[vk - 48] : String(vk - 48);
+    }
+    if (vk >= 65 && vk <= 90) {
+        return shift ? String.fromCharCode(vk) : String.fromCharCode(vk).toLowerCase();
+    }
+    if (vk === 186)
+        return shift ? ":" : ";";
+    if (vk === 187)
+        return shift ? "+" : "=";
+    if (vk === 188)
+        return shift ? "<" : ",";
+    if (vk === 189)
+        return shift ? "_" : "-";
+    if (vk === 190)
+        return shift ? ">" : ".";
+    if (vk === 191)
+        return shift ? "?" : "/";
+    if (vk === 192)
+        return shift ? "~" : "`";
+    if (vk === 219)
+        return shift ? "{" : "[";
+    if (vk === 220)
+        return shift ? "|" : "\\";
+    if (vk === 221)
+        return shift ? "}" : "]";
+    if (vk === 222)
+        return shift ? '"' : "'";
+    return null;
+}
+/**
+ * Decodes a complete win32-input-mode sequence (ESC [ G ; R ; C ; VK ; MOD u)
+ * into a key action. Returns a descriptor for the prompt to execute, or null
+ * if the sequence isn't a win32-input-mode sequence.
+ */
+function decodeWin32Key(seq) {
+    const m = seq.match(/^\x1b\[(\d+);(\d+);(\d+);(\d+);(\d+)u$/);
+    if (!m)
+        return null;
+    const vk = parseInt(m[4], 10);
+    const mod = parseInt(m[5], 10);
+    const shift = (mod & 1) === 1;
+    const ctrl = (mod & 4) === 4;
+    const alt = (mod & 2) === 2;
+    const cmd = (c) => ({ type: "cmd", cmd: c });
+    const text = (t) => ({ type: "text", text: t });
+    // Control combos
+    if (ctrl && vk === 67)
+        return cmd("interrupt"); // Ctrl+C
+    if (ctrl && vk === 68)
+        return cmd("eof"); // Ctrl+D
+    if (ctrl && vk === 90)
+        return cmd("eof"); // Ctrl+Z
+    if (ctrl && vk === 65)
+        return cmd("home"); // Ctrl+A
+    if (ctrl && vk === 69)
+        return cmd("end"); // Ctrl+E
+    if (ctrl && vk === 85)
+        return cmd("clear-line"); // Ctrl+U
+    if (ctrl && vk === 75)
+        return cmd("kill-line"); // Ctrl+K
+    if (ctrl && vk === 87)
+        return cmd("delete-word"); // Ctrl+W
+    switch (vk) {
+        case 13: // Enter
+            return shift ? cmd("newline") : cmd("submit");
+        case 8: // Backspace
+            return cmd(ctrl ? "delete-word" : "backspace");
+        case 46: // Delete
+            return cmd("delete");
+        case 37: // Left
+            return ctrl ? cmd("back-word") : cmd("left");
+        case 39: // Right
+            return ctrl ? cmd("forward-word") : cmd("right");
+        case 38: // Up
+            return cmd("up");
+        case 40: // Down
+            return cmd("down");
+        case 36: // Home
+            return cmd("home");
+        case 35: // End
+            return cmd("end");
+        case 33: // PageUp
+            return cmd("up");
+        case 34: // PageDown
+            return cmd("down");
+        case 9: // Tab
+            return cmd("tab");
+        case 32: // Space
+            return text(" ");
+        case 27: // Escape
+            return cmd("escape");
+        default: {
+            if (alt)
+                return null; // Alt combos unsupported -> ignore
+            const ch = vkToChar(vk, shift);
+            if (ch)
+                return text(ch);
+            return cmd("ignore");
+        }
+    }
+}
 export function askBottomPrompt(label = "You", prefix = "❯", history = []) {
     return new Promise((resolve, reject) => {
         const isTTY = process.stdin.isTTY;
@@ -995,10 +1140,10 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = []) {
         if (process.stdin.isTTY) {
             process.stdin.setRawMode(true);
             process.stdout.write("\x1b[?2004h");
-            // Enable CSI-u "disambiguate" so the terminal reports Shift+Enter as a
-            // distinct code (`ESC [ 13 ; 2 u`) instead of collapsing it into a plain
-            // Enter. Pop any prior mode, then push flags=1 (disambiguate).
-            process.stdout.write("\x1b[<u\x1b[>1u");
+            // Enable win32-input-mode (preferred by Windows Terminal) and CSI-u
+            // disambiguation so Shift+Enter arrives as a distinct code instead of a
+            // plain Enter. Harmless if a terminal doesn't support them.
+            process.stdout.write("\x1b[?9001h\x1b[>1u");
         }
         process.stdin.resume();
         hideCursor();
@@ -1021,13 +1166,14 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = []) {
             if (done)
                 return;
             done = true;
-            process.stdout.write("\x1b[?2004l");
+            process.stdout.write("\x1b[?2004l\x1b[?9001l");
             process.stdin.setRawMode(false);
             if (pasteBurstTimer)
                 clearTimeout(pasteBurstTimer);
             clearBox();
             process.stdin.removeListener("keypress", onKeypress);
             process.stdin.pause();
+            showCursor();
             if (isErr)
                 reject(value);
             else
@@ -1341,26 +1487,122 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = []) {
                 pasteBurstTimer = null;
             }, 500);
         };
-        const onKeypress = (str, key) => {
-            // Reassemble a modifier-prefixed CSI sequence that readline splits up,
-            // e.g. Shift+Enter arriving as `\x1b[27;2;` + "1" + "3" + "~".
-            if (key?.sequence === "\x1b[27;" || key?.sequence === "\x1b[27;2;") {
-                modSeq = key.sequence;
+        const handleRawSequence = (full) => {
+            // Enter sequences (CSI-u, kitty, legacy, SS3, win32).
+            const enter = parseEnterSequence(full);
+            if (enter === "newline") {
+                insert("\n");
+                repaint();
+                return;
+            }
+            if (enter === "submit") {
+                if (buffer.trim())
+                    settle([buffer, pasteSpans], false);
+                return;
+            }
+            // Other win32-input-mode keys (arrows, backspace, etc.).
+            const dec = decodeWin32Key(full);
+            if (!dec)
+                return;
+            if (dec.type === "text") {
+                insert(dec.text);
+                repaint();
                 return;
             }
+            switch (dec.cmd) {
+                case "interrupt":
+                    settle(new Error("interrupt"), true);
+                    return;
+                case "eof":
+                    settle(new Error("eof"), true);
+                    return;
+                case "backspace":
+                    backspace();
+                    repaint();
+                    return;
+                case "delete-word":
+                    deleteWordBefore();
+                    repaint();
+                    return;
+                case "delete":
+                    deleteChar();
+                    repaint();
+                    return;
+                case "left":
+                    moveLeft();
+                    repaint();
+                    return;
+                case "right":
+                    moveRight();
+                    repaint();
+                    return;
+                case "back-word": {
+                    const sp = buffer.slice(0, cursor).lastIndexOf(" ");
+                    cursor = sp === -1 ? 0 : sp + 1;
+                    repaint();
+                    return;
+                }
+                case "forward-word": {
+                    const sp = buffer.indexOf(" ", cursor);
+                    cursor = sp === -1 ? buffer.length : sp + 1;
+                    repaint();
+                    return;
+                }
+                case "up":
+                    moveUp();
+                    repaint();
+                    return;
+                case "down":
+                    moveDown();
+                    repaint();
+                    return;
+                case "home":
+                    cursor = 0;
+                    repaint();
+                    return;
+                case "end":
+                    cursor = buffer.length;
+                    repaint();
+                    return;
+                case "tab":
+                    insert("  ");
+                    repaint();
+                    return;
+                case "clear-line":
+                    buffer = "";
+                    cursor = 0;
+                    pasteSpans = [];
+                    repaint();
+                    return;
+                case "kill-line":
+                    buffer = buffer.slice(0, cursor);
+                    repaint();
+                    return;
+                default:
+                    return;
+            }
+        };
+        const onKeypress = (str, key) => {
+            // Reassemble modifier-prefixed / win32-input-mode CSI sequences, which
+            // Node's readline splits into several keypress events (e.g. Shift+Enter
+            // arriving as `\x1b[27;2;` + "1" + "3" + "~", or a win32-input-mode
+            // sequence `\x1b[0;1;1;13;2u` arriving piecemeal). A "partial CSI" is
+            // any ESC [ sequence readline left unterminated; we keep appending until
+            // it ends in a terminator, then classify it.
+            const seq = key?.sequence || str || "";
             if (modSeq) {
-                modSeq += str || key?.sequence || "";
-                if (/[~u_]/.test(modSeq.slice(-1)) || modSeq.endsWith("~")) {
+                modSeq += str || seq || "";
+                if (/^\x1b\[[\d;]*[a-zA-Z~_u]$/.test(modSeq)) {
                     const full = modSeq;
                     modSeq = "";
-                    // e.g. `\x1b[27;2;13~` = Shift+Enter.
-                    if (csiShiftEnter(full)) {
-                        insert("\n");
-                        repaint();
-                    }
+                    handleRawSequence(full);
                 }
                 return;
             }
+            if (/^\x1b\[[\d;]*$/.test(seq)) {
+                modSeq = seq;
+                return;
+            }
             if (consumeBracketedPaste(str, key))
                 return;
             if (pasteBurst && str && str.length === 1 && !key?.ctrl && !key?.meta) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxecli/oxe",
-  "version": "1.0.65",
+  "version": "1.0.67",
   "publishConfig": {
     "access": "public"
   },