@oxecli/oxe 1.0.6 → 1.0.8

package/dist/cli.js

@@ -15,6 +15,7 @@ export class CLI {
     story = [];
     sessionId = null;
     promptHistory = [];
+    interruptPending = false;
     constructor() {
         clearScreen();
         renderPanel("AI CODING AGENT", "", "Engine: Ready", false);
@@ -107,7 +108,8 @@ export class CLI {
                 if (footer) {
                     if (!footer.startsWith("("))
                         footer = `(${footer})`;
-                    process.stdout.write("\n" + mutedMarkdown(footer) + "\n");
+                    // Footer: labels white, only the backtick values grey (not the whole line).
+                    process.stdout.write("\n" + aiMarkdown(footer) + "\n");
                 }
             }
             else {
@@ -138,6 +140,10 @@ export class CLI {
             else if (typ === "tool") {
                 this.printToolEntry(e["started"], text, e["status"] ?? "");
             }
+            else if (typ === "footer") {
+                // Footer: labels white, only the backtick values grey (not the whole line).
+                process.stdout.write(aiMarkdown(text) + "\n");
+            }
             else {
                 process.stdout.write(mutedMarkdown(text) + "\n");
             }
@@ -210,6 +216,7 @@ export class CLI {
                 const [input, spans] = await askBottomPrompt("You", "❯", this.promptHistory);
                 if (!input.trim())
                     continue;
+                this.interruptPending = false;
                 this.promptHistory.push(input);
                 const lower = input.trim().toLowerCase();
                 if (lower === "/exit" || lower === "/quit") {
@@ -260,12 +267,35 @@ export class CLI {
                 this.saveSession(engine);
             }
             catch (err) {
-                if (err?.message === "interrupt" || err?.message === "eof") {
+                if (err?.message === "eof") {
                     this.saveSession(engine);
                     await engine.cleanupStoredResponses();
-                    process.stdout.write("\nClosing terminal session. Goodbye!\n");
+                    process.stdout.write("\nSession closing via exit interrupt hook.\n");
                     break;
                 }
+                if (err?.message === "interrupt") {
+                    const wasActive = engine.inQuery;
+                    engine.inQuery = false;
+                    // Drop the pending user message/story entry that was never run.
+                    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();
+                    }
+                    if (this.interruptPending) {
+                        this.saveSession(engine);
+                        await engine.cleanupStoredResponses();
+                        process.stdout.write("\nClosing terminal session. Goodbye!\n");
+                        break;
+                    }
+                    this.interruptPending = true;
+                    process.stdout.write("\n");
+                    process.stdout.write(wasActive
+                        ? "\x1b[2mInterrupted. Press Ctrl+C again to exit, or type a new prompt.\x1b[0m\n"
+                        : "\x1b[2mNo active response. Press Ctrl+C again to exit.\x1b[0m\n");
+                    continue;
+                }
                 throw err;
             }
         }

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,8 +163,10 @@ 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");

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 = [];
@@ -137,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 = {
@@ -190,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" ||
@@ -204,6 +227,7 @@ export class InferenceEngine {
                     finishThinking(true);
                 }
                 else if (etype === "response.output_text.delta") {
+                    reportWorking();
                     finishThinking(true);
                     content += event.delta;
                     pending += event.delta;
@@ -224,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));
         }
@@ -332,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)
@@ -346,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,
@@ -364,7 +400,7 @@ export class InferenceEngine {
         const stats = { thinking: 0, tokens: 0, reasoning: 0, input: 0 };
         const queryStart = Date.now();
         const footerText = () => `(Thought for ${tickDuration(stats["thinking"])} · Worked for ${tickDuration((Date.now() - queryStart) / 1000)} · Used \`${stats["tokens"].toLocaleString()}\` tokens)`;
-        const summary = () => mutedMarkdown(footerText());
+        const summary = () => aiMarkdown(footerText());
         const attachFooter = (items) => {
             const footer = footerText();
             for (let i = items.length - 1; i >= 0; i--) {
@@ -384,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 = "";
@@ -418,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;
                     }
@@ -458,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;
                 }
@@ -472,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")
@@ -496,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);
@@ -508,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) {
@@ -531,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,103 @@ 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);
+        // Cursor is always at the home position (col 0) after each draw. Clear
+        // `clearRows` lines downward from home, rewrite the content, then return
+        // the cursor to home (col 0) so the next frame overwrites in place.
+        for (let i = 0; i < clearRows; i++) {
+            process.stdout.write("\r\x1b[2K");
+            if (i < clearRows - 1)
+                process.stdout.write("\n");
+        }
+        // Cursor is now `clearRows-1` lines below home; move back to home.
+        if (clearRows > 1)
+            process.stdout.write(`\x1b[${clearRows - 1}A\r`);
+        else
+            process.stdout.write("\r");
+        process.stdout.write(rendered);
+        // Return cursor to home (col 0) for the next draw.
+        if (newRows > 1)
+            process.stdout.write(`\x1b[${newRows - 1}A\r`);
+        else
+            process.stdout.write("\r");
+        this.rows = newRows;
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        if (this.enabled && this.rows > 0) {
+            // Cursor is at home (col 0); clear the rendered rows downward.
+            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 > 1)
+                process.stdout.write(`\x1b[${this.rows - 1}A\r`);
+            else
+                process.stdout.write("\r");
+        }
+        this.rows = 0;
+    }
+}
+// ---------------------------------------------------------------------------
 // Tool action formatter
 // ---------------------------------------------------------------------------
 export function formatToolAction(name, argumentsJson, status = "ok") {
@@ -481,35 +584,51 @@ 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;
-        const finish = (resolveVal) => {
-            if (done)
-                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.
+        // 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 / message.
+        const clearBox = () => {
             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`);
-            resolve(resolveVal);
+            process.stdout.write("\x1b[1A\r\x1b[K");
+        };
+        const settle = (value, isErr) => {
+            if (done)
+                return;
+            done = true;
+            process.stdin.setRawMode(false);
+            showCursor();
+            clearBox();
+            if (isErr)
+                reject(value);
+            else
+                resolve(value);
         };
         const repaint = (isFirst = false) => {
             const { frame, cursorRow, cursorCol, totalRows } = renderBufferWithCursor(buffer, pasteSpans, prefix, label, cursor);
             lastCursorRow = cursorRow;
             lastTotalRows = totalRows;
             const frameLines = frame.split("\n");
-            if (!isFirst) {
+            if (isFirst) {
+                // Draw a leading blank line above the box (mirrors the original's
+                // Group(Text(""), panel)): move down one line, clear it as a blank, then
+                // move down again so the box starts below that blank.
+                process.stdout.write("\n");
+                process.stdout.write("\r\x1b[K\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`);
@@ -586,18 +705,16 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = []) {
         };
         const onKeypress = (str, key) => {
             if (key && key.ctrl && key.name === "c") {
-                finish(["", []]);
-                reject(new Error("interrupt"));
+                settle(new Error("interrupt"), true);
                 return;
             }
             if (key && key.ctrl && (key.name === "d" || key.name === "z")) {
-                finish([buffer, []]);
-                reject(new Error("eof"));
+                settle(new Error("eof"), true);
                 return;
             }
             if (key && key.name === "return") {
                 if (buffer.trim()) {
-                    finish([buffer, pasteSpans]);
+                    settle([buffer, pasteSpans], false);
                 }
                 return;
             }

package/package.json

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