@oxecli/oxe 1.0.109 → 1.0.111

package/dist/engine.js

@@ -11,6 +11,10 @@ import { takePendingDiffOutput } from "./tools.js";
 // ---------------------------------------------------------------------------
 const tokenEstCache = new Map();
 const tokenEstCacheMax = 4096;
+/** Minimum time (ms) a tool's "Working"/"Running" status stays visible after
+ *  the tool returns, so instant tools (write_file/edit_file) are still seen to
+ *  stream when called before the result replaces the status line. */
+const MIN_TOOL_STATUS_MS = 350;
 export function estimateTokens(items) {
     let total = 0;
     for (const item of items) {
@@ -585,12 +589,14 @@ export class InferenceEngine {
                 for (const c of calls) {
                     this.queryCalledTool = true;
                     const started = toolCallLabel(c.name, c.arguments);
-                    // Print the tool label the instant the command starts, then show a
-                    // "╰─ Running..." dots line that swaps to the real result in place.
+                    // Print the tool label the instant the tool starts, then show a
+                    // "╰─ Working..." (file tools) or "╰─ Running..." (bash) dots line
+                    // that streams while the tool runs and swaps to the real result.
                     dockAppendContent(`${started}\n`);
                     dockTransientStart("flush");
                     const toolSpinner = new Spinner();
-                    toolSpinner.startDots("\x1b[90m╰─\x1b[0m Running");
+                    toolSpinner.startDots(`\x1b[90m╰─\x1b[0m ${c.name === "bash" ? "Running" : "Working"}`);
+                    const t0 = Date.now();
                     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.
@@ -599,6 +605,14 @@ export class InferenceEngine {
                         toolSpinner.stop();
                         throw new Error("interrupt");
                     }
+                    // Keep the status line streaming for at least MIN_TOOL_STATUS_MS so
+                    // even instant tools (write_file/edit_file) visibly show their
+                    // "Working" indicator when called, then swap to the result. The
+                    // spinner's own timer animates the dots during this window.
+                    const elapsed = Date.now() - t0;
+                    if (elapsed < MIN_TOOL_STATUS_MS) {
+                        await new Promise((res) => setTimeout(res, MIN_TOOL_STATUS_MS - elapsed));
+                    }
                     const failed = toolOutputFailed(c.name, rawResult);
                     const action = formatToolResult(rawResult, failed);
                     const diff = takePendingDiffOutput();

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
@@ -31,6 +31,18 @@ function truncateDiffLine(line) {
     }
     return line;
 }
+/**
+ * Truncate a styled line to at most `maxVisible` visible characters and, if
+ * truncation occurred, append a visible ellipsis "…". The diff viewer must
+ * NEVER wrap a line onto a new row (that breaks the +/- column alignment), so
+ * every row is hard-truncated here; the ellipsis makes the truncation obvious.
+ */
+function truncateStyledEllipsis(text, maxVisible) {
+    if (plainLen(text) <= maxVisible)
+        return text;
+    const dot = maxVisible > 1 ? "…" : "";
+    return truncateStyled(text, Math.max(1, maxVisible - (dot ? 1 : 0))) + dot;
+}
 /**
  * Recolor bracket syntax characters (`( ) [ ] { }`) inside an already-ANSI
  * rendered string to `fg`, restoring the row's white base after each bracket.
@@ -76,8 +88,9 @@ function displayDiff(pathName, oldContent, newContent) {
     // tool result text above it ("╰─ Wrote N chars").
     const ind = "   ";
     if (oldContent.length + newContent.length > max_diff_source_chars) {
-        pendingDiffOutput.push(`\x1b[90m${ind}${pathName}: ${oldContent.length.toLocaleString()} chars -> ${newContent.length.toLocaleString()} chars ` +
-            `(diff hidden: exceeds ${max_diff_source_chars.toLocaleString()} char limit)\x1b[0m`);
+        const hiddenMsg = `${pathName}: ${oldContent.length.toLocaleString()} chars -> ${newContent.length.toLocaleString()} chars ` +
+            `(diff hidden: exceeds ${max_diff_source_chars.toLocaleString()} char limit)`;
+        pendingDiffOutput.push(`\x1b[90m${ind}${truncateStyledEllipsis(hiddenMsg, Math.max(terminalWidth() - 2, 1))}\x1b[0m`);
         return null;
     }
     const patch = structuredPatch(pathName, pathName, oldContent, newContent, "", "", { context: max_diff_context_lines });
@@ -148,6 +161,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,11 +173,11 @@ 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 === "~") {
-            const body = truncateStyled(v.body, bodyMax);
+            const body = truncateStyledEllipsis(v.body, bodyMax);
             pendingDiffOutput.push(`\x1b[90m${ind}${gap}   ${body}\x1b[0m`);
             continue;
         }
@@ -177,14 +194,14 @@ function displayDiff(pathName, oldContent, newContent) {
             // background + white base after each token reset so both hold across
             // the whole body.
             const raw = highlightCodeLine(v.body);
-            const body = truncateStyled(raw.replace(/\x1b\[0m/g, `\x1b[0m${bg}\x1b[97m`), bodyMax);
+            const body = truncateStyledEllipsis(raw.replace(/\x1b\[0m/g, `\x1b[0m${bg}\x1b[97m`), bodyMax);
             // Deleted rows: recolor bracket syntax to the same red as the line
             // number (fg) so brackets match the row's deleted color. Added rows keep
             // their green highlighter as-is.
             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 {
@@ -193,7 +210,7 @@ function displayDiff(pathName, oldContent, newContent) {
             // lines (only the number gutter stays dim). highlightCodeLine resets to
             // default after each token, so re-apply the base after every reset.
             const base = v.kind === "\\" ? "\x1b[90m" : "\x1b[97m";
-            const body = truncateStyled(raw.replace(/\x1b\[0m/g, `\x1b[0m${base}`), bodyMax);
+            const body = truncateStyledEllipsis(raw.replace(/\x1b\[0m/g, `\x1b[0m${base}`), bodyMax);
             pendingDiffOutput.push(`\x1b[90m${ind}${numStr}  \x1b[0m${base}${body}\x1b[0m`);
         }
     }

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 = 40;
+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);
 }
@@ -363,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))} `;
     });
@@ -377,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))} `;
         });

package/package.json

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