@oxecli/oxe 1.0.108 → 1.0.110

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/tools.js

@@ -4,7 +4,7 @@ import { execFile, spawn } from "node:child_process";
 import { structuredPatch } from "diff";
 import { max_diff_source_chars, max_diff_lines, max_diff_context_lines, max_diff_line_chars, max_read_line_chars, max_read_file_bytes, max_read_lines, max_output_chars, max_bash_timeout_seconds, max_grep_file_bytes, strict_max_properties, ignoredDirs, } from "./config.js";
 import { toolLoadSkill } from "./skills.js";
-import { truncateStyled, plainLen, terminalWidth, highlightCodeLine } from "./ui.js";
+import { truncateStyled, plainLen, terminalWidth, highlightCodeLine, fitBoxWidth } from "./ui.js";
 export { toolLoadSkill };
 // ---------------------------------------------------------------------------
 // Path sanitization helper
@@ -148,6 +148,10 @@ function displayDiff(pathName, oldContent, newContent) {
         return { kind: k, body: line.slice(1), oldNum, newNum };
     });
     const termW = terminalWidth();
+    // The diff rows render outside a panel, so clamp their width to the scaled
+    // box width (minus margin) so they never overflow on narrow terminals.
+    const boxW = fitBoxWidth(termW - 4, termW);
+    const innerW = Math.max(boxW - 4, 1);
     let maxNum = 1;
     for (const v of visible) {
         if (v.oldNum)
@@ -156,7 +160,7 @@ function displayDiff(pathName, oldContent, newContent) {
             maxNum = Math.max(maxNum, v.newNum);
     }
     const numW = String(maxNum).length;
-    const bodyMax = Math.max(termW - ind.length - numW - 4, 20);
+    const bodyMax = Math.max(innerW - ind.length - numW - 4, 1);
     const gap = " ".repeat(numW);
     for (const v of visible) {
         if (v.kind === "~") {
@@ -184,7 +188,7 @@ function displayDiff(pathName, oldContent, newContent) {
             const shown = isAdd
                 ? body
                 : recolorBrackets(body, fg, "\x1b[97m");
-            const fill = Math.max(0, termW - ind.length - numW - 4 - plainLen(body));
+            const fill = Math.max(0, innerW - ind.length - numW - 4 - plainLen(body));
             pendingDiffOutput.push(`${ind}${bg}${fg}${numStr} ${sign}  \x1b[0m${bg}\x1b[97m${shown}${bg}\x1b[97m${" ".repeat(fill)}\x1b[0m`);
         }
         else {

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 = 52;
 /** Horizontal margin reserved on each side of a box/card from the terminal edge. */
 const BOX_MARGIN = 4;
 /**
@@ -127,7 +127,7 @@ const BOX_MARGIN = 4;
  * terminal is narrower than min+margin, so cards size down smoothly instead of
  * overflowing.
  */
-function fitBoxWidth(pref, termW) {
+export function fitBoxWidth(pref, termW) {
     const maxW = Math.max(termW - BOX_MARGIN, 1);
     return Math.min(Math.max(Math.min(pref, maxW), MIN_BOX_WIDTH), maxW);
 }
@@ -198,55 +198,62 @@ function wrapStyledToWidth(line, width) {
             pending = "";
         }
     }
-    const out = [];
-    let cur = "";
+    const render = (atoms) => atoms.map((a) => a.pre + a.ch).join("");
+    const rows = [];
+    let cur = [];
     let curLen = 0;
-    let word = [];
-    const emitChunk = (chunk, prependSpace) => {
-        const add = (prependSpace && curLen > 0 ? 1 : 0) + chunk.length;
-        if (curLen + add > width)
-            return false;
-        if (prependSpace && curLen > 0) {
-            cur += " ";
+    // 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;
         }
-        for (const u of chunk)
-            cur += u.pre + u.ch;
-        curLen += chunk.length;
-        return true;
-    };
-    const flushWord = () => {
-        if (!word.length)
-            return;
-        const wlen = word.length;
-        // Split overlong words into <= width chunks so nothing is ever cut off.
-        const chunks = [];
-        if (wlen <= width)
-            chunks.push(word);
-        else
-            for (let i = 0; i < wlen; i += width)
-                chunks.push(word.slice(i, i + width));
-        for (let ci = 0; ci < chunks.length; ci++) {
-            const chunk = chunks[ci];
-            if (!emitChunk(chunk, ci === 0)) {
-                out.push(cur);
-                cur = "";
+        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;
-                emitChunk(chunk, false);
             }
         }
-        word = [];
-    };
-    for (const u of units) {
-        if (/\s/.test(u.ch))
-            flushWord();
-        else
-            word.push(u);
+        cur.push(a);
+        curLen++;
     }
-    flushWord();
-    if (cur)
-        out.push(cur);
-    return out.length ? out : [line];
+    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
@@ -356,13 +363,36 @@ function formatMarkdownTable(tableLines) {
         }
         colWidths.push(Math.max(mw, 3));
     }
+    // Scale the table to fit the terminal: shrink columns (each toward a minimum
+    // of 3) so the whole table stays inside the box width instead of overflowing
+    // or wrapping its borders on a narrow/scaled terminal. Cell content that no
+    // longer fits is truncated to the column width when rendered.
+    {
+        const termW = terminalWidth();
+        const boxW = fitBoxWidth(termW - 4, termW);
+        const availW = Math.max(boxW - 4, 1);
+        // total = Σ(colWidth+2) + (ncols-1) separators + 2 outer borders.
+        const totalW = colWidths.reduce((a, w) => a + w + 2, 0) + (colWidths.length - 1) + 2;
+        let extra = totalW - availW;
+        if (extra > 0) {
+            for (let c = 0; c < colWidths.length && extra > 0; c++) {
+                const room = colWidths[c] - 3;
+                if (room > 0) {
+                    const cut = Math.min(room, extra);
+                    colWidths[c] -= cut;
+                    extra -= cut;
+                }
+            }
+        }
+    }
     const out = [];
     const topBorder = `\x1b[90m╭${colWidths.map((w) => "─".repeat(w + 2)).join("┬")}╮\x1b[0m`;
     const midBorder = `\x1b[90m├${colWidths.map((w) => "─".repeat(w + 2)).join("┼")}┤\x1b[0m`;
     const botBorder = `\x1b[90m╰${colWidths.map((w) => "─".repeat(w + 2)).join("┴")}╯\x1b[0m`;
     out.push(topBorder);
     const headCells = header.map((h, i) => {
-        const formatted = `\x1b[1;37m${formatInlineMarkdown(h)}\x1b[0m`;
+        const raw = `\x1b[1;37m${formatInlineMarkdown(h)}\x1b[0m`;
+        const formatted = truncateStyled(raw, colWidths[i]);
         const pad = colWidths[i] - plainLen(formatted);
         return ` ${formatted}${" ".repeat(Math.max(pad, 0))} `;
     });
@@ -370,7 +400,7 @@ function formatMarkdownTable(tableLines) {
     out.push(midBorder);
     for (const r of rows) {
         const rowCells = header.map((_, i) => {
-            const cell = r[i] ? formatInlineMarkdown(r[i]) : "";
+            const cell = r[i] ? truncateStyled(formatInlineMarkdown(r[i]), colWidths[i]) : "";
             const pad = colWidths[i] - plainLen(cell);
             return ` ${cell}${" ".repeat(Math.max(pad, 0))} `;
         });
@@ -948,7 +978,7 @@ export function showCursor() {
     }
 }
 const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-const DOT_FRAMES = [".  ", ".. ", "..."];
+const DOT_FRAMES = [".", "..", "..."];
 export class Spinner {
     timer = null;
     frame = 0;
@@ -1008,12 +1038,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

package/package.json

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