@oxecli/oxe 1.0.87 → 1.0.89

package/dist/cli.js

@@ -18,6 +18,7 @@ export class CLI {
     story = [];
     sessionId = null;
     promptHistory = [];
+    lastPrompt = "";
     interruptPending = false;
     constructor() {
         clearScreen();
@@ -395,10 +396,50 @@ export class CLI {
                 const used = estimateTokens(this.inputItems);
                 const budget = max_context_tokens - context_overhead_margin;
                 const pct = Math.max(0, Math.min(100, Math.round(((budget - used) / budget) * 100)));
+                // Queries run through onSubmit so the prompt box stays focused and
+                // editable while the AI streams its reply and tool calls above it.
+                // Commands (slash inputs) settle back to this loop for handling.
+                const onSubmit = async (input, spans) => {
+                    this.interruptPending = false;
+                    this.promptHistory.push(input);
+                    this.lastPrompt = input;
+                    dockAppendContent(`\x1b[1;36m❯\x1b[0m ${userDisplayText(input, spans)}\n`);
+                    queryStarted = true;
+                    try {
+                        await engine.executeQuery(input, this.inputItems, this.story, spans);
+                    }
+                    catch (qerr) {
+                        if (qerr?.message === "interrupt") {
+                            if (!engine.queryHasOutput && !engine.queryCalledTool) {
+                                dockAppendContent(aiMarkdown("What else can I help you with?") + "\n");
+                            }
+                            engine.inQuery = false;
+                            stripOrphanCalls(this.inputItems);
+                            if (this.inputItems.length &&
+                                this.inputItems[this.inputItems.length - 1]["role"] === "user") {
+                                this.inputItems.pop();
+                            }
+                            if (this.story.length &&
+                                this.story[this.story.length - 1]["type"] === "user") {
+                                this.story.pop();
+                            }
+                            this.interruptPending = true;
+                            dockAppendContent("\x1b[90mInterrupted agent. Press Ctrl+C again to exit, or type a new prompt.\x1b[0m\n");
+                        }
+                        else if (qerr?.message !== "eof") {
+                            throw qerr;
+                        }
+                    }
+                    finally {
+                        queryStarted = false;
+                    }
+                    this.saveSession(engine);
+                };
+                const onInterrupt = () => engine.interrupt();
                 const [input, spans] = await askBottomPrompt("You", "❯", this.promptHistory, {
                     left: "\x1b[90mPress \x1b[1;36mCtrl+C\x1b[0m\x1b[90m to interrupt\x1b[0m",
                     right: `\x1b[1;36m${pct}%\x1b[0m \x1b[90muntil auto-compact\x1b[0m`,
-                });
+                }, this.lastPrompt, onSubmit, onInterrupt);
                 if (!input.trim())
                     continue;
                 this.interruptPending = false;
@@ -450,11 +491,6 @@ export class CLI {
                     }
                     continue;
                 }
