@oxecli/oxe 1.0.96 → 1.0.98

package/dist/cli.js

@@ -4,7 +4,7 @@ import { fileURLToPath } from "node:url";
 import { loadOrPrompt, default_reasoning_effort, max_action_chars, max_resume_history_items, runtimeOsSummary, max_context_tokens, context_overhead_margin, } from "./config.js";
 import { InferenceEngine, estimateTokens } from "./engine.js";
 import { saveSession, loadSession, listSessions, nextSessionId, conversationLabel, COMMAND_HELP, stripOrphanCalls, toolOutputFailed, } from "./sessions.js";
-import { clearScreen, enableAnsi, askBottomPrompt, userDisplayText, aiMarkdown, mutedMarkdown, messageText, toolCallLabel, formatToolResult, truncateEllipsis, stripAnsi, plainLen, truncateStyled, terminalWidth, TOOL_RESULT_MAX_LINES, MAX_COMMAND_DISPLAY_CHARS, renderPanel, renderTableString, enableRawStdin, disableRawStdin, waitRawKey, dockAppendContent, dockSetInactive, dockTearDown, startDraftCapture, } from "./ui.js";
+import { clearScreen, enableAnsi, askBottomPrompt, userDisplayText, aiMarkdown, mutedMarkdown, messageText, toolCallLabel, formatToolResult, truncateEllipsis, stripAnsi, plainLen, truncateStyled, terminalWidth, TOOL_RESULT_MAX_LINES, MAX_COMMAND_DISPLAY_CHARS, renderPanel, renderTableString, enableRawStdin, disableRawStdin, waitRawKey, dockAppendContent, dockSetInactive, dockTearDown, dockRenderPrompt, startDraftCapture, } from "./ui.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
 const packageInfo = require("../package.json");
