@oxecli/oxe 1.0.105 → 1.0.107

package/README.md

@@ -36,5 +36,9 @@ Install Oxe globally with npm:
 
 
 
+**Info**
+
+
+
 Oxe can inspect your project, make the required changes, run commands, and show you what it is doing along the way.
 

package/dist/cli.js

@@ -60,7 +60,7 @@ export class CLI {
             // The result body was formatted against the terminal width at tool time,
             // but the window may be narrower on resume — re-truncate defensively so
             // long persisted lines never run off the screen.
-            const lineMax = Math.max(terminalWidth() - 4, 20);
+            const lineMax = Math.max(terminalWidth() - 4, 1);
             const allLines = body.split("\n");
             const lines = allLines
                 .slice(0, TOOL_RESULT_MAX_LINES)
@@ -81,7 +81,7 @@ export class CLI {
         const truncated = truncateEllipsis(body, Math.min(max_action_chars, MAX_COMMAND_DISPLAY_CHARS), "text");
         // truncateEllipsis appends a "…(text truncated: N chars total)" suffix, so
         // re-truncate to the current width to keep the legacy action on one row.
-        const displayMax = Math.max(terminalWidth() - 6, 20);
+        const displayMax = Math.max(terminalWidth() - 6, 1);
         process.stdout.write(`${icon} ${style}${truncateStyled(truncated, displayMax)}\x1b[0m\n`);
     }
     printAssistantBlock(text) {

package/dist/engine.js

@@ -82,7 +82,7 @@ export class InferenceEngine {
             }
         }
     }
