@oxecli/oxe 1.0.14 → 1.0.16

package/dist/config.js

@@ -145,7 +145,7 @@ export const SYSTEM_PROMPT_BODY = "You are a terminal-based coding agent named O
     "consequence in your response.\n";
 export const API_KEY_MAX = 64;
 import { validateOxeApiKey } from "./api.js";
-import { renderPanel, markupToAnsi } from "./ui.js";
+import { renderPanel, markupToAnsi, hideCursor, showCursor } from "./ui.js";
 export async function loadOrPrompt() {
     let api_key = "";
     let key_data = {};
@@ -164,9 +164,13 @@ export async function loadOrPrompt() {
         }
         process.stdout.write("\n");
         const authSpinner = new Spinner();
+        // promptApiKey echoes input with the cursor visible; hide it while the
+        // validating-key label runs so no stray block cursor sits beside it.
+        hideCursor();
         authSpinner.start("Authenticating key with Oxe Cloud…");
         const validation = await validateOxeApiKey(api_key);
         authSpinner.stop();
+        showCursor();
         if (validation.valid) {
             key_data = validation.key_data || {};
             process.stdout.write(markupToAnsi(`[green]✓ Oxe API Key verified[/green] [dim](${String(key_data["name"] ?? "Desktop")})[/dim]`) + "\n");

package/dist/ui.js

@@ -456,15 +456,76 @@ export function splitBlocks(buffer, pasteSpans) {
     }
     return segs;
 }
+const PROMPT_CARET = "\u0000"; // sentinel marking the caret position
+/**
+ * Wrap styled runs into physical rows of `width` visible columns, wrapping long
+ * lines so the panel box stays rectangular (mirrors rich's Panel auto-wrap).
+ * Returns the styled rows (no borders) and the caret's (row, col) in content
+ * coordinates, or (-1,-1) if no caret sentinel is present.
+ */
+function wrapRuns(runs, width) {
+    const rows = [];
+    let cur = "";
+    let curLen = 0;
+    let caretRow = -1;
+    let caretCol = -1;
+    const flush = () => {
+        rows.push(cur);
+        cur = "";
+        curLen = 0;
+    };
+    for (const run of runs) {
+        if (run.text === PROMPT_CARET) {
+            // Caret occupies one visible column; if the current row is full, move it
+            // to the start of the next row so it stays inside the box.
+            if (curLen >= width)
+                flush();
+            caretRow = rows.length;
+            caretCol = curLen;
+            cur += run.style + "▏" + "\x1b[0m";
+            curLen += 1;
+            continue;
+        }
+        let text = run.text;
+        while (text) {
+            // Split off the leading run up to the next newline (if any).
+            const nl = text.indexOf("\n");
+            const seg = nl === -1 ? text : text.slice(0, nl);
+            let rest = seg;
+            while (rest.length > 0) {
+                if (curLen >= width)
+                    flush();
+                const take = Math.min(rest.length, width - curLen);
+                const chunk = rest.slice(0, take);
+                cur += run.style ? run.style + chunk + "\x1b[0m" : chunk;
+                curLen += take;
+                rest = rest.slice(take);
+            }
+            if (nl !== -1) {
+                flush();
+                text = text.slice(nl + 1);
+            }
+            else {
+                break;
+            }
+        }
+    }
+    flush();
+    return { rows, caretRow, caretCol };
+}
 export function renderBufferWithCursor(buffer, pasteSpans, prefix, label, cursor) {
     const w = terminalWidth();
     const borderW = Math.max(w - 4, 10);
-    const [row, col] = cursorLineCol(buffer, cursor);
-    // Build the inner content: prefix, then the text with the `▏` block cursor
-    // always drawn at the cursor position (mirrors the original rich frame).
-    let display;
+    // Content width inside the box (between `│ ` and ` │`).
+    const innerW = borderW - 2;
+    // Build styled runs: prefix, then the text with the `▏` block caret always
+    // drawn at the cursor position (mirrors the original rich frame).
+    const runs = [];
+    runs.push({ text: prefix, style: "\x1b[1m" });
+    runs.push({ text: " ", style: "" });
     if (!buffer) {
-        display = `\x1b[1m▏\x1b[0m\x1b[2m${PROMPT_PLACEHOLDER}\x1b[0m`;
+        runs.push({ text: PROMPT_CARET, style: "\x1b[1m" });
+        runs.push({ text: PROMPT_PLACEHOLDER, style: "\x1b[2m" });
     }
     else {
         const segs = splitBlocks(buffer, pasteSpans);
@@ -513,50 +574,49 @@ export function renderBufferWithCursor(buffer, pasteSpans, prefix, label, cursor
                 inside = ranges.length ? ranges[ranges.length - 1][1] - ranges[ranges.length - 1][0] : 0;
             }
         }
-        display = "";
         for (let i = 0; i < segs.length; i++) {
             const [, kind, disp] = segs[i];
             if (i && !endsWithWs(segs[i - 1][2]))
-                display += " ";
+                runs.push({ text: " ", style: "" });
             if (i === target) {
                 if (kind === "collapsed") {
-                    display += `\x1b[1m\x1b[36m${disp}\x1b[0m`;
+                    runs.push({ text: disp, style: "\x1b[1m\x1b[36m" });
                     if (!endsWithWs(disp))
-                        display += " ";
-                    display += `\x1b[1m▏\x1b[0m`;
+                        runs.push({ text: " ", style: "" });
+                    runs.push({ text: PROMPT_CARET, style: "\x1b[1m" });
                 }
                 else {
-                    const bold = i === target;
-                    display += disp.slice(0, inside);
-                    display += `\x1b[1m▏\x1b[0m`;
-                    display += disp.slice(inside);
+                    const before = disp.slice(0, inside);
+                    const after = disp.slice(inside);
+                    if (before)
+                        runs.push({ text: before, style: "" });
+                    runs.push({ text: PROMPT_CARET, style: "\x1b[1m" });
+                    if (after)
+                        runs.push({ text: after, style: "" });
                 }
             }
             else {
-                display += kind === "collapsed" ? `\x1b[1m\x1b[36m${disp}\x1b[0m` : disp;
+                runs.push({ text: disp, style: kind === "collapsed" ? "\x1b[1m\x1b[36m" : "" });
             }
         }
     }
-    const content = `\x1b[1m${prefix}\x1b[0m ${display}`;
-    const lines = content.split("\n");
+    const { rows, caretRow, caretCol } = wrapRuns(runs, innerW);
     // Top border with the label embedded on the left.
     const topPad = Math.max(borderW - label.length - 2, 0);
     const top = `\x1b[90m╭─ ${label} ${"─".repeat(topPad)}╮\x1b[0m`;
     // Body rows.
     const body = [];
-    for (const l of lines) {
+    for (const l of rows) {
         const plain = l.replace(/\x1b\[[0-9;]*m/g, "");
         const pad = Math.max(borderW - 2 - plain.length, 0);
         body.push(`\x1b[90m│\x1b[0m ${l}${" ".repeat(pad)} \x1b[90m│\x1b[0m`);
     }
     const bottom = `\x1b[90m╰${"─".repeat(borderW)}╯\x1b[0m`;
     const frame = [top, ...body, bottom].join("\n");
-    // Cursor placement: one row below the top border. Preceding columns are
-    // `│ ` (2) + prefix (prefix.length) + ` ` (1) = prefix.length+3, so the first
-    // display char (the `▏` block cursor) sits at column prefix.length+4 relative
-    // to line column `col`.
-    const cursorRow = row + 1;
-    const cursorCol = col + prefix.length + 4;
+    // Cursor placement: one row below the top border. The body prefix (`│ `)
+    // shifts the content right by 2 columns, so add 2 to the wrapped caret col.
+    const cursorRow = (caretRow === -1 ? 0 : caretRow) + 1;
+    const cursorCol = (caretCol === -1 ? 0 : caretCol) + 2;
     const totalRows = body.length + 2;
     return { frame, cursorRow, cursorCol, totalRows };
 }
@@ -670,12 +730,37 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = []) {
                 return;
             }
         };
