@oxecli/oxe 1.0.5 → 1.0.7

package/dist/config.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { Spinner } from "./ui.js";
 // ---------------------------------------------------------------------------
 // Paths
 // ---------------------------------------------------------------------------
@@ -162,15 +163,19 @@ export async function loadOrPrompt() {
             }
         }
         process.stdout.write("\n");
-        process.stdout.write(markupToAnsi("[dim]Authenticating key with Oxe Cloud…[/dim]") + "\n");
+        const authSpinner = new Spinner();
+        authSpinner.start("Authenticating key with Oxe Cloud…");
         const validation = await validateOxeApiKey(api_key);
+        authSpinner.stop();
         if (validation.valid) {
             key_data = validation.key_data || {};
+            process.stdout.write("\n");
             process.stdout.write(markupToAnsi(`[green]✓ Oxe API Key verified[/green] [dim](${String(key_data["name"] ?? "Desktop")})[/dim]`) + "\n");
             process.env.OXE_API_KEY = api_key;
             break;
         }
         else {
+            process.stdout.write("\n");
             process.stdout.write(`\x1b[31mAuthentication Error:\x1b[0m ${validation.error}\n`);
             process.stdout.write("\n");
             api_key = "";

package/dist/engine.js

@@ -2,7 +2,7 @@ import OpenAI from "openai";
 import { max_output_tokens, max_empty_retries, max_agent_steps, max_context_tokens, context_overhead_margin, compact_keep_recent_turns, max_summary_source_chars, max_read_file_stored_chars, } from "./config.js";
 import { SYSTEM_PROMPT } from "./system.js";
 import { buildTools, truncateToolOutput, TOOL_IMPLEMENTATIONS } from "./tools.js";
-import { mutedMarkdown, aiMarkdown, tickDuration, safeCommitPoint, printAiChunk, formatToolAction, } from "./ui.js";
+import { mutedMarkdown, aiMarkdown, tickDuration, displayRows, safeCommitPoint, printAiChunk, formatToolAction, renderPanel, Spinner, hideCursor, showCursor, } from "./ui.js";
 import { reportUsage } from "./api.js";
 import { stripOrphanCalls, persistCompactionSummary, toolOutputFailed, } from "./sessions.js";
 // ---------------------------------------------------------------------------
@@ -35,30 +35,6 @@ const objectId = (() => {
     };
 })();
 // ---------------------------------------------------------------------------