@@ -20,6 +20,13 @@ export class CLI {
     promptHistory = [];
     lastPrompt = "";
     interruptPending = false;
+    /**
+     * When a prompt is submitted during an in-flight query (Enter while the AI is
+     * responding), we interrupt the query silently and queue the submitted prompt
+     * here so the next loop iteration processes it directly without showing the
+     * "Interrupted agent" alert.
+     */
+    autoSubmit = null;
     constructor() {
         clearScreen();
         this.renderHeader();
@@ -404,14 +411,33 @@ export class CLI {
                 const pct = Math.max(0, Math.min(100, Math.round(((budget - used) / budget) * 100)));
                 // Queries run the proven settle-on-Enter flow: the prompt settles and
                 // the query streams above it (robust dock streaming). While the query
-                // runs, typed keys are captured into a draft; the draft (or the sent
-                // prompt) is restored into the next prompt box so input is never lost.
-                const [input, spans] = await askBottomPrompt("You", "❯", this.promptHistory, {
+                // runs, the prompt box stays live-editable: typed keys are rendered
+                // into the box, and Enter submits a new prompt that interrupts the
+                // running response (no "Interrupted agent" alert) and is processed
+                // immediately. A plain (non-submitted) draft is restored into the next
+                // prompt box so input is never lost.
+                const hints = {
                     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);
-                if (!input.trim())
-                    continue;
+                };
+                let input;
+                let spans;
+                if (this.autoSubmit) {
+                    // A prompt was submitted while the previous response was running. It
+                    // has already interrupted that response; process it directly, first
+                    // clearing the prompt box as a normal send would.
+                    input = this.autoSubmit.input;
+                    spans = this.autoSubmit.spans;
+                    this.autoSubmit = null;
+                    dockRenderPrompt("", [], "You", "❯", hints);
+                }
+                else {
+                    const got = await askBottomPrompt("You", "❯", this.promptHistory, hints, this.lastPrompt);
+                    input = got[0];
+                    spans = got[1];
+                    if (!input.trim())
+                        continue;
+                }
                 this.interruptPending = false;
                 this.promptHistory.push(input);
                 const lower = input.trim().toLowerCase();
@@ -463,18 +489,25 @@ export class CLI {
                     continue;
                 }
                 dockAppendContent(`\x1b[1;36m❯\x1b[0m ${userDisplayText(input, spans)}\n`);
-                // Empty the prompt field as soon as the prompt is sent. Only a draft
-                // typed while the query runs is restored into the next box.
+                // Empty the prompt field as soon as the prompt is sent. A draft typed
+                // while the query runs is rendered into the box and restored into the
+                // next one; Enter submits it as a new prompt.
                 this.lastPrompt = "";
                 queryStarted = true;
-                const stopCapture = startDraftCapture(() => engine.interrupt());
+                const stopCapture = startDraftCapture(() => engine.interrupt(), (buf, sp) => dockRenderPrompt(buf, sp, "You", "❯", hints));
                 try {
                     await engine.executeQuery(input, this.inputItems, this.story, spans);
                 }
                 finally {
                     const captured = stopCapture();
-                    if (captured.trim())
-                        this.lastPrompt = captured;
+                    if (captured.submitted && captured.draft.trim()) {
+                        // The user pressed Enter during the response: interrupt it and queue
+                        // the new prompt so the next loop iteration sends it (silently).
+                        this.autoSubmit = { input: captured.draft, spans: [] };
+                    }
+                    else if (captured.draft.trim()) {
+                        this.lastPrompt = captured.draft;
+                    }
                     queryStarted = false;
                 }
                 this.saveSession(engine);
@@ -488,6 +521,24 @@ export class CLI {
                 }
                 if (err?.message === "interrupt") {
                     const wasActive = queryStarted || engine.inQuery;
+                    // A prompt submitted during the response was queued in `autoSubmit`
+                    // (by the finally above). Interrupt silently — no "Interrupted agent"
+                    // alert — and let the next iteration process the new prompt (the loop
+                    // top consumes `autoSubmit`).
+                    if (this.autoSubmit && this.autoSubmit.input.trim()) {
+                        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 = false;
+                        continue;
+                    }
                     if (wasActive && !engine.queryHasOutput && !engine.queryCalledTool) {
                         dockAppendContent(aiMarkdown("What else can I help you with?") + "\n");
                     }

package/dist/engine.js

@@ -155,11 +155,12 @@ export class InferenceEngine {
         let sawReasoning = false;
         let status = null;
         let thinkingStart = null;
-        // A "Worked for …" block is committed once per working phase. Each phase is
-        // interrupted (and the flag reset) by either real answer text or a tool
-        // call, so unlimited working blocks can appear — but never two in a row
-        // without an answer or tool call in between. The total worked time also
-        // lands in the final footer.
+        // A "Worked for …" block is committed once per working phase. The flag is
+        // reset whenever a tool call runs (in the tool loop below), which is the
+        // only way a later phase can begin — the loop only continues after a tool
+        // call. So unlimited working blocks can appear, but never two in a row
+        // without a tool call in between. An answer ends the query. The total
+        // worked time also lands in the final footer.
         const showWorkSpinner = !this.workedCommitted;
         if (showWorkSpinner)
             dockTransientStart();
@@ -184,10 +185,7 @@ export class InferenceEngine {
             const t = tickDuration(elapsed);
             if (!showWorkSpinner)
                 return;
-            // Reset immediately so a later working phase (after an answer or a tool
-            // call) may commit a fresh block; the per-streamOnce guard above keeps
-            // the current phase from duplicating.
-            this.workedCommitted = false;
+            this.workedCommitted = true;
             story.push({ type: "worked", text: `Worked for ${t}` });
             dockReplaceTransient(mutedMarkdown(`Worked for ${t}`) + "\n");
         };
@@ -555,6 +553,10 @@ export class InferenceEngine {
                     dockAppendContent(summary() + "\n");
                     return;
                 }
+                // A successful turn (text or tool call) after a retry must not leave the
+                // cut-off retry prompts in the transcript — they'd pollute the context of
+                // later turns. Drop them now that the retry produced real output.
+                dropRetryPrompts(conversation, inputItems, retryPrompts);
                 if (!calls.length) {
                     story.push({ type: "footer", text: footerText() });
                     attachFooter(conversation);

package/dist/ui.js

@@ -39,14 +39,18 @@ export function waitRawKey() {
     });
 }
 /**
- * Capture typed input while a query runs (the prompt box is torn down during
- * streaming). Keystrokes are accumulated into a draft that the next prompt box
- * is pre-filled with, so nothing the user types while the AI is busy is lost.
- * Returns a stop() function returning the captured draft (may be empty).
+ * Capture typed input while a query runs (the prompt box is docked during
+ * streaming). Keystrokes are accumulated into a draft AND rendered into the
+ * docked prompt box via `renderBox`, so the user sees their input live while
+ * the AI is busy. Enter submits the draft: it interrupts the running query
+ * (as if Ctrl+C) and flags `submitted`, so the caller can send the new prompt.
+ * Returns a stop() function returning `{ draft, submitted }`.
  */
-export function startDraftCapture(onInterrupt) {
+export function startDraftCapture(onInterrupt, renderBox) {
     let draft = "";
+    let pasteSpans = [];
     let active = true;
+    let submitted = false;
     const onKey = (str, key) => {
         if (!active)
             return;
@@ -56,14 +60,24 @@ export function startDraftCapture(onInterrupt) {
         }
         if (key && key.ctrl && (key.name === "d" || key.name === "z"))
             return;
+        if (isEnterKey(str, key)) {
+            if (draft.trim()) {
+                submitted = true;
+                active = false;
+                onInterrupt();
+            }
+            return;
+        }
+        if (key && (key.name === "enter" || key.name === "linefeed"))
+            return;
         if (key && key.name === "backspace") {
             draft = draft.slice(0, -1);
+            renderBox?.(draft, pasteSpans);
             return;
         }
-        if (key && (key.name === "return" || key.name === "enter"))
-            return;
         if (str && !key?.ctrl && !key?.meta) {
             draft += str.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+            renderBox?.(draft, pasteSpans);
         }
     };
     readline.emitKeypressEvents(process.stdin);
@@ -81,7 +95,7 @@ export function startDraftCapture(onInterrupt) {
             /* ignore */
         }
         process.stdin.pause();
-        return draft;
+        return { draft, submitted };
     };
 }
 // ---------------------------------------------------------------------------
@@ -568,6 +582,13 @@ let dockBoxRows = 0;
 let dockGap = false;
 let dockTransient = false;
 let dockFrameLines = [];
+/**
+ * How many rows the caret sits BELOW boxTop when the prompt box is being
+ * live-edited during a query (0 = cursor parked at boxTop / transient, the
+ * normal dock invariant). dockEraseBox must know this to erase the box from
+ * the caret's position instead of assuming the cursor is at boxTop.
+ */
+let dockCaretBelow = 0;
 export function dockIsDocked() {
     return docked;
 }
@@ -585,12 +606,14 @@ export function dockSetInactive() {
     dockGap = false;
     dockTransient = false;
     dockFrameLines = [];
+    dockCaretBelow = 0;
 }
 export function dockEnterDocked() {
     docked = true;
     dockRel = 0;
     dockGap = false;
     dockTransient = false;
+    dockCaretBelow = 0;
 }
 /** 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. */
@@ -639,12 +662,18 @@ export function dockTransientStart(mode = "blank") {
     dockTransient = true;
 }
 /** Erase the box and any transient rows above it, leaving the cursor at boxTop
- *  with the gap row intact above. */
+ *  with the gap row intact above. Handles the cursor being parked at boxTop,
+ *  above it (transient), or inside it at the live-edit caret. */
 function dockEraseBox() {
     if (!docked || dockBoxRows < 1)
         return;
     const rel = dockRel;
-    process.stdout.write(`\x1b[${dockBoxRows - 1 + rel}B`);
+    const caret = dockCaretBelow;
+    // Move from the cursor to the box's bottom row, then erase the box upward.
+    //   cursor at boxTop - rel (transient): go down (dockBoxRows - 1 + rel)
+    //   cursor at boxTop + caret (live caret): go down (dockBoxRows - 1 - caret)
+    const down = caret > 0 ? dockBoxRows - 1 - caret : dockBoxRows - 1 + rel;
+    process.stdout.write(`\x1b[${down}B`);
     for (let i = 0; i < dockBoxRows; i++) {
         process.stdout.write("\r\x1b[K");
         if (i < dockBoxRows - 1)
@@ -657,6 +686,7 @@ function dockEraseBox() {
     }
     docked = false;
     dockRel = 0;
+    dockCaretBelow = 0;
     dockGap = true;
     dockTransient = false;
 }
@@ -674,6 +704,7 @@ function dockEraseBoxKeep() {
     process.stdout.write(`\x1b[${dockRel}A`);
     docked = false;
     dockRel = 0;
+    dockCaretBelow = 0;
     dockGap = true;
     dockTransient = false;
 }
@@ -685,10 +716,31 @@ function dockRenderBox() {
     process.stdout.write("\n\n" + dockFrameLines.join("\n"));
     process.stdout.write(`\x1b[${dockBoxRows - 1}A\r`);
     dockRel = 0;
+    dockCaretBelow = 0;
     docked = true;
     dockGap = false;
     dockTransient = false;
 }
+/**
+ * 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 (and any transient row above it),
+ * writes the new frame, and parks the cursor at the caret. Preserves exactly
+ * one blank row between the last content and the box.
+ */
+export function dockRenderPrompt(buffer, pasteSpans, prefix, label, hints) {
+    if (!docked || dockBoxRows < 1)
+        return;
+    const { frame, cursorRow, cursorCol, totalRows } = renderBufferWithCursor(buffer, pasteSpans, prefix, label, buffer.length, hints);
+    dockEraseBox();
+    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;
+}
 /** Commit content at the box top, pushing the box down, preserving exactly one
  *  blank row between the content and the box. */
 export function dockAppendContent(text) {

package/package.json

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