-        const insert = (text) => {
+        const shiftSpansAfterInsert = (pos, delta) => {
+            const newSpans = [];
+            for (const [s, e] of pasteSpans) {
+                if (pos <= s)
+                    newSpans.push([s + delta, e + delta]);
+                else if (pos >= e)
+                    newSpans.push([s, e]);
+                else {
+                    newSpans.push([s, pos]);
+                    newSpans.push([pos + delta, e + delta]);
+                }
+            }
+            return newSpans;
+        };
+        const insert = (text, isPaste = false) => {
             if (histIdx !== hist.length) {
                 draft = { buffer, cursor, spans: pasteSpans.slice() };
                 histIdx = hist.length;
             }
+            const pasteStart = cursor;
             buffer = buffer.slice(0, cursor) + text + buffer.slice(cursor);
+            // Keep existing paste spans valid across the insertion point.
+            pasteSpans = shiftSpansAfterInsert(cursor, text.length);
+            // A real paste records a span so the prompt box can collapse it (mirrors
+            // Python's handle_paste). splitBlocks only collapses segments inside a
+            // span that meet the threshold, so small pastes stay expanded but remain
+            // tagged for cursor/backspace handling.
+            if (isPaste) {
+                pasteSpans.push([pasteStart, pasteStart + text.length]);
+                pasteSpans.sort((a, b) => a[0] - b[0]);
+            }
             cursor += text.length;
         };
         const backspace = () => {
@@ -689,18 +774,53 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = []) {
             const before = Array.from(buffer.slice(0, cursor));
             before.pop();
             buffer = before.join("") + buffer.slice(cursor);
+            const deletedAt = cursor - 1;
             cursor -= 1;
+            // Adjust spans: shrink any span covering the deleted char, shift spans
+            // that start after it left by one.
+            const adjusted = [];
+            for (const [s, e] of pasteSpans) {
+                if (deletedAt >= s && deletedAt < e) {
+                    const ne = e - 1;
+                    if (s < ne)
+                        adjusted.push([s, ne]);
+                }
+                else if (deletedAt < s) {
+                    adjusted.push([s - 1, e - 1]);
+                }
+                else {
+                    adjusted.push([s, e]);
+                }
+            }
+            pasteSpans = adjusted.filter(([s, e]) => s < e);
         };
         const moveLeft = () => {
-            if (cursor > 0)
-                cursor -= 1;
+            if (cursor <= 0)
+                return;
+            // Jump the caret to the start of a paste span it sits just past (mirrors
+            // Python), so a collapsed block is treated as one unit.
+            for (const [s, e] of pasteSpans) {
+                if (s < cursor && cursor <= e) {
+                    cursor = s;
+                    return;
+                }
+            }
+            cursor -= 1;
         };
         const moveRight = () => {
-            if (cursor < buffer.length)
-                cursor += 1;
+            if (cursor >= buffer.length)
+                return;
+            for (const [s, e] of pasteSpans) {
+                if (s <= cursor && cursor < e) {
+                    cursor = e;
+                    return;
+                }
+            }
+            cursor += 1;
         };
         const moveUp = () => {
             if (!buffer.includes("\n")) {
+                // Single row: navigate command history.
                 if (!hist.length)
                     return;
                 if (histIdx === hist.length) {
@@ -712,10 +832,21 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = []) {
                     cursor = buffer.length;
                     pasteSpans = [];
                 }
+                return;
+            }
+            // Multi row: move the caret up to the previous line, preserving column.
+            if (cursor > 0) {
+                let lineStart = buffer.lastIndexOf("\n", cursor - 1);
+                lineStart = lineStart !== -1 ? lineStart : 0;
+                let prevStart = buffer.lastIndexOf("\n", lineStart - 1);
+                prevStart = prevStart !== -1 ? prevStart : 0;
+                const [, col] = cursorLineCol(buffer, cursor);
+                cursor = prevStart + Math.min(col, lineStart - prevStart);
             }
         };
         const moveDown = () => {
             if (!buffer.includes("\n")) {
+                // Single row: navigate command history.
                 if (histIdx === hist.length || !draft)
                     return;
                 histIdx += 1;
@@ -729,6 +860,21 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = []) {
                     cursor = buffer.length;
                     pasteSpans = [];
                 }
+                return;
+            }
+            // Multi row: move the caret down to the next line, preserving column.
+            if (cursor < buffer.length) {
+                const [, col] = cursorLineCol(buffer, cursor);
+                let nextStart = buffer.indexOf("\n", cursor);
+                if (nextStart === -1) {
+                    cursor = buffer.length;
+                }
+                else {
+                    nextStart += 1;
+                    let nxtEnd = buffer.indexOf("\n", nextStart);
+                    nxtEnd = nxtEnd !== -1 ? nxtEnd : buffer.length;
+                    cursor = Math.min(nextStart + col, nxtEnd);
+                }
             }
         };
         const onKeypress = (str, key) => {
@@ -782,8 +928,9 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = []) {
                 return;
             }
             if (str) {
-                // paste / multi-char sequence
-                insert(str);
+                // Multi-char sequence = a paste (single-char typed keys arrive one per
+                // event). Tag it so the prompt box collapses it when it meets the rules.
+                insert(str, str.length > 1);
                 repaint();
             }
         };

package/package.json

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