@oxecli/oxe 1.0.107 → 1.0.109

package/dist/engine.js

@@ -586,11 +586,11 @@ export class InferenceEngine {
                     this.queryCalledTool = true;
                     const started = toolCallLabel(c.name, c.arguments);
                     // Print the tool label the instant the command starts, then show a
-                    // "╰─ Working..." dots line that swaps to the real result in place.
+                    // "╰─ Running..." dots line that swaps to the real result in place.
                     dockAppendContent(`${started}\n`);
                     dockTransientStart("flush");
                     const toolSpinner = new Spinner();
-                    toolSpinner.startDots("\x1b[90m╰─\x1b[0m Working");
+                    toolSpinner.startDots("\x1b[90m╰─\x1b[0m Running");
                     const rawResult = await this.runTool(c.name, c.arguments, this.activeAbort?.signal);
                     // A tool call was made, which interrupts any current working phase,
                     // so the next agent iteration may commit a fresh "Worked for …" block.
@@ -609,7 +609,7 @@ export class InferenceEngine {
                         status: failed ? "failed" : "ok",
                         diff,
                     });
-                    // Swap the "╰─ Working..." line for the real result. If the tool
+                    // Swap the "╰─ Running..." line for the real result. If the tool
                     // produced a diff it renders directly below the action line with no
                     // gap; otherwise the dock gap separates the action from what follows.
                     toolSpinner.stop();

package/dist/oxe.js

@@ -1,10 +1,18 @@
 import { main } from "./cli.js";
+import { dockTearDown, showCursor } from "./ui.js";
 export { main };
 // The TUI keeps the terminal cursor hidden except inside a prompt field. Always