-    async runTool(name, argumentsJson) {
+    async runTool(name, argumentsJson, signal) {
         let args = {};
         try {
             args = argumentsJson ? JSON.parse(argumentsJson) : {};
@@ -103,7 +103,7 @@ export class InferenceEngine {
                     result = toolEditFile(args.path, args.old_string, args.new_string, args.replace_all);
                     break;
                 case "bash":
-                    result = await toolBash(args.command, args.timeout, args.cwd);
+                    result = await toolBash(args.command, args.timeout, args.cwd, signal);
                     break;
                 case "glob":
                     result = toolGlob(args.pattern, args.path, args.limit, args.depth);
@@ -591,7 +591,7 @@ export class InferenceEngine {
                     dockTransientStart("flush");
                     const toolSpinner = new Spinner();
                     toolSpinner.startDots("\x1b[90m╰─\x1b[0m Working");
-                    const rawResult = await this.runTool(c.name, c.arguments);
+                    const rawResult = await this.runTool(c.name, c.arguments, this.activeAbort?.signal);
                     // A tool call was made, which interrupts any current working phase,
                     // so the next agent iteration may commit a fresh "Worked for …" block.
                     this.workedCommitted = false;

package/dist/tools.js

@@ -586,7 +586,7 @@ function terminateProcessTree(proc) {
         }
     }
 }
-export function toolBash(command, timeout = 60, cwd) {
+export function toolBash(command, timeout = 60, cwd, signal) {
     try {
         let t = typeof timeout === "number" ? timeout : parseInt(String(timeout), 10);
         if (Number.isNaN(t))
@@ -597,6 +597,10 @@ export function toolBash(command, timeout = 60, cwd) {
             return Promise.resolve(`Error: working directory not found: ${cwd}`);
         }
         return new Promise((resolve) => {
+            if (signal && signal.aborted) {
+                resolve("Error: command aborted");
+                return;
+            }
             let child;
             try {
                 if (process.platform === "win32") {
@@ -621,6 +625,18 @@ export function toolBash(command, timeout = 60, cwd) {
             let stdout = "";
             let stderr = "";
             let finished = false;
+            const onAbort = () => {
+                if (finished)
+                    return;
+                terminateProcessTree({
+                    pid: child.pid,
+                    kill: (sig) => child.kill(sig),
+                });
+                finished = true;
+                clearTimeout(timer);
+                resolve("Error: command aborted");
+            };
+            signal?.addEventListener("abort", onAbort, { once: true });
             const timer = setTimeout(() => {
                 if (finished)
                     return;
@@ -633,6 +649,8 @@ export function toolBash(command, timeout = 60, cwd) {
                 if (output)
                     msg += `\n${output}`;
                 finished = true;
+                clearTimeout(timer);
+                signal?.removeEventListener("abort", onAbort);
                 resolve(msg);
             }, t * 1000);
             child.stdout?.on("data", (d) => (stdout += d.toString("utf-8")));
@@ -642,6 +660,7 @@ export function toolBash(command, timeout = 60, cwd) {
                     return;
                 finished = true;
                 clearTimeout(timer);
+                signal?.removeEventListener("abort", onAbort);
                 resolve(`Error: ${err}`);
             });
             child.on("close", (code) => {
@@ -649,6 +668,7 @@ export function toolBash(command, timeout = 60, cwd) {
                     return;
                 finished = true;
                 clearTimeout(timer);
+                signal?.removeEventListener("abort", onAbort);
                 const output = (stdout + stderr).trim() || "(no output)";
                 resolve(`exit code: ${code}\n${output}`);
             });

package/dist/ui.js

@@ -76,8 +76,11 @@ export function startDraftCapture(onInterrupt, renderBox) {
             return;
         }
         if (str && !key?.ctrl && !key?.meta) {
-            draft += str.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-            renderBox?.(draft, pasteSpans);
+            const added = str.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+            if (draft.length + added.length <= MAX_PROMPT_CHARS) {
+                draft += added;
+                renderBox?.(draft, pasteSpans);
+            }
         }
     };
     readline.emitKeypressEvents(process.stdin);
@@ -113,6 +116,21 @@ export function clearScreen() {
 export function terminalWidth() {
     return process.stdout.columns || 80;
 }
+/** Minimum width for boxes/cards so they don't collapse to nothing. */
+const MIN_BOX_WIDTH = 20;
+/** Horizontal margin reserved on each side of a box/card from the terminal edge. */
+const BOX_MARGIN = 4;
+/**
+ * Clamp a preferred box width so it fits inside the terminal (borders never wrap
+ * or duplicate on narrow/scaled terminals, e.g. a larger command-prompt scale)
+ * while keeping a preferred minimum. Fitting wins over the minimum when the
+ * terminal is narrower than min+margin, so cards size down smoothly instead of
+ * overflowing.
+ */
+function fitBoxWidth(pref, termW) {
+    const maxW = Math.max(termW - BOX_MARGIN, 1);
+    return Math.min(Math.max(Math.min(pref, maxW), MIN_BOX_WIDTH), maxW);
+}
 // ---------------------------------------------------------------------------
 // ANSI and plain text length helpers
 // ---------------------------------------------------------------------------
@@ -290,7 +308,7 @@ function formatMarkdownTable(tableLines) {
 // Rich Markdown -> ANSI Terminal Renderer
 // ---------------------------------------------------------------------------
 export function markdownToAnsi(text) {
-    const width = Math.max(terminalWidth() - 2, 40);
+    const width = Math.max(terminalWidth() - 2, 1);
     const rawLines = text.split("\n");
     const out = [];
     let inCode = false;
@@ -445,8 +463,8 @@ function panelString(content, title = "", subtitle = "", expand = true, borderSt
         maxLineW = Math.max(maxLineW, plainLen(subtitle) + 4);
     const termW = terminalWidth();
     const boxW = expand
-        ? Math.max(termW - 4, 20)
-        : Math.min(Math.max(maxLineW + 4, 20), termW - 4);
+        ? fitBoxWidth(termW - 4, termW)
+        : fitBoxWidth(maxLineW + 4, termW);
     const innerW = Math.max(boxW - 4, 1);
     const embed = (text, align) => {
         if (!text)
@@ -1072,7 +1090,7 @@ export function toolCallLabel(name, argumentsJson) {
     arg = arg.trim().replace(/\s*\r?\n\s*/g, " ");
     if (!arg)
         return `\x1b[1;36m${display}\x1b[0m`;
-    const cap = Math.max(Math.min(terminalWidth() - plainLen(display) - 4, MAX_COMMAND_DISPLAY_CHARS), 20);
+    const cap = Math.max(Math.min(terminalWidth() - plainLen(display) - 4, MAX_COMMAND_DISPLAY_CHARS), Math.min(terminalWidth() - plainLen(display) - 2, 8));
     if (plainLen(arg) > cap)
         arg = truncateStyled(arg, cap) + "…";
     return `\x1b[1;36m${display}\x1b[0m(${arg})`;
@@ -1097,7 +1115,7 @@ export function formatToolResult(rawResult, failed) {
     // Truncate to the terminal width (rows OR per-line length, whichever trips
     // first) so long tool output — e.g. Glob paths — never runs off the screen.
     const termW = terminalWidth();
-    const lineMax = Math.max(termW - 4, 20);
+    const lineMax = Math.max(termW - 4, 1);
     const allLines = clean.split("\n");
     const lines = allLines
         .slice(0, TOOL_RESULT_MAX_LINES)
@@ -1116,10 +1134,32 @@ export function formatToolResult(rawResult, failed) {
 export const PROMPT_PLACEHOLDER = "Describe a coding task, or type /help for commands";
 const MAX_PROMPT_DISPLAY_LINES = 12;
 const MAX_PROMPT_PASTE_CHARS = 400;
+const MAX_PROMPT_CHARS = 500;
 function shouldCollapsePaste(text) {
     return (text.split("\n").length > MAX_PROMPT_DISPLAY_LINES ||
         text.length > MAX_PROMPT_PASTE_CHARS);
 }
+/**
+ * Effective character count of a prompt for its length limit. Each non-collapsed
+ * char counts as one; a collapsed pasted block counts as a single char.
+ */
+export function promptCharCount(buffer, pasteSpans) {
+    if (!buffer)
+        return 0;
+    const spans = [...pasteSpans].sort((a, b) => a[0] - b[0]);
+    let count = 0;
+    let last = 0;
+    for (const [s, e] of spans) {
+        if (s > last)
+            count += s - last;
+        const seg = buffer.slice(s, e);
+        count += shouldCollapsePaste(seg) ? 1 : e - s;
+        last = e;
+    }
+    if (last < buffer.length)
+        count += buffer.length - last;
+    return count;
+}
 export function cursorLineCol(buffer, cursor) {
     const before = buffer.slice(0, cursor);
     const lines = before.split("\n");
@@ -1238,7 +1278,7 @@ function wrapRuns(runs, width) {
 }
 export function renderBufferWithCursor(buffer, pasteSpans, prefix, label, cursor, hints) {
     const termW = terminalWidth();
-    const boxW = Math.max(termW - 4, 16);
+    const boxW = fitBoxWidth(termW - 4, termW);
     const innerW = boxW - 4;
     const runs = [];
     runs.push({ text: prefix, style: "\x1b[90m" });
@@ -1536,14 +1576,32 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = [], hin
                 draft = { buffer, cursor, spans: pasteSpans.slice() };
                 histIdx = hist.length;
             }
-            const pasteStart = cursor;
-            buffer = buffer.slice(0, cursor) + text + buffer.slice(cursor);
-            pasteSpans = shiftSpansAfterInsert(cursor, text.length);
+            // Non-collapsing pastes get a leading space when inserted after non-empty,
+            // non-whitespace text (never when a space is already present). The space is
+            // inserted as plain text (outside the paste span) so display spacing isn't
+            // doubled.
+            let prefix = "";
+            if (isPaste &&
+                !shouldCollapsePaste(text) &&
+                cursor > 0 &&
+                !endsWithWs(buffer.slice(0, cursor))) {
+                prefix = " ";
+            }
+            const pasteStart = cursor + prefix.length;
+            const insertLen = prefix.length + text.length;
+            const newBuffer = buffer.slice(0, cursor) + prefix + text + buffer.slice(cursor);
+            const newSpans = shiftSpansAfterInsert(cursor, insertLen);
             if (isPaste) {
-                pasteSpans.push([pasteStart, pasteStart + text.length]);
-                pasteSpans.sort((a, b) => a[0] - b[0]);
+                newSpans.push([pasteStart, pasteStart + text.length]);
+                newSpans.sort((a, b) => a[0] - b[0]);
+            }
+            // Enforce the 500-char effective limit; a collapsed block counts as one.
+            if (promptCharCount(newBuffer, newSpans) > MAX_PROMPT_CHARS) {
+                return;
             }
-            cursor += text.length;
+            buffer = newBuffer;
+            pasteSpans = newSpans;
+            cursor += insertLen;
         };
         const spanCollapsed = (span) => {
             return shouldCollapsePaste(buffer.slice(span[0], span[1]));

package/package.json

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