@oxecli/oxe 1.0.88 → 1.0.90

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+(.+)$/);
@@ -551,17 +557,20 @@ export function dockTearDown() {
         dockFrameLines = [];
     }
 }
-/** Make a content row two rows above the box for a transient spinner: push the
- *  box down one content row, then park the cursor on it with the blank gap
- *  row (boxTop-1) preserved between it and the box. Idempotent while parked. */
-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 (dockTransient)
         return;
-    dockEraseBox();
-    dockRenderBox();
-    process.stdout.write("\x1b[2A\r");
+    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;
 }
@@ -587,35 +596,9 @@ function dockEraseBox() {
     dockGap = true;
     dockTransient = false;
 }
-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");
-    }
-    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;
-    dockTransient = 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;
@@ -623,15 +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 (two rows above the box) with content,
- *  then re-dock, keeping exactly one blank row between content and box. */
+/** 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;
@@ -639,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
@@ -925,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);
@@ -944,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;
@@ -1078,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") {
@@ -1153,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) {
@@ -1169,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;
@@ -1191,8 +1201,12 @@ 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`);
+            if (lastCursorRow > 0)
+                process.stdout.write(`\x1b[${lastCursorRow}A`);
             for (let i = 0; i < lastTotalRows; i++) {
                 process.stdout.write("\r\x1b[K");
                 if (i < lastTotalRows - 1)
@@ -1215,7 +1229,9 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = [], hin
                 dockSetInactive();
             }
             else {
-                process.stdout.write(`\x1b[${lastCursorRow}A\r`);
+                if (lastCursorRow > 0)
+                    process.stdout.write(`\x1b[${lastCursorRow}A`);
+                process.stdout.write("\r");
                 dockSetFrame((prevFrameLines ?? []).join("\n"), lastTotalRows);
                 dockEnterDocked();
             }
@@ -1243,15 +1259,21 @@ 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`);
+                // Cursor is parked at the box top (row 0). Never emit \x1b[0A (which
+                // terminals treat as "cursor up 1"): start from column 0, redraw only
+                // the changed lines, then return the cursor to the box top so dock
+                // content (AI streaming, tool results) keeps inserting above the box.
+                process.stdout.write("\r");
                 const oldLines = prevFrameLines ?? [];
                 const maxLen = Math.max(oldLines.length, newLines.length);
                 for (let i = 0; i < maxLen; i++) {
@@ -1261,14 +1283,11 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = [], hin
                     if (i < maxLen - 1)
                         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 to the box top (maxLen-1 rows up; never 0 since the frame has
+                // at least a top border, body and bottom border).
+                process.stdout.write(`\x1b[${maxLen - 1}A\r`);
                 prevFrameLines = newLines;
-                lastCursorRow = cursorRow;
+                lastCursorRow = 0;
                 lastTotalRows = totalRows;
                 dockSetFrame(frame, totalRows);
             }
@@ -1553,6 +1572,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;
             }
@@ -1593,9 +1618,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") {
@@ -1675,7 +1722,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.88",
+  "version": "1.0.90",
   "publishConfig": {
     "access": "public"
   },