@oxecli/oxe 1.0.74 → 1.0.76

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, } 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, formatToolAction, truncateEllipsis, renderPanel, renderTableString, enableRawStdin, disableRawStdin, waitRawKey, } from "./ui.js";
+import { clearScreen, enableAnsi, askBottomPrompt, userDisplayText, aiMarkdown, mutedMarkdown, messageText, toolCallLabel, formatToolResult, truncateEllipsis, stripAnsi, renderPanel, renderTableString, enableRawStdin, disableRawStdin, waitRawKey, } from "./ui.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
 const packageInfo = require("../package.json");
@@ -46,9 +46,15 @@ export class CLI {
         });
     }
     printToolEntry(started, text, status) {
+        const label = started && String(started).trim();
+        const body = String(text).trim();
+        if (label && stripAnsi(body).startsWith("⎿")) {
+            process.stdout.write(`${label}\n${body}\n`);
+            return;
+        }
         const icon = status === "failed" ? "\x1b[31m✗\x1b[0m" : "\x1b[32m✓\x1b[0m";
         const style = status === "failed" ? "\x1b[31m" : "\x1b[32m";
-        process.stdout.write(`${icon} ${style}${truncateEllipsis(String(text), max_action_chars, "text")}\x1b[0m\n`);
+        process.stdout.write(`${icon} ${style}${truncateEllipsis(body, max_action_chars, "text")}\x1b[0m\n`);
     }
     printAssistantBlock(text) {
         const rendered = aiMarkdown(text);
@@ -153,8 +159,8 @@ export class CLI {
                 const argumentsJson = it["arguments"] ?? "";
                 renders.push({
                     kind: "tool",
-                    started: formatToolAction(name, argumentsJson, "started"),
-                    text: formatToolAction(name, argumentsJson, failed ? "failed" : "ok"),
+                    started: toolCallLabel(name, argumentsJson),
+                    text: formatToolResult(rawResult, failed),
                     status: failed ? "failed" : "ok",
                 });
             }

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 { getSystemPrompt } from "./system.js";
 import { buildTools, truncateToolOutput, toolReadFile, toolWriteFile, toolEditFile, toolBash, toolGlob, toolGrep, toolLoadSkill, } from "./tools.js";
-import { mutedMarkdown, aiMarkdown, tickDuration, displayRows, safeCommitPoint, printAiChunk, formatToolAction, renderPanel, Spinner, hideCursor, } from "./ui.js";
+import { mutedMarkdown, aiMarkdown, tickDuration, displayRows, safeCommitPoint, printAiChunk, toolCallLabel, formatToolResult, renderPanel, Spinner, hideCursor, } from "./ui.js";
 import { reportUsage } from "./api.js";
 import { stripOrphanCalls, persistCompactionSummary, toolOutputFailed, } from "./sessions.js";
 import { flushPendingDiffOutput } from "./tools.js";
@@ -576,7 +576,7 @@ export class InferenceEngine {
                 }
                 for (const c of calls) {
                     this.workActive = false;
-                    const started = formatToolAction(c.name, c.arguments, "started");
+                    const started = toolCallLabel(c.name, c.arguments);
                     const toolSpinner = new Spinner();
                     toolSpinner.start(started);
                     const rawResult = await this.runTool(c.name, c.arguments);
@@ -584,16 +584,14 @@ export class InferenceEngine {
                     if (this.interrupted)
                         throw new Error("interrupt");
                     const failed = toolOutputFailed(c.name, rawResult);
-                    const action = formatToolAction(c.name, c.arguments, failed ? "failed" : "ok");
+                    const action = formatToolResult(rawResult, failed);
                     story.push({
                         type: "tool",
                         started,
                         text: action,
                         status: failed ? "failed" : "ok",
                     });
-                    const icon = failed ? "\x1b[31m✗\x1b[0m" : "\x1b[32m✓\x1b[0m";
-                    const actionStyle = failed ? "\x1b[31m" : "\x1b[32m";
-                    process.stdout.write(`${icon} ${actionStyle}${action}\x1b[0m\n\n`);
+                    process.stdout.write(`${started}\n${action}\n\n`);
                     // Any diff the tool produced is flushed only now, after the spinner
                     // has stopped, so the box renders cleanly below the action line.
                     flushPendingDiffOutput();

package/dist/tools.js

@@ -44,7 +44,7 @@ function displayDiff(pathName, oldContent, newContent) {
     if (oldContent.length + newContent.length > max_diff_source_chars) {
         pendingDiffOutput.push(`\x1b[90m${pathName}: ${oldContent.length.toLocaleString()} chars -> ${newContent.length.toLocaleString()} chars ` +
             `(diff hidden: exceeds ${max_diff_source_chars.toLocaleString()} char limit)\x1b[0m`);
-        return;
+        return null;
     }
     const patch = structuredPatch(pathName, pathName, oldContent, newContent, "", "", { context: max_diff_context_lines });
     const contentLines = [];
@@ -74,7 +74,7 @@ function displayDiff(pathName, oldContent, newContent) {
     const added = contentLines.filter((c) => c.kind === "+").length;
     const removed = contentLines.filter((c) => c.kind === "-").length;
     if (!added && !removed)
-        return;
+        return null;
     const shown = [];
     let run = [];
     let lastKind = null;
@@ -121,51 +121,30 @@ function displayDiff(pathName, oldContent, newContent) {
         if (v.newNum)
             maxNum = Math.max(maxNum, v.newNum);
     }
-    const numW = Math.max(String(maxNum).length, 2);
-    let contentW = 0;
-    for (const v of visible) {
-        const len = v.kind === "~" ? plainLen(v.body) : numW + 1 + 2 + plainLen(v.body);
-        contentW = Math.max(contentW, len);
-    }
-    const headerPlain = `${pathName}  +${added}  -${removed}`;
-    const boxW = Math.min(Math.max(contentW + 6, plainLen(headerPlain) + 6), Math.max(termW - 2, 20));
-    const innerW = Math.max(boxW - 4, 1);
-    const maxPath = Math.max(10, boxW - 2 - plainLen(`  +${added}  -${removed}`) - 3);
-    let pathDisp = pathName;
-    if (plainLen(pathDisp) > maxPath)
-        pathDisp = truncateStyled(pathDisp, Math.max(maxPath - 1, 1)) + "…";
-    const header = `\x1b[1m${pathDisp}\x1b[0m \x1b[32m+${added}\x1b[0m \x1b[31m-${removed}\x1b[0m`;
-    const headerStr = `─ ${header} `;
-    const top = `╭${headerStr}${"─".repeat(Math.max(0, boxW - 2 - plainLen(headerStr)))}╮`;
-    pendingDiffOutput.push(`\x1b[90m${top}\x1b[0m`);
-    const bodyMax = Math.max(innerW - numW - 3, 1);
+    const numW = String(maxNum).length;
+    const indent = "      ";
+    const bodyMax = Math.max(termW - plainLen(indent) - numW - 4, 20);
     const gap = " ".repeat(numW);
     for (const v of visible) {
         if (v.kind === "~") {
-            const body = truncateStyled(v.body, innerW - 2);
-            const text = `\x1b[90m${gap}   ${body}\x1b[0m`;
-            const fill = Math.max(0, innerW - plainLen(text));
-            pendingDiffOutput.push(`\x1b[90m│\x1b[0m ${text}${" ".repeat(fill)} \x1b[90m│\x1b[0m`);
+            const body = truncateStyled(v.body, bodyMax);
+            pendingDiffOutput.push(`\x1b[90m${indent}${gap}   ${body}\x1b[0m`);
             continue;
         }
         const num = v.kind === "+" ? v.newNum : v.oldNum;
         const numStr = num ? String(num).padStart(numW, " ") : gap;
         if (v.kind === "+" || v.kind === "-") {
             const color = v.kind === "+" ? "\x1b[32m" : "\x1b[31m";
+            const sign = v.kind === "+" ? "+" : "-";
             const body = truncateStyled(v.body, bodyMax);
-            const text = `${numStr} ${v.kind === "+" ? "+ " : "- "}${body}`;
-            const fill = Math.max(0, innerW - plainLen(text));
-            // Whole line is painted green/red, filling to the right edge.
-            pendingDiffOutput.push(`\x1b[90m│\x1b[0m ${color}${text}${" ".repeat(fill)}\x1b[0m \x1b[90m│\x1b[0m`);
+            pendingDiffOutput.push(`${indent}${color}${numStr} ${sign}  ${body}\x1b[0m`);
         }
         else {
             const body = truncateStyled(v.kind === "\\" ? v.body : highlightCodeLine(v.body), bodyMax);
-            const text = `\x1b[90m${numStr}  ${body}\x1b[0m`;
-            const fill = Math.max(0, innerW - plainLen(text));
-            pendingDiffOutput.push(`\x1b[90m│\x1b[0m ${text}${" ".repeat(fill)} \x1b[90m│\x1b[0m`);
+            pendingDiffOutput.push(`\x1b[90m${indent}${numStr}  ${body}\x1b[0m`);
         }
     }
-    pendingDiffOutput.push(`\x1b[90m╰${"─".repeat(boxW - 2)}╯\x1b[0m`);
+    return { added, removed };
 }
 export function truncateToolOutput(output, maxChars = max_output_chars) {
     if (output.length > maxChars) {
@@ -491,7 +470,6 @@ export function toolEditFile(pathName, oldString, newString, replaceAll = false)
     const text = data.toString("utf-8");
     const newline = detectNewline(text);
     let match;
-    let normalized = false;
     if (text.includes(oldString)) {
         match = oldString;
     }
@@ -499,7 +477,6 @@ export function toolEditFile(pathName, oldString, newString, replaceAll = false)
         const norm = withNewlines(oldString, newline);
         if (text.includes(norm)) {
             match = norm;
-            normalized = true;
         }
         else {
             const blocks = findWsBlocks(text, oldString);
@@ -508,7 +485,6 @@ export function toolEditFile(pathName, oldString, newString, replaceAll = false)
                     "(line endings and per-line leading/trailing whitespace are normalized for matching)");
             }
             match = blocks[0];
-            normalized = true;
         }
     }
     const count = text.split(match).length - 1;
@@ -519,15 +495,17 @@ export function toolEditFile(pathName, oldString, newString, replaceAll = false)
     const newContent = replaceAll
         ? text.split(match).join(insert)
         : text.replace(match, insert);
-    displayDiff(pathName, text, newContent);
+    const summary = displayDiff(pathName, text, newContent);
     try {
         fs.writeFileSync(p, newContent, "utf-8");
     }
     catch (err) {
         return `Error: ${err}`;
     }
-    return (`Edited ${pathName} (${count} occurrence${count !== 1 ? "s" : ""} replaced` +
-        `${normalized ? "; line endings and per-line whitespace normalized" : ""})`);
+    if (!summary)
+        return `Edited ${pathName}`;
+    return (`Added ${summary.added} line${summary.added !== 1 ? "s" : ""}, ` +
+        `removed ${summary.removed} line${summary.removed !== 1 ? "s" : ""}`);
 }
 // ---------------------------------------------------------------------------
 // bash

package/dist/ui.js

@@ -556,7 +556,7 @@ export class Spinner {
     draw() {
         const text = this.render ? this.render() : "";
         const icon = SPINNER_FRAMES[this.frame % SPINNER_FRAMES.length];
-        const rendered = `\x1b[36m${icon}\x1b[0m \x1b[90m${text}\x1b[0m`;
+        const rendered = `\x1b[1;36m${icon}\x1b[0m \x1b[90m${text}\x1b[0m`;
         // Nothing changed on this tick -> do not rewrite the line (avoids flicker).
         if (rendered === this.lastRendered)
             return;
@@ -613,9 +613,22 @@ export class Spinner {
     }
 }
 // ---------------------------------------------------------------------------
-// Tool Action Formatter
+// Tool Call & Result Formatter
 // ---------------------------------------------------------------------------
-export function formatToolAction(name, argumentsJson, status = "ok") {
+const TOOL_DISPLAY_NAMES = {
+    read_file: "Read",
+    write_file: "Write",
+    edit_file: "Edit",
+    bash: "Bash",
+    glob: "Glob",
+    grep: "Grep",
+    load_skill: "Load",
+};
+const TOOL_RESULT_MAX_CHARS = 400;
+const TOOL_RESULT_MAX_LINES = 6;
+const TOOL_RESULT_MAX_LINE_CHARS = 160;
+/** First line of a tool entry: `Bash(rm -f "…")` — cyan tool name, primary arg in parens. */
+export function toolCallLabel(name, argumentsJson) {
     let args = {};
     try {
         args = argumentsJson ? JSON.parse(argumentsJson) : {};
@@ -623,58 +636,67 @@ export function formatToolAction(name, argumentsJson, status = "ok") {
     catch {
         args = {};
     }
-    const phrase = (verbOk, verbIng, verbFail, detail) => {
-        if (status === "started")
-            return `${verbIng} ${detail}`;
-        if (status === "failed")
-            return `${verbFail} ${detail}`;
-        return `${verbOk} ${detail}`;
-    };
-    const p = args["path"] ?? "";
+    const display = TOOL_DISPLAY_NAMES[name] ??
+        (name ? name[0].toUpperCase() + name.slice(1) : "Tool");
+    let arg = "";
     switch (name) {
-        case "read_file": {
-            const start = args["start_line"];
-            const end = args["end_line"];
-            const span = start != null || end != null
-                ? ` lines ${start ?? 1}-${end ?? "end"}`
-                : "";
-            return phrase("Read", "Reading", "Failed to read", `${p}${span}`);
-        }
+        case "bash":
+            arg = String(args["command"] ?? "");
+            break;
+        case "read_file":
         case "write_file":
-            return phrase("Wrote", "Writing", "Failed to write", `${p} · ${String(args["content"] ?? "").length.toLocaleString()} chars`);
-        case "edit_file": {
-            const suffix = args["replace_all"] ? " · replace all" : "";
-            return phrase("Edited", "Editing", "Failed to edit", `${p}${suffix}`);
-        }
-        case "bash": {
-            const cwd = args["cwd"];
-            const location = cwd ? ` in ${cwd}` : "";
-            const command = truncateEllipsis(String(args["command"] ?? ""), 400, "command");
-            if (status === "started")
-                return `Running command${location}: ${command}`;
-            if (status === "failed")
-                return `Command failed${location}: ${command}`;
-            return `Ran command${location}: ${command}`;
-        }
-        case "glob": {
-            const detail = String(args["pattern"] ?? "");
-            if (status === "failed")
-                return `Search failed for: ${detail}`;
-            return phrase("Searched files for", "Searching files for", "Search failed for", detail);
-        }
-        case "grep": {
-            const detail = String(args["pattern"] ?? "");
-            if (status === "failed")
-                return `Grep failed for: ${detail}`;
-            return phrase("Grepped for", "Grepping for", "Grep failed for", detail);
-        }
-        case "load_skill": {
-            const skill = String(args["skill_name"] ?? "");
-            return phrase("Loaded skill", "Loading skill", "Failed to load skill", skill);
-        }
-        default:
-            return phrase("Executed", "Executing", "Failed to execute", name);
+        case "edit_file":
+            arg = String(args["path"] ?? "");
+            break;
+        case "glob":
+        case "grep":
+            arg = String(args["pattern"] ?? "");
+            break;
+        case "load_skill":
+            arg = String(args["skill_name"] ?? "");
+            break;
     }
+    arg = arg.trim();
+    if (!arg)
+        return `\x1b[1;36m${display}\x1b[0m`;
+    if (arg.length > 400)
+        arg = arg.slice(0, 400) + "…";
+    return `\x1b[1;36m${display}\x1b[0m(${arg})`;
+}
+/**
+ * Second line of a tool entry: `⎿  Done` on a quiet success, otherwise the
+ * tool's output / error, collapsed and truncated so it never floods the screen.
+ */
+export function formatToolResult(rawResult, failed) {
+    const raw = stripAnsi(rawResult || "")
+        .replace(/\r\n/g, "\n")
+        .trim();
+    const code = raw.match(/^exit code: (\d+)/)?.[1] ?? null;
+    const clean = raw.replace(/^exit code: \d+\n?/, "").trim();
+    const corner = "\x1b[90m⎿\x1b[0m  ";
+    if (!failed && (!clean || clean === "(no output)")) {
+        return `${corner}\x1b[32mDone\x1b[0m`;
+    }
+    if (failed && (!clean || clean === "(no output)") && code) {
+        return `${corner}\x1b[31mexit code: ${code}\x1b[0m`;
+    }
+    let body = clean;
+    const clipped = body.length > TOOL_RESULT_MAX_CHARS;
+    if (clipped)
+        body = body.slice(0, TOOL_RESULT_MAX_CHARS);
+    const lines = body
+        .split("\n")
+        .slice(0, TOOL_RESULT_MAX_LINES)
+        .map((ln) => ln.length > TOOL_RESULT_MAX_LINE_CHARS
+        ? ln.slice(0, TOOL_RESULT_MAX_LINE_CHARS) + "…"
+        : ln);
+    if (clipped || body.split("\n").length > TOOL_RESULT_MAX_LINES)
+        lines.push("…");
+    const styleOpen = failed ? "\x1b[31m" : "\x1b[90m";
+    const inner = lines
+        .map((ln, i) => (i === 0 ? corner : "   ") + styleOpen + ln)
+        .join("\n");
+    return `${inner}\x1b[0m`;
 }
 // ---------------------------------------------------------------------------
 // Prompt Editing & Interactive Input

package/package.json

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