@oxecli/oxe 1.0.102 → 1.0.104

package/README.md

@@ -20,7 +20,9 @@ Install Oxe globally with npm:
 
 
 
-Features
+**Features**
+
+
 
 * Terminal-native — Work directly from your CLI.
 * Codebase-aware — Inspect and understand your project before making changes.

package/dist/ui.js

@@ -667,13 +667,17 @@ export function dockTransientStart(mode = "blank") {
         return;
     dockEraseBox();
     if (mode === "flush") {
-        // Park on the gap row directly under the preceding content (adjacent).
+        // Park directly under the preceding content (adjacent, no blank above), but
+        // still keep one blank row between the transient and the box — otherwise the
+        // working line (and the tool result that replaces it) sits flush against the
+        // prompt box. dockRel=2 mirrors the blank mode's spacing below the row.
         process.stdout.write("\x1b[1A\r");
         process.stdout.write("\n");
+        process.stdout.write("\n");
         process.stdout.write(dockFrameLines.join("\n"));
         process.stdout.write(`\x1b[${dockBoxRows - 1}A`);
-        process.stdout.write("\x1b[1A\r");
-        dockRel = 1;
+        process.stdout.write("\x1b[2A\r");
+        dockRel = 2;
     }
     else {
         // Park on a fresh spinner row that keeps a blank above and below it.
@@ -750,49 +754,64 @@ function dockRenderBox() {
 /**
  * Redraw the docked prompt box with the given buffer/caret, keeping whatever
  * content already streams above it. Used to make the prompt field live-edit
- * while a query runs. Erases the box, writes the new frame, and parks the
- * cursor at the caret. Preserves exactly one blank row between the last content
- * and the box. When a transient (thinking/working spinner) is parked above the
- * box, it is rebuilt above the new frame and the physical cursor stays on that
- * transient row, so streaming content is never pulled into the prompt.
+ * while a query runs. Preserves exactly one blank row between the last content
+ * and the box. Rows that did not change (top border, hint row) are left
+ * untouched, so static parts never flicker on each keystroke. When a transient
+ * (thinking/working spinner) is parked above the box, the physical cursor stays
+ * on that transient row, so streaming content is never pulled into the prompt
+ * and the box does not drift.
  */
 export function dockRenderPrompt(buffer, pasteSpans, prefix, label, hints) {
     if (!docked || dockBoxRows < 1)
         return;
-    // If a thinking/working spinner is currently parked above the box, typing
-    // must NOT disturb it. dockEraseBox() wipes that transient row and resets
-    // its state; the still-running spinner then keeps drawing at the physical
-    // caret (now inside the box), pulling streaming content into the prompt.
-    // Capture the transient before erasing so we can rebuild it above the frame
-    // and park the cursor back on the transient row, keeping the box intact.
     const wasTransient = dockTransient;
     const wasRel = dockRel;
+    const wasCaret = dockCaretBelow;
     const { frame, cursorRow, cursorCol, totalRows } = renderBufferWithCursor(buffer, pasteSpans, prefix, label, buffer.length, hints);
-    dockEraseBox();
+    const newLines = frame.split("\n");
+    const oldLines = dockFrameLines.length ? dockFrameLines : newLines;
+    // Move the caret to the box's top row (R). The physical cursor is either on
+    // the transient row (R - wasRel) or at the live caret (R + wasCaret).
+    if (wasTransient)
+        process.stdout.write(`\x1b[${wasRel}B\r`);
+    else if (wasCaret > 0)
+        process.stdout.write(`\x1b[${wasCaret}A\r`);
+    // In-place line diff: rewrite only lines that actually changed (the body),
+    // leaving unchanged rows (top border, hint row) untouched so they never
+    // flicker. Clear each rewritten row so a shorter line leaves no residue.
+    const maxLen = Math.max(oldLines.length, newLines.length);
+    for (let i = 0; i < maxLen; i++) {
+        if (newLines[i] !== oldLines[i]) {
+            process.stdout.write("\r\x1b[K" + (newLines[i] ?? ""));
+        }
+        if (i < maxLen - 1)
+            process.stdout.write("\n");
+    }
+    // Reposition the caret.
+    if (wasTransient) {
+        // Park back on the transient row so the running spinner keeps drawing there.
+        process.stdout.write(`\x1b[${maxLen - 1 + wasRel}A\r`);
+    }
+    else {
+        const atLine = maxLen - 1;
+        if (atLine > cursorRow)
+            process.stdout.write(`\x1b[${atLine - cursorRow}A\r`);
+        else if (atLine < cursorRow)
+            process.stdout.write(`\x1b[${cursorRow - atLine}B\r`);
+        process.stdout.write(`\x1b[${cursorCol}C`);
+    }
+    dockSetFrame(frame, totalRows);
     if (wasTransient) {
-        // dockEraseBox has left the transient row and gap still present above the
-        // box-top row (cleared but physically occupying rows R-2 and R-1). Write
-        // the frame at R and park the cursor back on the transient row (R-2) so the
-        // running spinner keeps drawing THERE instead of on/inside the box. Do NOT
-        // write any leading newlines: they would push the box down and add a blank
-        // row on every keystroke.
-        process.stdout.write(frame);
-        process.stdout.write(`\x1b[${totalRows - 1 + wasRel}A\r`);
-        dockSetFrame(frame, totalRows);
         docked = true;
         dockGap = false;
         dockTransient = true;
         dockRel = wasRel;
         dockCaretBelow = 0;
-        return;
     }
-    process.stdout.write(frame);
-    // Park the cursor at the caret inside the box (cursorRow is 1-indexed, so
-    // the caret sits cursorRow rows below boxTop).
-    process.stdout.write(`\x1b[${totalRows - 1 - cursorRow}A\r\x1b[${cursorCol}C`);
-    dockSetFrame(frame, totalRows);
-    dockEnterDocked();
-    dockCaretBelow = cursorRow;
+    else {
+        dockEnterDocked();
+        dockCaretBelow = cursorRow;
+    }
 }
 /** Commit content at the box top, pushing the box down, preserving exactly one
  *  blank row between the content and the box. */
@@ -1375,6 +1394,7 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = [], hin
         let draft = null;
         let bracketedPaste = false;
         let bracketedPasteBuffer = "";
+        let bracketedPasteSince = 0;
         let pasteBurst = false;
         let pasteBurstTimer = null;
         readline.emitKeypressEvents(process.stdin);
@@ -1409,6 +1429,8 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = [], hin
                 : value;
             process.stdout.write("\x1b[?2004l");
             process.stdin.setRawMode(false);
+            bracketedPaste = false;
+            bracketedPasteBuffer = "";
             if (pasteBurstTimer)
                 clearTimeout(pasteBurstTimer);
             if (isErr) {
@@ -1699,6 +1721,7 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = [], hin
             const value = str || "";
             if (!bracketedPaste && (sequence === start || value === start)) {
                 bracketedPaste = true;
+                bracketedPasteSince = Date.now();
                 bracketedPasteBuffer = "";
                 const inline = value === start ? "" : value.startsWith(start) ? value.slice(start.length) : "";
                 if (inline)
@@ -1719,6 +1742,29 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = [], hin
             }
             if (!bracketedPaste)
                 return false;
+            // Safety net: if the paste-end marker (\x1b[201~) was lost — interrupted
+            // paste, split escape sequence, or a terminal quirk — bracketedPaste stays
+            // true and every later keystroke is swallowed here, which looks like the
+            // input field locked up (even Ctrl+C is captured as a paste chunk). If the
+            // paste has been open far longer than any real paste takes and a fresh
+            // single-printable-char keystroke arrives, flush the buffered text as
+            // literal input and reset so typing works again.
+            if (Date.now() - bracketedPasteSince > 3000 &&
+                str &&
+                str.length === 1 &&
+                !key?.ctrl &&
+                !key?.meta) {
+                const pasted = bracketedPasteBuffer
+                    .replace(/\r\n/g, "\n")
+                    .replace(/\r/g, "\n");
+                bracketedPaste = false;
+                bracketedPasteBuffer = "";
+                if (pasted) {
+                    insert(pasted, true);
+                    repaint();
+                }
+                return false; // let this keystroke be handled normally below
+            }
             if (sequence === end || value === end) {
                 const pasted = bracketedPasteBuffer.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
                 bracketedPaste = false;

package/package.json

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