-                dockAppendContent(`\x1b[1;36m❯\x1b[0m ${userDisplayText(input, spans)}\n`);
-                queryStarted = true;
-                await engine.executeQuery(input, this.inputItems, this.story, spans);
-                queryStarted = false;
-                this.saveSession(engine);
             }
             catch (err) {
                 if (err?.message === "eof") {

package/dist/config.js

@@ -191,7 +191,7 @@ export async function loadOrPrompt() {
             break;
         }
         else {
-            process.stdout.write(`\x1b[31mAuthentication Error:\x1b[0m ${validation.error}\n\n`);
+            process.stdout.write(`\x1b[31mAuthentication Error:\x1b[0m ${validation.error}\n`);
             api_key = "";
         }
     }

package/dist/engine.js

@@ -542,7 +542,7 @@ export class InferenceEngine {
                     // Print the tool label the instant the command starts, then show a
                     // "╰─ Working..." dots line that swaps to the real result in place.
                     dockAppendContent(`${started}\n`);
-                    dockTransientStart();
+                    dockTransientStart("flush");
                     const toolSpinner = new Spinner();
                     toolSpinner.startDots("\x1b[90m╰─\x1b[0m Working");
                     const rawResult = await this.runTool(c.name, c.arguments);
@@ -564,10 +564,10 @@ export class InferenceEngine {
                     // 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();
-                    dockReplaceTransient(action + "\n");
+                    dockReplaceTransient(action);
                     if (diff) {
-                        dockTransientStart();
-                        dockReplaceTransient(diff + "\n");
+                        dockTransientStart("flush");
+                        dockReplaceTransient(diff);
                     }
                     const truncatedResult = c.name === "read_file"
                         ? truncateToolOutput(rawResult, max_read_file_stored_chars)

package/dist/tools.js

@@ -31,6 +31,36 @@ function truncateDiffLine(line) {
     }
     return line;
 }
+/**
+ * Recolor bracket syntax characters (`( ) [ ] { }`) inside an already-ANSI
+ * rendered string to `fg`, restoring the row's white base after each bracket.
+ * ANSI escape sequences are skipped so the injected color codes are never
+ * corrupted. Used so a deleted (red) diff row's bracket syntax matches the
+ * red of its line number instead of inheriting the syntax highlighter's color.
+ */
+function recolorBrackets(text, fg, base) {
+    let out = "";
+    let i = 0;
+    while (i < text.length) {
+        if (text[i] === "\x1b") {
+            const m = text.slice(i).match(/^\x1b\[[0-9;]*[a-zA-Z]/);
+            if (m) {
+                out += m[0];
+                i += m[0].length;
+                continue;
+            }
+        }
+        const ch = text[i];
+        if (ch === "(" || ch === ")" || ch === "[" || ch === "]" || ch === "{" || ch === "}") {
+            out += fg + ch + base;
+        }
+        else {
+            out += ch;
+        }
+        i++;
+    }
+    return out;
+}
 // 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 = [];
@@ -148,8 +178,14 @@ function displayDiff(pathName, oldContent, newContent) {
             // the whole body.
             const raw = highlightCodeLine(v.body);
             const body = truncateStyled(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));
-            pendingDiffOutput.push(`${ind}${bg}${fg}${numStr} ${sign}  \x1b[0m${bg}\x1b[97m${body}${bg}\x1b[97m${" ".repeat(fill)}\x1b[0m`);
+            pendingDiffOutput.push(`${ind}${bg}${fg}${numStr} ${sign}  \x1b[0m${bg}\x1b[97m${shown}${bg}\x1b[97m${" ".repeat(fill)}\x1b[0m`);
         }
         else {
             const raw = v.kind === "\\" ? v.body : highlightCodeLine(v.body);

package/dist/ui.js

@@ -293,6 +293,12 @@ export function markdownToAnsi(text) {
             out.push(`\x1b[90m${"─".repeat(Math.min(width, 60))}\x1b[0m`);
             continue;
         }
+        // Collapse consecutive blank lines to a single empty row (never a leading one)
+        if (!raw.trim()) {
+            if (out.length && out[out.length - 1] !== "")
+                out.push("");
+            continue;
+        }
         let line = raw;
         // Headers (render as styled headings with the '#' markers stripped)
         const h1 = line.match(/^#\s+(.+)$/);
@@ -505,13 +511,16 @@ export function displayRows(text) {
 // one blank row is preserved between the latest content and the box.
 //
 // dockRel: how many rows the cursor sits above boxTop. 0 = parked at boxTop,
-// 1 = one row up (the gap row), where transient spinners render.
+// 2 = transient content row (spinner/thinking line), with the blank gap row
+// (boxTop-1) kept between it and the box.
+// dockTransient: true while a transient spinner is parked on the content row.
 // dockGap: true when a blank row already exists above the current row (after
 // the box is torn down), so askBottomPrompt does not add a second one.
 let docked = false;
 let dockRel = 0;
 let dockBoxRows = 0;
 let dockGap = false;
+let dockTransient = false;
 let dockFrameLines = [];
 export function dockIsDocked() {
     return docked;
@@ -528,12 +537,14 @@ export function dockSetInactive() {
     dockRel = 0;
     dockBoxRows = 0;
     dockGap = false;
+    dockTransient = false;
     dockFrameLines = [];
 }
 export function dockEnterDocked() {
     docked = true;
     dockRel = 0;
     dockGap = false;
+    dockTransient = false;
 }
 /** Erase the docked box and leave the cursor at boxTop with the gap above it,
  *  so a pager/replay can write there and a later prompt re-docks cleanly. */
@@ -546,55 +557,48 @@ export function dockTearDown() {
         dockFrameLines = [];
     }
 }
-/** Park the cursor on the gap row (above the box) for a transient spinner. */
-export function dockTransientStart() {
+/** Park a transient spinner two rows above the box (dockRel=2), keeping boxTop-1
+ *  as the single blank gap. "flush" parks the spinner directly under the
+ *  preceding content (label, spinner, blank, box); "blank" gives it its own
+ *  blank row above (echo, blank, spinner, blank, box). Idempotent while parked. */
+export function dockTransientStart(mode = "blank") {
     if (!docked || dockBoxRows < 1)
         return;
-    if (dockRel === 0) {
-        process.stdout.write("\x1b[1A\r");
-        dockRel = 1;
-    }
+    if (dockTransient)
+        return;
+    const insert = mode === "flush" ? 1 : 2;
+    process.stdout.write(`\x1b[${insert}L`);
+    if (mode === "flush")
+        process.stdout.write("\x1b[1A");
+    process.stdout.write("\r");
+    dockRel = 2;
+    dockTransient = true;
 }
+/** Erase the box and any transient rows above it, leaving the cursor at boxTop
+ *  with the gap row intact above. */
 function dockEraseBox() {
     if (!docked || dockBoxRows < 1)
         return;
-    process.stdout.write(`\x1b[${dockBoxRows - 1 + dockRel}B`);
+    const rel = dockRel;
+    process.stdout.write(`\x1b[${dockBoxRows - 1 + rel}B`);
     for (let i = 0; i < dockBoxRows; i++) {
         process.stdout.write("\r\x1b[K");
         if (i < dockBoxRows - 1)
             process.stdout.write("\x1b[1A");
     }
-    docked = false;
-    dockRel = 0;
-    dockGap = true;
-}
-function dockEraseBoxKeep() {
-    if (!docked || dockBoxRows < 1)
-        return;
-    process.stdout.write(`\x1b[${dockBoxRows - 1 + dockRel}B`);
-    for (let i = 0; i < dockBoxRows; i++) {
-        process.stdout.write("\r\x1b[K");
-        if (i < dockBoxRows - 1)
-            process.stdout.write("\x1b[1A");
+    if (rel > 0) {
+        for (let i = 0; i < rel; i++)
+            process.stdout.write("\x1b[1A\r\x1b[K");
+        process.stdout.write(`\x1b[${rel}B`);
     }
-    process.stdout.write(`\x1b[${dockRel}A`);
     docked = false;
     dockRel = 0;
     dockGap = true;
+    dockTransient = false;
 }
-/** Write exactly one blank row then the box frame below the current row, and
- *  park the cursor at the box top. */
-function dockRenderBox() {
-    if (dockBoxRows < 1)
-        return;
-    process.stdout.write("\n\n" + dockFrameLines.join("\n"));
-    process.stdout.write(`\x1b[${dockBoxRows - 1}A\r`);
-    dockRel = 0;
-    docked = true;
-    dockGap = false;
-}
-/** Commit content at the box top, pushing the box down, preserving exactly one
- *  blank row between the content and the box. */
+/** Commit content at the box top: insert `rows+1` lines to push the box down
+ *  (no erase/redraw), write the body, leave exactly one blank row between the
+ *  content and the box, and park the cursor at the new boxTop. */
 export function dockAppendContent(text) {
     if (!text)
         return;
@@ -602,14 +606,18 @@ export function dockAppendContent(text) {
         process.stdout.write(text);
         return;
     }
-    dockEraseBox();
-    process.stdout.write(text);
-    const tb = displayRows(text) - displayRows(text.replace(/\n+$/, ""));
-    if (tb > 0)
-        process.stdout.write(`\x1b[${tb}A`);
-    dockRenderBox();
+    const body = text.replace(/\n+$/, "");
+    if (!body)
+        return;
+    const rows = displayRows(body);
+    process.stdout.write(`\x1b[${rows + 1}L`);
+    process.stdout.write(body + "\n\r");
+    process.stdout.write("\x1b[1B\r");
 }
-/** Replace a transient spinner row (the gap row) with content, then re-dock. */
+/** Replace a transient spinner row (dockRel=2, two rows above the box) with
+ *  real (possibly multi-row) content: erase the spinner line, push the box
+ *  down by `rows-1` if the content is taller than the transient row, write the
+ *  content, and park the cursor at the boxTop with one blank row above it. */
 export function dockReplaceTransient(text) {
     if (!text)
         return;
@@ -617,12 +625,22 @@ export function dockReplaceTransient(text) {
         process.stdout.write(text);
         return;
     }
-    dockEraseBoxKeep();
-    process.stdout.write(text);
-    const tb = displayRows(text) - displayRows(text.replace(/\n+$/, ""));
-    if (tb > 0)
-        process.stdout.write(`\x1b[${tb}A`);
-    dockRenderBox();
+    if (!dockTransient) {
+        dockAppendContent(text);
+        return;
+    }
+    const body = text.replace(/\n+$/, "");
+    if (!body)
+        return;
+    const rows = displayRows(body);
+    const push = rows + 1 - dockRel;
+    process.stdout.write("\r\x1b[K");
+    if (push > 0)
+        process.stdout.write(`\x1b[${push}L`);
+    process.stdout.write(body);
+    process.stdout.write("\x1b[2B\r");
+    dockRel = 0;
+    dockTransient = false;
 }
 // ---------------------------------------------------------------------------
 // Cursor & Spinner
@@ -903,9 +921,23 @@ export function cursorLineCol(buffer, cursor) {
 function endsWithWs(s) {
     return s.length > 0 && /[ \t\n]/.test(s[s.length - 1]);
 }
+/**
+ * Whether a spacer should be inserted between the previous segment and the
+ * current one. A space is added when the previous segment doesn't already end
+ * in whitespace — EXCEPT for non-block (inline) pastes, which keep their
+ * leading space but never force a trailing space after them. Collapsed pasted
+ * blocks always get spaced on both sides.
+ */
+function joinNeedsSpace(prev) {
+    if (endsWithWs(prev[2]))
+        return false;
+    if (prev[1] === "text" && prev[3])
+        return false; // non-block inline paste
+    return true;
+}
 export function splitBlocks(buffer, pasteSpans) {
     if (!buffer)
-        return [["", "text", ""]];
+        return [["", "text", "", false]];
     const pts = new Set([0, buffer.length]);
     for (const [s, e] of pasteSpans) {
         pts.add(s);
@@ -922,10 +954,10 @@ export function splitBlocks(buffer, pasteSpans) {
         const text = buffer.slice(a, b);
         if (isPaste(a, b) && shouldCollapsePaste(text)) {
             const n = text.split("\n").length;
-            segs.push(["", "collapsed", `[Pasted text, ${n} lines]`]);
+            segs.push(["", "collapsed", `[Pasted text, ${n} lines]`, true]);
         }
         else {
-            segs.push(["", "text", text]);
+            segs.push(["", "text", text, isPaste(a, b)]);
         }
     }
     return segs;
@@ -1056,8 +1088,8 @@ export function renderBufferWithCursor(buffer, pasteSpans, prefix, label, cursor
             }
         }
         for (let i = 0; i < segs.length; i++) {
-            const [, kind, disp] = segs[i];
-            if (i && !endsWithWs(segs[i - 1][2]))
+            const [, kind, disp, pasted] = segs[i];
+            if (i && joinNeedsSpace(segs[i - 1]))
                 runs.push({ text: " ", style: "" });
             if (i === target) {
                 if (kind === "collapsed") {
@@ -1131,7 +1163,7 @@ function isEnterKey(str, key) {
         seq === "\x1bOM" // application keypad
     );
 }
-export function askBottomPrompt(label = "You", prefix = "❯", history = [], hints) {
+export function askBottomPrompt(label = "You", prefix = "❯", history = [], hints, initialBuffer = "", onSubmit, onInterrupt) {
     return new Promise((resolve, reject) => {
         const isTTY = process.stdin.isTTY;
         if (!isTTY) {
@@ -1147,8 +1179,8 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = [], hin
             });
             return;
         }
-        let buffer = "";
-        let cursor = 0;
+        let buffer = initialBuffer;
+        let cursor = buffer.length;
         let pasteSpans = [];
         const hist = history.slice();
         let histIdx = hist.length;
@@ -1169,6 +1201,9 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = [], hin
         let lastCursorRow = 0;
         let lastTotalRows = 0;
         let prevFrameLines = null;
+        // True while an onSubmit query is running. While it runs the box stays
+        // focused and editable; Enter won't re-submit and Ctrl+C interrupts it.
+        let submitting = false;
         const clearBox = () => {
             process.stdout.write(`\x1b[${lastCursorRow}A`);
             for (let i = 0; i < lastTotalRows; i++) {
@@ -1221,12 +1256,14 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = [], hin
                         process.stdout.write("\n");
                 }
                 prevFrameLines = newLines;
-                lastCursorRow = cursorRow;
+                lastCursorRow = 0;
                 lastTotalRows = totalRows;
                 dockSetFrame(frame, totalRows);
                 dockEnterDocked();
-                const up = totalRows - 1 - cursorRow;
-                process.stdout.write(`\x1b[${up}A\r\x1b[${cursorCol}C`);
+                // Park the cursor at the box top so concurrent dock content (AI
+                // streaming, tool results) inserts above the box rather than into it.
+                const up = totalRows - 1;
+                process.stdout.write(`\x1b[${up}A\r`);
             }
             else {
                 process.stdout.write(`\x1b[${lastCursorRow}A\r`);
@@ -1240,13 +1277,11 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = [], hin
                         process.stdout.write("\n");
                 }
                 const atLine = maxLen - 1;
-                if (atLine > cursorRow)
-                    process.stdout.write(`\x1b[${atLine - cursorRow}A`);
-                else if (atLine < cursorRow)
-                    process.stdout.write(`\x1b[${cursorRow - atLine}B`);
-                process.stdout.write(`\r\x1b[${cursorCol}C`);
+                // Return the cursor to the box top so concurrent dock content keeps
+                // inserting above the box.
+                process.stdout.write(`\x1b[${atLine}A\r`);
                 prevFrameLines = newLines;
-                lastCursorRow = cursorRow;
+                lastCursorRow = 0;
                 lastTotalRows = totalRows;
                 dockSetFrame(frame, totalRows);
             }
@@ -1531,6 +1566,12 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = [], hin
                 pasteBurstTimer = null;
             }
             if (key && key.ctrl && key.name === "c") {
+                // While a query is running, Ctrl+C interrupts the query instead of
+                // leaving the prompt (the box stays focused for editing).
+                if (submitting && onInterrupt) {
+                    onInterrupt();
+                    return;
+                }
                 settle(new Error("interrupt"), true);
                 return;
             }
@@ -1571,9 +1612,31 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = [], hin
                 return;
             }
             if (isEnterKey(str, key)) {
-                if (buffer.trim()) {
-                    settle([buffer, pasteSpans], false);
+                const trimmed = buffer.trim();
+                if (!trimmed)
+                    return;
+                // While a query is running the box stays focused and editable; Enter is
+                // ignored (even for commands) so the query finishes cleanly first.
+                if (submitting)
+                    return;
+                // With an onSubmit handler, ordinary prompts are submitted in place so
+                // the box stays focused and editable while the query streams above it.
+                // Slash commands (and any prompt when no handler is wired) settle so the
+                // caller's existing command loop handles them.
+                if (onSubmit && !trimmed.startsWith("/")) {
+                    submitting = true;
+                    const submitted = buffer;
+                    const submittedSpans = pasteSpans.slice();
+                    Promise.resolve()
+                        .then(() => onSubmit(submitted, submittedSpans))
+                        .then(() => {
+                        submitting = false;
+                    }, () => {
+                        submitting = false;
+                    });
+                    return;
                 }
+                settle([buffer, pasteSpans], false);
                 return;
             }
             if (key && key.name === "backspace") {
@@ -1653,7 +1716,7 @@ export function userDisplayText(payload, pasteSpans) {
         let out = "";
         for (let i = 0; i < segs.length; i++) {
             const [, kind, disp] = segs[i];
-            if (i && !endsWithWs(segs[i - 1][2]))
+            if (i && joinNeedsSpace(segs[i - 1]))
                 out += " ";
             out += kind === "collapsed" ? `\x1b[1;36m${disp}\x1b[0m` : disp;
         }

package/package.json

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