-// Simple status line helper
-// ---------------------------------------------------------------------------
-class Status {
-    text;
-    timer = null;
-    started;
-    constructor(initial) {
-        this.text = initial;
-        this.started = Date.now();
-    }
-    start() {
-        process.stdout.write("\r\x1b[2K" + mutedMarkdown(this.text) + "\n");
-    }
-    update(text) {
-        this.text = text;
-        process.stdout.write("\r\x1b[2K" + mutedMarkdown(text) + "\x1b[1A");
-    }
-    stop() {
-        if (this.timer)
-            clearInterval(this.timer);
-        this.timer = null;
-    }
-}
-// ---------------------------------------------------------------------------
 // InferenceEngine
 // ---------------------------------------------------------------------------
 export class InferenceEngine {
@@ -66,6 +42,10 @@ export class InferenceEngine {
     reasoningEffort;
     keyData;
     client;
+    // "Worked for Xs" line is overwritten in place across tool iterations
+    // (mirrors Python's _work_active / _overwrite_work_line).
+    workActive = false;
+    workRows = 2;
     inQuery = false;
     temperature;
     storedResponseIds = [];
@@ -76,7 +56,8 @@ export class InferenceEngine {
         this.client = new OpenAI({
             apiKey: config["api_key"],
             baseURL: config["base_url"],
-            timeout: config["timeout"] ?? 120,
+            // OpenAI SDK `timeout` is in MILLISECONDS; config stores seconds.
+            timeout: (config["timeout"] ?? 120) * 1000,
             maxRetries: config["max_retries"] ?? 2,
         });
         this.temperature = config["temperature"] ?? null;
@@ -136,28 +117,70 @@ export class InferenceEngine {
     incompleteReason(response) {
         return response?.incomplete_details?.reason ?? null;
     }
+    /** Replace the previously-printed "Worked for Xs" line in place. */
+    overwriteWorkLine(text) {
+        for (let i = 0; i < this.workRows; i++) {
+            process.stdout.write("\x1b[1A\x1b[2K");
+        }
+        process.stdout.write(mutedMarkdown(text) + "\n\n");
+        this.workRows = displayRows(text) + 1;
+    }
     async streamOnce(inputItems, stats, story, previousResponseId) {
         let content = "";
         let committedLen = 0;
         let pending = "";
         let sawReasoning = false;
         let status = null;
-        const thinkingStart = Date.now();
-        const workStatus = new Status("Working for `0s`");
-        workStatus.start();
+        let thinkingStart = null;
+        const workStatus = new Spinner();
+        const workingStarted = Date.now();
+        workStatus.start("Working for `0s`");
+        const workTimer = setInterval(() => {
+            workStatus.update(`Working for ${tickDuration((Date.now() - workingStarted) / 1000)}`);
+        }, 500);
+        let workingReported = false;
         let response = null;
         let etype = null;
+        const silenceWorking = () => {
+            clearInterval(workTimer);
+            workStatus.stop();
+            // Reasoning took over; suppress any later "Worked for Xs" report for this
+            // stream (mirrors Python's working_started = None in silence_working()).
+            workingReported = true;
+        };
+        const reportWorking = () => {
+            clearInterval(workTimer);
+            workStatus.stop();
+            if (workingReported)
+                return;
+            workingReported = true;
+            const elapsed = (Date.now() - workingStarted) / 1000;
+            const t = tickDuration(elapsed);
+            story.push({ type: "worked", text: `Worked for ${t}` });
+            if (this.workActive) {
+                this.overwriteWorkLine(`Worked for ${t}`);
+            }
+            else {
+                process.stdout.write(mutedMarkdown(`Worked for ${t}`) + "\n\n");
+                this.workActive = true;
+                this.workRows = displayRows(`Worked for ${t}`) + 1;
+            }
+        };
         const finishThinking = (report) => {
+            if (thinkingStart === null)
+                return;
+            const elapsed = (Date.now() - thinkingStart) / 1000;
             if (status) {
                 status.stop();
                 status = null;
             }
             if (report) {
-                const elapsed = (Date.now() - thinkingStart) / 1000;
                 const t = tickDuration(elapsed);
                 story.push({ type: "thought", text: `Thought for ${t}` });
-                process.stdout.write("\n" + mutedMarkdown(`Thought for ${t}`) + "\n");
+                process.stdout.write(mutedMarkdown(`Thought for ${t}`) + "\n\n");
+                this.workActive = false;
             }
+            thinkingStart = null;
         };
         try {
             const kwargs = {
@@ -189,13 +212,14 @@ export class InferenceEngine {
                 if (etype === "response.reasoning_text.delta" ||
                     etype === "response.reasoning.summary.delta") {
                     sawReasoning = true;
-                    if (!status) {
-                        status = new Status("Thinking for `0s`");
-                        status.start();
+                    silenceWorking();
+                    if (thinkingStart === null) {
+                        thinkingStart = Date.now();
+                        status = new Spinner();
+                        status.start("Thinking for `0s`");
                     }
                     else {
-                        const elapsed = (Date.now() - thinkingStart) / 1000;
-                        status.update(`Thinking for ${tickDuration(elapsed)}`);
+                        status?.update(`Thinking for ${tickDuration((Date.now() - thinkingStart) / 1000)}`);
                     }
                 }
                 else if (etype === "response.reasoning_text.done" ||
@@ -203,6 +227,7 @@ export class InferenceEngine {
                     finishThinking(true);
                 }
                 else if (etype === "response.output_text.delta") {
+                    reportWorking();
                     finishThinking(true);
                     content += event.delta;
                     pending += event.delta;
@@ -223,8 +248,13 @@ export class InferenceEngine {
             }
         }
         finally {
+            clearInterval(workTimer);
             workStatus.stop();
-            finishThinking(true);
+            // If the stream ended while still reasoning (no *.done event), still report
+            // the elapsed "Thought for Xs" (mirrors Python's `still_thinking` handling).
+            const stillThinking = thinkingStart !== null;
+            finishThinking(stillThinking);
+            reportWorking();
             if (content.slice(committedLen))
                 printAiChunk(content.slice(committedLen));
         }
@@ -331,13 +361,17 @@ export class InferenceEngine {
         if (!this.contextOverBudget(conversation))
             return [conversation, false];
         const started = Date.now();
-        const comp = new Status("Compacting conversation for `0s`");
-        comp.start();
+        const comp = new Spinner();
+        comp.start("Compacting conversation for `0s`");
+        const compTimer = setInterval(() => {
+            comp.update(`Compacting conversation for ${tickDuration((Date.now() - started) / 1000)}`);
+        }, 500);
         let compacted;
         try {
             compacted = await this.compactHistory(conversation);
         }
         finally {
+            clearInterval(compTimer);
             comp.stop();
         }
         if (!compacted)
@@ -345,11 +379,14 @@ export class InferenceEngine {
         persistCompactionSummary(inputItems, compacted[0]);
         const text = `Compacted conversation in ${tickDuration((Date.now() - started) / 1000)}`;
         story.push({ type: "compacted", text });
-        process.stdout.write("\n" + mutedMarkdown(text) + "\n");
+        this.workActive = false;
+        process.stdout.write(mutedMarkdown(text) + "\n");
+        process.stdout.write("\n");
         return [compacted, true];
     }
     async executeQuery(userPrompt, inputItems, story, pasteSpans) {
         this.inQuery = true;
+        hideCursor();
         inputItems.push({
             role: "user",
             content: userPrompt,
@@ -383,7 +420,6 @@ export class InferenceEngine {
         };
         let prevId = null;
         let pending = conversation;
-        let resetInQuery = true;
         try {
             for (let step = 0; step < max_agent_steps; step++) {
                 let text = "";
@@ -417,13 +453,11 @@ export class InferenceEngine {
                             respId = res.responseId;
                         }
                         catch (err2) {
-                            process.stdout.write("\n");
                             renderErrorPanel(`API Error: ${err2}`);
                             return;
                         }
                     }
                     else {
-                        process.stdout.write("\n");
                         renderErrorPanel(`API Error: ${err}`);
                         return;
                     }
@@ -457,7 +491,7 @@ export class InferenceEngine {
                         continue;
                     }
                     dropRetryPrompts(conversation, inputItems, retryPrompts);
-                    process.stdout.write("\n" + aiMarkdown(emptyMessage) + "\n");
+                    process.stdout.write(aiMarkdown(emptyMessage) + "\n");
                     process.stdout.write("\n" + summary() + "\n");
                     return;
                 }
@@ -471,6 +505,7 @@ export class InferenceEngine {
                 if (text.trim())
                     process.stdout.write("\n");
                 for (const c of calls) {
+                    this.workActive = false;
                     const started = formatToolAction(c.name, c.arguments, "started");
                     process.stdout.write(`\x1b[2m${started}\x1b[0m\n`);
                     if (c.name === "edit_file" || c.name === "write_file")
@@ -495,9 +530,11 @@ export class InferenceEngine {
                         pending.push(outputItem);
                 }
             }
-            process.stdout.write("\n\x1b[1;33m⚠ Max tool-call iterations reached for this turn.\x1b[0m\n" +
-                "\x1b[33mThe work so far is saved. If you want the agent to keep going, type " +
-                "[bold]continue[/bold] and the next step will resume from where it left off.\x1b[0m\n");
+            process.stdout.write("\n");
+            renderPanel("[bold yellow]⚠ Max tool-call iterations reached for this turn.[/bold yellow]\n" +
+                "[yellow]The work so far is saved. If you want the agent to keep going, type " +
+                "[bold]continue[/bold] and the next step will resume from where it left off.[/yellow]", "Warning", "", false, "33");
+            process.stdout.write("\n");
             if (retryPrompts.length)
                 dropRetryPrompts(conversation, inputItems, retryPrompts);
             stripOrphanCalls(conversation);
@@ -507,11 +544,11 @@ export class InferenceEngine {
             if (err?.message === "interrupt" || err?.message === "eof") {
                 throw err;
             }
-            process.stdout.write("\n");
             renderErrorPanel(`Runtime Exception: ${err}`);
         }
         finally {
             this.inQuery = false;
+            showCursor();
             if (stats["tokens"] > 0 && this.keyData) {
                 const userId = this.keyData["user_id"];
                 if (userId) {
@@ -530,6 +567,7 @@ export class InferenceEngine {
 }
 function renderErrorPanel(msg) {
     const text = msg.replace(/\[bold yellow\]|\[yellow\]|\[\/.*?\]/g, "");
-    process.stdout.write(`\x1b[31m${text}\x1b[0m\n`);
+    renderPanel(text, "Error", "", true, "31");
+    process.stdout.write("\n");
 }
 export { renderErrorPanel };

package/dist/ui.js

@@ -210,8 +210,14 @@ export function tickDuration(seconds) {
 // ---------------------------------------------------------------------------
 const FENCE_MARKER_RE = /`{3,}/g;
 export function printAiChunk(chunk) {
-    process.stdout.write(markdownToAnsi(chunk) + "\n");
-    if (/^```/m.test(chunk))
+    // rich's Markdown renderer ignores leading blank lines; a commit boundary in
+    // "…\n\n…" text can leave the second chunk starting with "\n", so strip it to
+    // avoid double-printing a blank row (mirrors the original's output).
+    const trimmed = chunk.replace(/^\n+/, "");
+    if (!trimmed)
+        return;
+    process.stdout.write(markdownToAnsi(trimmed) + "\n");
+    if (/^```/m.test(trimmed))
         process.stdout.write("\n");
 }
 export function safeCommitPoint(text) {
@@ -233,7 +239,7 @@ export function truncateEllipsis(text, maxChars, label = "text") {
 export function displayRows(text) {
     if (!text)
         return 1;
-    const plain = text.replace(/`/g, "");
+    const plain = text.replace(/\x1b\[[0-9;]*m/g, "").replace(/`/g, "");
     const width = Math.max(terminalWidth() || 80, 1);
     let rows = 0;
     const lines = plain.split("\n");
@@ -245,6 +251,92 @@ export function displayRows(text) {
     return rows;
 }
 // ---------------------------------------------------------------------------
+// Cursor + spinner helpers (mirror rich's console.status spinner="dots")
+// ---------------------------------------------------------------------------
+let cursorHidden = false;
+export function hideCursor() {
+    if (!cursorHidden) {
+        process.stdout.write("\x1b[?25l");
+        cursorHidden = true;
+    }
+}
+export function showCursor() {
+    if (cursorHidden) {
+        process.stdout.write("\x1b[?25h");
+        cursorHidden = false;
+    }
+}
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+/**
+ * A transient status line with an animated dot spinner, updated in place
+ * (no new lines appended on every tick). On stop() the line is erased.
+ * Mirrors rich's console.status(..., spinner="dots").
+ */
+export class Spinner {
+    timer = null;
+    frame = 0;
+    rows = 0;
+    text = "";
+    enabled;
+    constructor(enabled = true) {
+        this.enabled = enabled;
+    }
+    start(text) {
+        if (!this.enabled)
+            return;
+        if (this.timer) {
+            this.update(text);
+            return;
+        }
+        this.text = text;
+        this.frame = 0;
+        this.rows = 0;
+        this.timer = setInterval(() => {
+            this.frame++;
+            this.draw();
+        }, 120);
+        this.draw();
+    }
+    update(text) {
+        this.text = text;
+        if (this.timer)
+            this.draw();
+    }
+    draw() {
+        const rendered = mutedMarkdown(`${SPINNER_FRAMES[this.frame % SPINNER_FRAMES.length]} ${this.text}`);
+        const newRows = Math.max(1, displayRows(rendered));
+        const clearRows = Math.max(this.rows, newRows, 1);
+        if (this.rows > 0)
+            process.stdout.write(`\x1b[${this.rows}A`);
+        for (let i = 0; i < clearRows; i++) {
+            process.stdout.write("\r\x1b[2K");
+            if (i < clearRows - 1)
+                process.stdout.write("\n");
+        }
+        if (clearRows > 0)
+            process.stdout.write(`\x1b[${clearRows - 1}A\r`);
+        process.stdout.write(rendered);
+        this.rows = newRows;
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        if (this.enabled && this.rows > 0) {
+            process.stdout.write(`\x1b[${this.rows}A`);
+            for (let i = 0; i < this.rows; i++) {
+                process.stdout.write("\r\x1b[2K");
+                if (i < this.rows - 1)
+                    process.stdout.write("\n");
+            }
+            if (this.rows > 0)
+                process.stdout.write(`\x1b[${this.rows - 1}A`);
+        }
+        this.rows = 0;
+    }
+}
+// ---------------------------------------------------------------------------
 // Tool action formatter
 // ---------------------------------------------------------------------------
 export function formatToolAction(name, argumentsJson, status = "ok") {
@@ -357,23 +449,84 @@ 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 line(s) — the whole prefix+text (or placeholder)
-    // lives on a single row when the buffer is empty, matching the original.
-    let content;
+    // 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;
     if (!buffer) {
-        content = `\x1b[1m${prefix}\x1b[0m \x1b[1m▏\x1b[0m\x1b[2m${PROMPT_PLACEHOLDER}\x1b[0m`;
+        display = `\x1b[1m▏\x1b[0m\x1b[2m${PROMPT_PLACEHOLDER}\x1b[0m`;
     }
     else {
         const segs = splitBlocks(buffer, pasteSpans);
-        let display = "";
+        // Recompute each segment's buffer range [a, b) so we can locate the cursor.
+        const ranges = [];
+        {
+            let pos = 0;
+            const pts = new Set([0, buffer.length]);
+            for (const [s, e] of pasteSpans) {
+                pts.add(s);
+                pts.add(e);
+            }
+            const sorted = [...pts].sort((a, b) => a - b);
+            const isPaste = (a, b) => pasteSpans.some(([s, e]) => s <= a && b <= e);
+            const used = new Set();
+            for (const seg of segs) {
+                for (let i = 0; i < sorted.length - 1; i++) {
+                    const a = sorted[i];
+                    const b = sorted[i + 1];
+                    if (a === b || used.has(a))
+                        continue;
+                    used.add(a);
+                    ranges.push([a, b]);
+                    break;
+                }
+            }
+        }
+        // Determine the target segment + inside offset (mirrors Python).
+        let target = -1;
+        let inside = 0;
+        if (cursor >= buffer.length) {
+            target = segs.length - 1;
+            inside = ranges.length ? ranges[ranges.length - 1][1] - ranges[ranges.length - 1][0] : 0;
+        }
+        else {
+            for (let i = 0; i < ranges.length; i++) {
+                const [a, b] = ranges[i];
+                if (a <= cursor && cursor <= b) {
+                    target = i;
+                    inside = cursor - a;
+                    break;
+                }
+            }
+            if (target === -1) {
+                target = segs.length - 1;
+                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 += " ";
-            display += kind === "collapsed" ? `\x1b[1m\x1b[36m${disp}\x1b[0m` : disp;
+            if (i === target) {
+                if (kind === "collapsed") {
+                    display += `\x1b[1m\x1b[36m${disp}\x1b[0m`;
+                    if (!endsWithWs(disp))
+                        display += " ";
+                    display += `\x1b[1m▏\x1b[0m`;
+                }
+                else {
+                    const bold = i === target;
+                    display += disp.slice(0, inside);
+                    display += `\x1b[1m▏\x1b[0m`;
+                    display += disp.slice(inside);
+                }
+            }
+            else {
+                display += kind === "collapsed" ? `\x1b[1m\x1b[36m${disp}\x1b[0m` : disp;
+            }
         }
-        content = `\x1b[1m${prefix}\x1b[0m ${display}`;
     }
+    const content = `\x1b[1m${prefix}\x1b[0m ${display}`;
     const lines = content.split("\n");
     // Top border with the label embedded on the left.
     const topPad = Math.max(borderW - label.length - 2, 0);
@@ -387,10 +540,12 @@ export function renderBufferWithCursor(buffer, pasteSpans, prefix, label, cursor
     }
     const bottom = `\x1b[90m╰${"─".repeat(borderW)}╯\x1b[0m`;
     const frame = [top, ...body, bottom].join("\n");
-    // Cursor placement: one row below the top border. Column includes the
-    // "│ " left border (2) plus "prefix " (prefix.length + 1).
+    // 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 + 3;
+    const cursorCol = col + prefix.length + 4;
     const totalRows = body.length + 2;
     return { frame, cursorRow, cursorCol, totalRows };
 }
@@ -418,6 +573,7 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = []) {
         if (process.stdin.isTTY)
             process.stdin.setRawMode(true);
         process.stdin.resume();
+        hideCursor();
         let done = false;
         let lastCursorRow = 0;
         let lastTotalRows = 0;
@@ -426,19 +582,22 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = []) {
                 return;
             done = true;
             process.stdin.setRawMode(false);
-            // Erase the whole prompt box (which occupies `lastTotalRows` lines) so no
-            // frame borders are left behind, then leave the cursor on the box's top
-            // row (a blank line). That way the caller's single leading newline yields
-            // exactly ONE blank row before the echoed user prompt — never two.
+            showCursor();
+            // Erase the prompt region: a leading blank line + the box. Cursor sits at
+            // lastCursorRow inside the box; move up to the box's top border, erase the
+            // box rows, then erase the leading blank line, leaving the cursor on that
+            // blank row. The caller's single leading newline then yields exactly ONE
+            // blank row before the echoed user prompt.
             process.stdout.write(`\x1b[${lastCursorRow}A`);
             for (let i = 0; i < lastTotalRows; i++) {
                 process.stdout.write("\r\x1b[K");
                 if (i < lastTotalRows - 1)
                     process.stdout.write("\n");
             }
-            // Cursor is now on the last box row; move back up to the box's top row.
             if (lastTotalRows > 1)
                 process.stdout.write(`\x1b[${lastTotalRows - 1}A`);
+            // Clear the leading blank line above the box.
+            process.stdout.write("\x1b[1A\r\x1b[K");
             resolve(resolveVal);
         };
         const repaint = (isFirst = false) => {
@@ -446,7 +605,11 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = []) {
             lastCursorRow = cursorRow;
             lastTotalRows = totalRows;
             const frameLines = frame.split("\n");
-            if (!isFirst) {
+            if (isFirst) {
+                // A blank line above the box (mirrors the original's leading Text("")).
+                process.stdout.write("\n");
+            }
+            else {
                 // Cursor currently sits at cursorRow (inside the box). Move to the top
                 // border, then clear+rewrite each line so old content is fully removed.
                 process.stdout.write(`\x1b[${cursorRow}A`);

package/package.json

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