@oxecli/oxe 1.0.113 → 1.0.115

package/dist/ui.js

@@ -116,8 +116,10 @@ export function clearScreen() {
 export function terminalWidth() {
     return process.stdout.columns || 80;
 }
-/** Minimum width for boxes/cards so they don't collapse to nothing. */
-const MIN_BOX_WIDTH = 52;
+/** Minimum width for boxes/cards so they don't collapse to nothing. Kept
+ *  well below the smallest terminal width so a card can keep scaling down
+ *  (it never forces a box wider than the terminal). */
+const MIN_BOX_WIDTH = 30;
 /** Horizontal margin reserved on each side of a box/card from the terminal edge. */
 const BOX_MARGIN = 4;
 /**
@@ -1336,69 +1338,126 @@ export function splitBlocks(buffer, pasteSpans) {
 }
 const PROMPT_CARET = "\u0000";
 function wrapRuns(runs, width) {
+    const units = [];
+    for (const run of runs) {
+        if (run.text === PROMPT_CARET) {
+            units.push({ ch: PROMPT_CARET, style: run.style, caret: true });
+        }
+        else {
+            for (const ch of run.text) {
+                units.push({ ch, style: run.style, caret: false });
+            }
+        }
+    }
+    if (units.length === 0)
+        units.push({ ch: "", style: "", caret: false });
     const rows = [];
-    let cur = "";
-    let curLen = 0;
+    let line = [];
+    let lineLen = 0;
     let caretRow = -1;
     let caretCol = -1;
-    const flush = () => {
-        rows.push(cur);
-        cur = "";
-        curLen = 0;
+    const flushLine = () => {
+        if (line.length === 0)
+            return;
+        let out = "";
+        for (const u of line) {
+            if (u.caret)
+                out += u.style + "▏" + "\x1b[0m";
+            else if (u.style)
+                out += u.style + u.ch + "\x1b[0m";
+            else
+                out += u.ch;
+        }
+        rows.push(out);
+        line = [];
+        lineLen = 0;
     };
-    for (const run of runs) {
-        if (run.text === PROMPT_CARET) {
-            if (curLen >= width)
-                flush();
+    const isWs = (u) => !u.caret && /\s/.test(u.ch);
+    const addUnit = (u) => {
+        if (u.caret) {
             caretRow = rows.length;
-            caretCol = curLen;
-            cur += run.style + "▏" + "\x1b[0m";
-            curLen += 1;
+            caretCol = lineLen;
+        }
+        line.push(u);
+        lineLen += 1;
+    };
+    let i = 0;
+    while (i < units.length) {
+        const u = units[i];
+        if (u.caret) {
+            if (lineLen >= width)
+                flushLine();
+            addUnit(u);
+            i++;
             continue;
         }
-        let text = run.text;
-        while (text) {
-            const nl = text.indexOf("\n");
-            const seg = nl === -1 ? text : text.slice(0, nl);
-            let rest = seg;
-            while (rest.length > 0) {
-                if (curLen >= width)
-                    flush();
-                let take;
-                if (curLen === 0) {
-                    // Start of a line: take a whole word (or one char for a lone space,
-                    // or a full-width chunk for an overlong word).
-                    const sp = rest.indexOf(" ");
-                    take = sp === -1 ? rest.length : sp;
-                    if (take === 0)
-                        take = 1;
-                    take = Math.min(take, width);
-                }
-                else {
-                    // Mid-line: append the next whole word (plus its trailing space) only
-                    // if it fits; otherwise move the entire word to the next line.
-                    const sp = rest.indexOf(" ");
-                    take = sp === -1 ? rest.length : sp + 1;
-                    if (take > width - curLen) {
-                        flush();
-                        continue;
-                    }
-                }
-                const chunk = rest.slice(0, take);
-                cur += run.style ? run.style + chunk + "\x1b[0m" : chunk;
-                curLen += take;
-                rest = rest.slice(take);
+        if (u.ch === "\n") {
+            // Hard line break: end the current row and start a fresh one.
+            flushLine();
+            i++;
+            continue;
+        }
+        if (isWs(u)) {
+            if (lineLen + 1 > width)
+                flushLine();
+            // Never start a line with whitespace: if the space lands at the start of
+            // a fresh line, drop it (it was the fill of the previous full line).
+            if (lineLen === 0) {
+                i++;
+                continue;
             }
-            if (nl !== -1) {
-                flush();
-                text = text.slice(nl + 1);
+            addUnit(u);
+            i++;
+            continue;
+        }
+        // Start of a word (which may contain the caret). Find its full extent in
+        // the flattened stream so we never wrap mid-word.
+        let j = i;
+        let wordLen = 0; // each unit (including a caret) occupies one column
+        while (j < units.length && !isWs(units[j])) {
+            wordLen += 1;
+            j++;
+        }
+        if (wordLen === 0) {
+            i++;
+            continue;
+        }
+        if (lineLen === 0) {
+            if (wordLen > width) {
+                // Overlong word: split into width-sized chunks, keeping the caret in
+                // the chunk that contains it.
+                let from = i;
+                let remaining = wordLen;
+                while (remaining > 0) {
+                    const n = Math.min(width, remaining);
+                    for (let k = 0; k < n; k++)
+                        addUnit(units[from + k]);
+                    flushLine();
+                    from += n;
+                    remaining -= n;
+                }
             }
             else {
-                break;
+                for (let k = i; k < j; k++)
+                    addUnit(units[k]);
             }
+            i = j;
+        }
+        else {
+            if (lineLen + wordLen > width) {
+                // Word doesn't fit on the current line; move the whole word to a new
+                // line (leaving any trailing space from the previous word behind).
+                flushLine();
+                continue;
+            }
+            for (let k = i; k < j; k++)
+                addUnit(units[k]);
+            i = j;
         }
     }
-    flush();
+    flushLine();
+    if (rows.length === 0)
+        rows.push("");
     return { rows, caretRow, caretCol };
 }
 export function renderBufferWithCursor(buffer, pasteSpans, prefix, label, cursor, hints) {
@@ -1490,8 +1549,19 @@ export function renderBufferWithCursor(buffer, pasteSpans, prefix, label, cursor
     }
     const { rows, caretRow, caretCol } = wrapRuns(runs, innerW);
     const labelLen = plainLen(label);
-    const topPad = Math.max(0, boxW - labelLen - 7);
-    const top = `\x1b[90m╭─── \x1b[1m\x1b[36m${label}\x1b[0m\x1b[90m ${"─".repeat(topPad)}╮\x1b[0m`;
+    // Truncate the label so the top border never exceeds the box width — a long
+    // label used to push past `boxW` and wrap onto its own row, breaking the box
+    // on narrow/scaled terminals. Reserve room for "╭─── ", the two spaces and
+    // "╮" (7 cols) plus at least one dash.
+    let topLabel = label;
+    let topLabelLen = labelLen;
+    const topRoom = Math.max(0, boxW - 8);
+    if (topLabelLen > topRoom) {
+        topLabel = truncateStyledEllipsis(label, topRoom);
+        topLabelLen = plainLen(topLabel);
+    }
+    const topPad = Math.max(0, boxW - topLabelLen - 7);
+    const top = `\x1b[90m╭─── \x1b[1m\x1b[36m${topLabel}\x1b[0m\x1b[90m ${"─".repeat(topPad)}╮\x1b[0m`;
     const body = [];
     for (const l of rows) {
         const plain = stripAnsi(l);
@@ -1503,18 +1573,29 @@ export function renderBufferWithCursor(buffer, pasteSpans, prefix, label, cursor
     let totalRows = body.length + 2;
     if (hints && (hints.left || hints.right)) {
         let left = hints.left ?? "";
-        const right = hints.right ?? "";
+        let 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. 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).
+        // column before the box's right border for the same padding. Truncate so
+        // the row NEVER exceeds the box width on narrow/scaled terminals: the left
+        // hint is cut first to keep the (priority) right hint intact, then the
+        // right hint is cut as a last resort. Otherwise a long right hint would
+        // overflow past the 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 maxText = Math.max(0, hintMax - 1); // reserve a >=1 gap between hints
+        let leftW = plainLen(left);
+        let rightW = plainLen(right);
+        if (leftW + rightW > maxText) {
+            const roomL = Math.max(0, maxText - rightW);
+            left = truncateStyled(left, roomL);
+            leftW = plainLen(left);
+        }
+        const roomR = Math.max(0, maxText - leftW);
+        if (rightW > roomR) {
+            right = truncateStyled(right, roomR);
+            rightW = plainLen(right);
         }
-        const gap = Math.max(1, boxW - 2 - plainLen(left) - plainLen(right));
+        const gap = Math.max(1, hintMax - leftW - rightW);
         lines.push(" " + left + " ".repeat(gap) + right);
         totalRows += 1;
     }

package/package.json

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