-// restore it on exit so the shell isn't left with an invisible cursor.
+// restore it on exit and tear down any docked prompt box so the shell isn't
+// left with a stale prompt box or an invisible cursor.
 process.on("exit", () => {
     try {
-        process.stdout.write("\x1b[?25h");
+        dockTearDown();
+    }
+    catch {
+        /* ignore */
+    }
+    try {
+        showCursor();
     }
     catch {
         /* ignore */

package/dist/ui.js

@@ -117,7 +117,7 @@ export function terminalWidth() {
     return process.stdout.columns || 80;
 }
 /** Minimum width for boxes/cards so they don't collapse to nothing. */
-const MIN_BOX_WIDTH = 20;
+const MIN_BOX_WIDTH = 40;
 /** Horizontal margin reserved on each side of a box/card from the terminal edge. */
 const BOX_MARGIN = 4;
 /**
@@ -173,6 +173,88 @@ export function truncateStyled(text, maxVisible) {
     }
     return out;
 }
+/**
+ * Wrap a styled (ANSI) string into lines of at most `width` visible characters,
+ * wrapping whole words onto new lines and splitting any single word longer than
+ * `width`. ANSI escape sequences are preserved and re-attached to their glyphs,
+ * so no style is lost and no escape sequence is ever cut mid-way.
+ */
+function wrapStyledToWidth(line, width) {
+    if (width <= 0)
+        return [line];
+    if (plainLen(line) <= width)
+        return [line];
+    // Tokenize into glyph units, each carrying the ANSI prefix that precedes it.
+    const units = [];
+    const re = /(\x1b\[[0-9;]*[a-zA-Z]|\x1b\].*?\x07)|([\s\S])/g;
+    let pending = "";
+    let m;
+    re.lastIndex = 0;
+    while ((m = re.exec(line)) !== null) {
+        if (m[1] !== undefined)
+            pending += m[1];
+        else {
+            units.push({ ch: m[2], pre: pending });
+            pending = "";
+        }
+    }
+    const render = (atoms) => atoms.map((a) => a.pre + a.ch).join("");
+    const rows = [];
+    let cur = [];
+    let curLen = 0;
+    // Index (in `cur`) of the whitespace atom that is a valid break point, or -1.
+    let breakAt = -1;
+    // The last SGR open code currently in effect, so a word split mid-way can
+    // re-apply the style on its continuation.
+    let activeStyle = "";
+    for (const a of units) {
+        // Track the active style from this glyph's ANSI prefix.
+        if (a.pre) {
+            const sgr = a.pre.match(/\x1b\[[0-9;]*m/g);
+            if (sgr && sgr.length) {
+                const last = sgr[sgr.length - 1];
+                activeStyle = last === "\x1b[0m" ? "" : last;
+            }
+        }
+        const isSpace = /\s/.test(a.ch);
+        if (isSpace) {
+            cur.push(a);
+            curLen++;
+            breakAt = cur.length - 1;
+            continue;
+        }
+        if (curLen + 1 > width) {
+            if (breakAt >= 0) {
+                // Break after the whitespace at breakAt: keep the whitespace's ANSI
+                // prefix (often a reset) so style never leaks onto the continuation.
+                const space = cur[breakAt];
+                const lead = space.pre; // e.g. \x1b[0m — applied at start of next row
+                const kept = cur.slice(breakAt + 1);
+                rows.push(cur.slice(0, breakAt));
+                cur = [{ ch: "", pre: lead }, ...kept];
+                curLen = kept.length;
+                breakAt = -1;
+            }
+            else if (cur.length) {
+                // No whitespace break point: split the word mid-way, re-applying the
+                // active style on the continuation so a styled word keeps its style.
+                rows.push(cur);
+                const lead = activeStyle ? activeStyle : "";
+                cur = lead ? [{ ch: "", pre: lead }] : [];
+                curLen = 0;
+            }
+        }
+        cur.push(a);
+        curLen++;
+    }
+    if (cur.length)
+        rows.push(cur);
+    // Emit each row, ending with a reset so no style bleeds across rows.
+    return rows.map((r) => {
+        const rendered = render(r);
+        return rendered + (plainLen(rendered) ? "\x1b[0m" : "");
+    });
+}
 // ---------------------------------------------------------------------------
 // Markup tag -> ANSI
 // ---------------------------------------------------------------------------
@@ -412,22 +494,11 @@ export function markdownToAnsi(text) {
         if (!line.includes("\x1b[36m•\x1b[0m") && !line.includes(".\x1b[0m ")) {
             line = formatInlineMarkdown(line);
         }
-        // Word wrap paragraph line if too long
+        // Word wrap paragraph line if too long. Whole words move to a new row; any
+        // single word longer than the width is split so nothing is ever cut off at
+        // the right edge.
         if (plainLen(line) > width && !line.startsWith(" ")) {
-            const words = line.split(" ");
-            let cur = "";
-            for (const w of words) {
-                if (plainLen(cur) + plainLen(w) + 1 > width) {
-                    if (cur)
-                        out.push(cur);
-                    cur = w;
-                }
-                else {
-                    cur = cur ? `${cur} ${w}` : w;
-                }
-            }
-            if (cur)
-                out.push(cur);
+            out.push(...wrapStyledToWidth(line, width));
         }
         else {
             out.push(line);
@@ -884,7 +955,7 @@ export function showCursor() {
     }
 }
 const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-const DOT_FRAMES = [".  ", ".. ", "..."];
+const DOT_FRAMES = [".", "..", "..."];
 export class Spinner {
     timer = null;
     frame = 0;
@@ -944,12 +1015,15 @@ export class Spinner {
     }
     writeDots(initial) {
         const dots = DOT_FRAMES[this.dotsFrame];
+        // Always emit a fixed 3-cell field so packed dots (., .., ...) animate
+        // without leaving residue when the frame shrinks (e.g. ... -> .).
+        const padded = dots.padEnd(3, " ");
         if (initial) {
-            process.stdout.write("\r" + this.dotsText + dots + "\r");
+            process.stdout.write("\r" + this.dotsText + padded + "\r");
         }
         else {
             // Jump to the dots column (1-based) and rewrite only the 3-cell field.
-            process.stdout.write(`\x1b[${plainLen(this.dotsText) + 1}G` + dots + "\r");
+            process.stdout.write(`\x1b[${plainLen(this.dotsText) + 1}G` + padded + "\r");
         }
     }
     /** Overwrite the dots line in place with `text` and advance to the next
@@ -1377,11 +1451,18 @@ export function renderBufferWithCursor(buffer, pasteSpans, prefix, label, cursor
     const lines = [top, ...body, bottom];
     let totalRows = body.length + 2;
     if (hints && (hints.left || hints.right)) {
-        const left = hints.left ?? "";
+        let left = hints.left ?? "";
         const right = hints.right ?? "";
         // Inset the hint row inside the box (box spans columns 0..boxW-1): a
         // leading space gives left-edge padding, and the right hint ends one
-        // column before the box's right border for the same padding.
+        // column before the box's right border for the same padding. Truncate the
+        // left hint so the row never exceeds the box width on narrow terminals
+        // (otherwise it overflows past the right border instead of scaling down).
+        const hintMax = boxW - 2;
+        if (plainLen(left) + plainLen(right) + 1 > hintMax) {
+            const room = Math.max(0, hintMax - plainLen(right) - 1);
+            left = truncateStyled(left, room);
+        }
         const gap = Math.max(1, boxW - 2 - plainLen(left) - plainLen(right));
         lines.push(" " + left + " ".repeat(gap) + right);
         totalRows += 1;
@@ -1504,6 +1585,7 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = [], hin
                 dockEnterDocked();
             }
             process.stdin.removeListener("keypress", onKeypress);
+            process.stdout.removeListener("resize", onResize);
             process.stdin.pause();
             showCursor();
             if (isErr)
@@ -1945,6 +2027,17 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = [], hin
             }
         };
         process.stdin.on("keypress", onKeypress);
+        // Reflow the idle prompt box when the terminal resizes so it scales down
+        // instead of wrapping/overflowing its borders on a narrow/scaled terminal.
+        const onResize = () => {
+            try {
+                repaint(false);
+            }
+            catch {
+                /* ignore */
+            }
+        };
+        process.stdout.on("resize", onResize);
         repaint(true);
     });
 }

package/package.json

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