@oxecli/oxe 1.0.61 → 1.0.63

package/dist/engine.js

@@ -5,6 +5,7 @@ import { buildTools, truncateToolOutput, toolReadFile, toolWriteFile, toolEditFi
 import { mutedMarkdown, aiMarkdown, tickDuration, displayRows, safeCommitPoint, printAiChunk, formatToolAction, renderPanel, Spinner, hideCursor, } from "./ui.js";
 import { reportUsage } from "./api.js";
 import { stripOrphanCalls, persistCompactionSummary, toolOutputFailed, } from "./sessions.js";
+import { flushPendingDiffOutput } from "./tools.js";
 // ---------------------------------------------------------------------------
 // Token estimation
 // ---------------------------------------------------------------------------
@@ -169,20 +170,15 @@ export class InferenceEngine {
         let thinkingStart = null;
         const workStatus = new Spinner();
         const workingStarted = Date.now();
-        workStatus.start(`Working ${tickDuration(0)}`);
-        const workTimer = setInterval(() => {
-            workStatus.update(`Working ${tickDuration((Date.now() - workingStarted) / 1000)}`);
-        }, 100);
+        workStatus.startWithRender(() => `Working ${tickDuration((Date.now() - workingStarted) / 1000)}`);
         let workingReported = false;
         let response = null;
         let etype = null;
         const silenceWorking = () => {
-            clearInterval(workTimer);
             workStatus.stop();
             workingReported = true;
         };
         const reportWorking = () => {
-            clearInterval(workTimer);
             workStatus.stop();
             if (workingReported)
                 return;
@@ -288,7 +284,6 @@ export class InferenceEngine {
             }
         }
         finally {
-            clearInterval(workTimer);
             workStatus.stop();
             const stillThinking = thinkingStart !== null;
             finishThinking(stillThinking);
@@ -563,12 +558,9 @@ export class InferenceEngine {
                     return;
                 }
                 if (!calls.length) {
-                    const gap = text.endsWith("\n\n")
-                        ? ""
-                        : text.endsWith("\n")
-                            ? "\n"
-                            : "\n\n";
-                    process.stdout.write(gap + summary() + "\n");
+                    // Exactly one blank row between the message and the footer summary.
+                    const trailing = (text.match(/\n+$/) ?? [""])[0].length;
+                    process.stdout.write("\n".repeat(Math.max(0, 2 - trailing)) + summary() + "\n");
                     story.push({ type: "footer", text: footerText() });
                     attachFooter(conversation);
                     attachFooter(inputItems);
@@ -576,8 +568,12 @@ export class InferenceEngine {
                     this.workRows = 0;
                     return;
                 }
-                if (text.trim())
-                    process.stdout.write("\n");
+                if (text.trim()) {
+                    // Ensure exactly one blank row between the assistant message and the
+                    // first tool call, no matter how many newlines the message ended with.
+                    const trailing = (text.match(/\n+$/) ?? [""])[0].length;
+                    process.stdout.write("\n".repeat(Math.max(0, 2 - trailing)));
+                }
                 for (const c of calls) {
                     this.workActive = false;
                     const started = formatToolAction(c.name, c.arguments, "started");
@@ -598,6 +594,9 @@ export class InferenceEngine {
                     const icon = failed ? "\x1b[31m✗\x1b[0m" : "\x1b[32m✓\x1b[0m";
                     const actionStyle = failed ? "\x1b[31m" : "\x1b[32m";
                     process.stdout.write(`${icon} ${actionStyle}${action}\x1b[0m\n\n`);
+                    // Any diff the tool produced is flushed only now, after the spinner
+                    // has stopped, so the box renders cleanly below the action line.
+                    flushPendingDiffOutput();
                     const truncatedResult = c.name === "read_file"
                         ? truncateToolOutput(rawResult, max_read_file_stored_chars)
                         : truncateToolOutput(rawResult);
@@ -612,11 +611,12 @@ export class InferenceEngine {
                         pending.push(outputItem);
                 }
             }
-            process.stdout.write("\n");
+            // The preceding tool action already leaves the cursor on a blank row, so
+            // no extra newline is needed above; renderPanel ends with its own "\n",
+            // and the prompt adds one leading "\n" -> exactly one blank row below.
             renderPanel("[bold yellow]⚠ Max tool-call iterations reached for this turn.[/bold yellow]\n" +
                 "[yellow]The work so far is saved. If you want the agent to keep going, type " +
                 "[bold]continue[/bold] and the next step will resume from where it left off.[/yellow]", "Warning", "", false, "33");
-            process.stdout.write("\n");
             if (retryPrompts.length)
                 dropRetryPrompts(conversation, inputItems, retryPrompts);
             stripOrphanCalls(conversation);

package/dist/tools.js

@@ -31,10 +31,19 @@ function truncateDiffLine(line) {
     }
     return line;
 }
+// Diff output is deferred (not written straight to stdout) so it doesn't
+// collide with the tool spinner that is still animating while the tool runs.
+const pendingDiffOutput = [];
+export function flushPendingDiffOutput() {
+    if (!pendingDiffOutput.length)
+        return;
+    process.stdout.write(pendingDiffOutput.join("\n") + "\n\n");
+    pendingDiffOutput.length = 0;
+}
 function displayDiff(pathName, oldContent, newContent) {
     if (oldContent.length + newContent.length > max_diff_source_chars) {
-        process.stdout.write(`\x1b[2m${pathName}: ${oldContent.length.toLocaleString()} chars -> ${newContent.length.toLocaleString()} chars ` +
-            `(diff hidden: exceeds ${max_diff_source_chars.toLocaleString()} char limit)\x1b[0m\n`);
+        pendingDiffOutput.push(`\x1b[2m${pathName}: ${oldContent.length.toLocaleString()} chars -> ${newContent.length.toLocaleString()} chars ` +
+            `(diff hidden: exceeds ${max_diff_source_chars.toLocaleString()} char limit)\x1b[0m`);
         return;
     }
     const patch = structuredPatch(pathName, pathName, oldContent, newContent, "", "", { context: max_diff_context_lines });
@@ -98,7 +107,7 @@ function displayDiff(pathName, oldContent, newContent) {
     const header = `\x1b[1m${pathDisp}\x1b[0m \x1b[32m+${added}\x1b[0m \x1b[31m-${removed}\x1b[0m`;
     const headerStr = `─ ${header} `;
     const top = `╭${headerStr}${"─".repeat(Math.max(0, boxW - 2 - plainLen(headerStr)))}╮`;
-    process.stdout.write(`\x1b[90m${top}\x1b[0m\n`);
+    pendingDiffOutput.push(`\x1b[90m${top}\x1b[0m`);
     for (const v of visible) {
         let line;
         if (v.kind === "+") {
@@ -114,9 +123,9 @@ function displayDiff(pathName, oldContent, newContent) {
             line = `\x1b[2m  ${body}\x1b[0m`;
         }
         const fill = Math.max(0, innerW - plainLen(line));
-        process.stdout.write(`\x1b[90m│\x1b[0m ${line}${" ".repeat(fill)} \x1b[90m│\x1b[0m\n`);
+        pendingDiffOutput.push(`\x1b[90m│\x1b[0m ${line}${" ".repeat(fill)} \x1b[90m│\x1b[0m`);
     }
-    process.stdout.write(`\x1b[90m╰${"─".repeat(boxW - 2)}╯\x1b[0m\n`);
+    pendingDiffOutput.push(`\x1b[90m╰${"─".repeat(boxW - 2)}╯\x1b[0m`);
 }
 export function truncateToolOutput(output, maxChars = max_output_chars) {
     if (output.length > maxChars) {

package/dist/ui.js

@@ -526,21 +526,31 @@ export class Spinner {
     timer = null;
     frame = 0;
     rows = 0;
-    text = "";
+    render = null;
     enabled;
+    lastRendered = "";
+    lastLen = 0;
     constructor(enabled = true) {
         this.enabled = enabled;
     }
     start(text) {
+        this.startWithRender(() => text);
+    }
+    /** Start the spinner with a render callback (recomputed each animation tick),
+     *  avoiding the need for a second, conflicting timer. */
+    startWithRender(render) {
         if (!this.enabled)
             return;
         if (this.timer) {
-            this.update(text);
+            this.render = render;
+            this.draw();
             return;
         }
-        this.text = text;
+        this.render = render;
         this.frame = 0;
         this.rows = 0;
+        this.lastRendered = "";
+        this.lastLen = 0;
         this.timer = setInterval(() => {
             this.frame++;
             this.draw();
@@ -548,29 +558,49 @@ export class Spinner {
         this.draw();
     }
     update(text) {
-        this.text = text;
-        if (this.timer)
+        if (this.timer) {
+            this.render = () => text;
             this.draw();
+        }
     }
     draw() {
+        const text = this.render ? this.render() : "";
         const icon = SPINNER_FRAMES[this.frame % SPINNER_FRAMES.length];
-        const rendered = `\x1b[36m${icon}\x1b[0m \x1b[2m${this.text}\x1b[0m`;
+        const rendered = `\x1b[36m${icon}\x1b[0m \x1b[2m${text}\x1b[0m`;
+        // Nothing changed on this tick -> do not rewrite the line (avoids flicker).
+        if (rendered === this.lastRendered)
+            return;
+        this.lastRendered = rendered;
         const newRows = Math.max(1, displayRows(rendered));
-        const clearRows = Math.max(this.rows, newRows, 1);
-        for (let i = 0; i < clearRows; i++) {
-            process.stdout.write("\r\x1b[2K");
-            if (i < clearRows - 1)
-                process.stdout.write("\n");
+        if (newRows === 1) {
+            // Overwrite in place: NEVER erase the whole line (the \x1b[2K erase-to-blank
+            // followed by a full redraw is what caused the flicker/flash). We just
+            // re-emit from the start; identical glyphs stay put, only the changed
+            // cells (spinner frame, trailing timer) actually change on screen. Pad
+            // with spaces so a shorter line clears any previously longer text.
+            const plain = stripAnsi(rendered);
+            const pad = Math.max(0, this.lastLen - plain.length);
+            process.stdout.write("\r" + rendered + " ".repeat(pad) + "\r");
+            this.lastLen = plain.length;
+        }
+        else {
+            // Multi-row wrapped text: fall back to an erase-based redraw.
+            const clearRows = Math.max(this.rows, newRows, 1);
+            for (let i = 0; i < clearRows; i++) {
+                process.stdout.write("\r\x1b[2K");
+                if (i < clearRows - 1)
+                    process.stdout.write("\n");
+            }
+            if (clearRows > 1)
+                process.stdout.write(`\x1b[${clearRows - 1}A\r`);
+            else
+                process.stdout.write("\r");
+            process.stdout.write(rendered);
+            if (newRows > 1)
+                process.stdout.write(`\x1b[${newRows - 1}A\r`);
+            else
+                process.stdout.write("\r");
         }
-        if (clearRows > 1)
-            process.stdout.write(`\x1b[${clearRows - 1}A\r`);
-        else
-            process.stdout.write("\r");
-        process.stdout.write(rendered);
-        if (newRows > 1)
-            process.stdout.write(`\x1b[${newRows - 1}A\r`);
-        else
-            process.stdout.write("\r");
         this.rows = newRows;
     }
     stop() {

package/package.json

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