u-foo 3.0.25 → 3.0.26

package/src/ui/format/index.js

@@ -154,11 +154,10 @@ function buildUcodeBannerLines({
   }
   shortPath = path.normalize(shortPath);
 
-  // The banner is content, not a log message. Keep it free of ANSI styling so
-  // every terminal renderer can display it as a stable, unformatted block.
+  // The logo is literal content. The renderer receives the completed banner
+  // row as a dedicated raw entry, so the logo never goes through log styling.
   const logoLines = UCODE_BANNER_LINES;
   const infoLines = [];
-  infoLines.push(`Version: ${UCODE_VERSION}`);
   infoLines.push(`Model: ${modelLabel}`);
   if (planMode) {
     infoLines.push("Mode: PLAN");
@@ -176,7 +175,7 @@ function buildUcodeBannerLines({
   return Array.from({ length: rows }, (_, index) => {
     const logoLine = logoLines[index] || logoPadding;
     const info = infoLines[index] || "";
-    return `  ${logoLine}  ${info}`;
+    return `${logoLine}  ${info}`;
   });
 }
 
@@ -325,6 +324,66 @@ function toolMessagePreview(message = {}) {
   return raw;
 }
 
+function parseToolCallArguments(call = {}) {
+  const raw = call && call.function && call.function.arguments != null
+    ? call.function.arguments
+    : (call && call.arguments != null ? call.arguments : call && call.input);
+  if (raw && typeof raw === "object") return raw;
+  if (typeof raw !== "string" || !raw.trim()) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function formatToolDisplayName(tool = "") {
+  const words = String(tool || "tool")
+    .trim()
+    .split(/[_\-\s]+/)
+    .filter(Boolean);
+  return words.map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ") || "Tool";
+}
+
+function formatUcodeToolLine(tool = "", args = {}, payload = {}) {
+  const name = String(tool || "tool").trim().toLowerCase() || "tool";
+  const detail = normalizeToolLogDetail(name, args, payload);
+  return `• ${formatToolDisplayName(name)}${detail ? ` ${detail}` : ""}`;
+}
+
+function collapseConsecutiveUcodeToolEntries(entries = []) {
+  const source = Array.isArray(entries) ? entries : [];
+  const collapsed = [];
+  for (let index = 0; index < source.length;) {
+    const entry = source[index];
+    if (!entry || entry.kind !== "tool") {
+      collapsed.push(entry);
+      index += 1;
+      continue;
+    }
+
+    let end = index + 1;
+    while (end < source.length && source[end] && source[end].kind === "tool") end += 1;
+    const group = source.slice(index, end);
+    if (group.length === 1) {
+      collapsed.push(entry);
+    } else {
+      const detail = group
+        .map((item) => String(item.text || "").replace(/^•\s*/, ""))
+        .join("\n");
+      collapsed.push({
+        ...entry,
+        text: `${String(entry.text || "• Tool")} · +${group.length - 1} calls (Ctrl+O expand)`,
+        detail,
+        expanded: false,
+      });
+    }
+    index = end;
+  }
+  return collapsed;
+}
+
 /**
  * Collapse attached-image prompt prefixes / base64 blobs for TUI log display.
  */
@@ -357,9 +416,6 @@ function buildUcodeSessionLogEntries(messages = [], options = {}) {
     : { inCodeBlock: false };
   const idPrefix = String(options.idPrefix || "h");
   let seq = Number.isFinite(options.startSeq) ? Math.max(0, Math.floor(options.startSeq)) : 0;
-  const maxToolPreviewLines = Number.isFinite(options.maxToolPreviewLines)
-    ? Math.max(1, Math.floor(options.maxToolPreviewLines))
-    : 4;
   const entries = [];
 
   const pushLines = (text, kind) => {
@@ -375,14 +431,12 @@ function buildUcodeSessionLogEntries(messages = [], options = {}) {
     } else {
       lines = source.split(/\r?\n/);
     }
-    for (const line of lines) {
-      entries.push({
-        id: `${idPrefix}-${seq}`,
-        text: String(line || ""),
-        kind,
-      });
-      seq += 1;
-    }
+    entries.push({
+      id: `${idPrefix}-${seq}`,
+      text: lines.map((line) => String(line || "")).join("\n"),
+      kind,
+    });
+    seq += 1;
   };
 
   for (const message of list) {
@@ -392,37 +446,35 @@ function buildUcodeSessionLogEntries(messages = [], options = {}) {
       const text = redactUserMessageForLog(messageContentText(message));
       if (!text.trim()) continue;
       const lines = text.split(/\r?\n/);
-      lines.forEach((line, index) => {
-        pushLines(index === 0 ? `› ${line}` : line, "user");
-      });
+      pushLines(lines.map((line, index) => (index === 0 ? `› ${line}` : line)).join("\n"), "user");
       continue;
     }
     if (role === "assistant") {
       const text = messageContentText(message);
       if (text) pushLines(text, "assistant");
       const calls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
-      if (calls.length > 0) {
-        const names = calls
-          .map((call) => {
-            if (!call || typeof call !== "object") return "";
-            if (call.function && call.function.name) return String(call.function.name);
-            return String(call.name || "");
-          })
-          .map((name) => name.trim())
-          .filter(Boolean);
-        if (names.length > 0) pushLines(`⚙ ${names.join(" · ")}`, "system");
+      for (const call of calls) {
+        if (!call || typeof call !== "object") continue;
+        const name = String(
+          (call.function && call.function.name) || call.name || "tool"
+        ).trim();
+        pushLines(formatUcodeToolLine(name, parseToolCallArguments(call)), "tool");
       }
       continue;
     }
     if (role === "tool") {
-      const preview = toolMessagePreview(message);
-      if (!preview.trim()) continue;
-      const clipped = preview.split(/\r?\n/).slice(0, maxToolPreviewLines).join("\n");
-      pushLines(clipped, "toolDetail");
+      // The corresponding assistant tool_call already carries the command or
+      // path. Tool-result artifacts are internal storage references and do
+      // not belong in the restored transcript presentation.
+      continue;
     }
   }
 
-  return { entries, nextSeq: seq, markdownState };
+  return {
+    entries: collapseConsecutiveUcodeToolEntries(entries),
+    nextSeq: seq,
+    markdownState,
+  };
 }
 
 function shouldEnterAgentSelection(inputValue = "") {
@@ -828,6 +880,19 @@ function buildToolMergeRowText(entries = []) {
   return `· ${summary}`;
 }
 
+function buildUcodeToolRowText(entries = []) {
+  const list = Array.isArray(entries)
+    ? entries.map((item) => normalizeToolMergeEntry(item))
+    : [];
+  if (list.length === 0) return "• Tool";
+  const first = list[0];
+  const firstLine = `• ${formatToolDisplayName(first.tool)}${first.detail ? ` ${first.detail}` : ""}`;
+  if (list.length === 1) return firstLine;
+  const errorCount = list.filter((item) => item.isError).length;
+  const errorSuffix = errorCount > 0 ? ` · ${errorCount} error${errorCount === 1 ? "" : "s"}` : "";
+  return `${firstLine} · +${list.length - 1} calls${errorSuffix}`;
+}
+
 /**
  * Lay out the global-mode project rail inside a single line. Like
  * planAgentsFooter, but with two differences:
@@ -1318,6 +1383,8 @@ module.exports = {
   buildMergedToolExpandedLines,
   buildMergedToolSummaryText,
   buildToolMergeRowText,
+  buildUcodeToolRowText,
+  collapseConsecutiveUcodeToolEntries,
   buildCompletions,
   buildUcodeBannerLines,
   buildUcodeSessionLogEntries,

package/src/ui/format/markdownRenderer.js

@@ -140,7 +140,7 @@ function createBlessedAdapters(escapeFn = (value) => String(value || "")) {
       return `{bold}${value}{/bold}`;
     },
     quoteMarker: () => "{gray-fg}│{/gray-fg}",
-    bulletMarker: () => "{gray-fg}•{/gray-fg}",
+    bulletMarker: () => "{gray-fg}-{/gray-fg}",
     orderedMarker: (value) => `{gray-fg}${escape(value)}.{/gray-fg}`,
     rule: () => "{gray-fg}────────────────────────{/gray-fg}",
     fenceOpen: (language) => (
@@ -181,7 +181,7 @@ function createAnsiAdapters() {
       return paint.bold(text);
     },
     quoteMarker: () => paint.gray("│"),
-    bulletMarker: () => paint.gray("•"),
+    bulletMarker: () => paint.gray("-"),
     orderedMarker: (value) => paint.gray(`${value}.`),
     rule: () => paint.gray("────────────────────────"),
     fenceOpen: (language) => (

package/src/ui/rustChatHost.js

@@ -39,6 +39,7 @@ const {
   resolveDaemonEndpoint,
   routeDaemonRequest,
 } = require("../runtime/daemon/endpoint");
+const PACKAGE_VERSION = require("../../package.json").version;
 
 function stripTags(value) {
   return String(value || "").replace(/\{[^}]+\}/g, "");
@@ -979,6 +980,7 @@ async function runChatRust(projectRoot, options = {}) {
     const projects = env.globalMode ? loadGlobalProjectRows(activeProjectRoot) : [];
     return {
       status: "ready",
+      package_version: PACKAGE_VERSION,
       footer: agents.footer || "",
       entries: historyToEntries(history),
       input_history: Array.isArray(inputHistory) ? inputHistory.filter(Boolean) : [],

package/src/ui/rustUcodeHost.js

@@ -17,6 +17,7 @@ const {
 } = require("../code/UcodeController");
 const { createEnvelope, encodeMessage } = require("../runtime/contracts/uiProtocol");
 const fmt = require("./format");
+const PACKAGE_VERSION = require("../../package.json").version;
 
 function stripTags(value) {
   return String(value || "").replace(/\{[^}]+\}/g, "");
@@ -162,6 +163,46 @@ function normalizeToolLogEntry(entry = {}) {
   return fmt.normalizeToolMergeEntry({ tool, detail, isError, errorText });
 }
 
+function splitUcodeBannerRow(line, index) {
+  const row = String(line || "");
+  const logo = String((fmt.UCODE_BANNER_LINES || [])[index] || "");
+  if (logo && row.startsWith(logo)) {
+    return { logo, metadata: row.slice(logo.length).trimStart() };
+  }
+  return { logo: "", metadata: row.trimStart() };
+}
+
+/**
+ * Keep a model's reasoning in one mutable scrollback entry. The TUI owns the
+ * collapsed/expanded presentation; the host only sends an initial row plus
+ * append-only deltas for that row.
+ */
+function createThinkingLogPublisher(publish, thinkingStatus, streamId) {
+  const id = `${String(streamId || "stream")}-thinking`;
+  let started = false;
+
+  function onThinkingDelta(delta) {
+    const text = String(delta || "");
+    if (!text) return;
+    if (!started) {
+      started = true;
+      publish("thinking.start", { id });
+    }
+    publish("thinking.delta", { id, text });
+    if (thinkingStatus && typeof thinkingStatus.onThinkingDelta === "function") {
+      thinkingStatus.onThinkingDelta(text);
+    }
+  }
+
+  function stop() {
+    if (thinkingStatus && typeof thinkingStatus.reset === "function") {
+      thinkingStatus.reset();
+    }
+  }
+
+  return { id, onThinkingDelta, stop };
+}
+
 async function runUcodeRust(props = {}) {
   const plan = resolveTuiLaunchPlan({
     mode: props.tuiMode || process.env.UFOO_TUI || "rust",
@@ -321,25 +362,22 @@ async function runUcodeRust(props = {}) {
     } else {
       lines = raw.split(/\r?\n/);
     }
-    let last = null;
-    for (const line of lines) {
-      entrySeq += 1;
-      last = {
-        id: `u-${entrySeq}`,
-        kind,
-        text: stripTags(line),
-        // Keep ANSI in a parallel field if strip removes styling; prefer raw
-        // ANSI line for Rust when it contains escape sequences.
-        ansi: line,
-        speaker: "",
-      };
-      // Prefer ANSI when present so Rust can paint spans; otherwise plain.
-      if (/\x1b\[/.test(line)) {
-        last.text = line;
-      }
-      publish("transcript.append", last);
+    const block = lines.map((line) => String(line || "")).join("\n");
+    entrySeq += 1;
+    const entry = {
+      id: `u-${entrySeq}`,
+      kind,
+      text: stripTags(block),
+      // Keep ANSI in a parallel field if strip removes styling; prefer the
+      // rendered block for Rust when it contains escape sequences.
+      ansi: block,
+      speaker: "",
+    };
+    if (/\x1b\[/.test(block)) {
+      entry.text = block;
     }
-    return last;
+    publish("transcript.append", entry);
+    return entry;
   }
 
   function replaceTranscript(entries = []) {
@@ -351,6 +389,8 @@ async function runUcodeRust(props = {}) {
         kind: String((entry && entry.kind) || "system"),
         text,
         speaker: String((entry && entry.speaker) || ""),
+        detail: String((entry && entry.detail) || ""),
+        expanded: Boolean(entry && entry.expanded),
       };
     });
     entrySeq = Math.max(entrySeq, normalized.length);
@@ -461,13 +501,25 @@ async function runUcodeRust(props = {}) {
     );
     return {
       status: "ready",
+      package_version: PACKAGE_VERSION,
       footer: agentsSnap.footer,
-      entries: banner.concat([""]).map((line, idx) => ({
-        id: `b-${idx}`,
-        kind: idx < banner.length ? "banner" : "spacer",
-        text: stripTags(line),
+      entries: banner.map((line, idx) => {
+        const { logo, metadata } = splitUcodeBannerRow(line, idx);
+        return {
+          id: `b-${idx}`,
+          kind: "banner",
+          // Logo and metadata are separate raw renderer segments. Neither
+          // ever passes through the ordinary log formatter.
+          text: logo,
+          detail: metadata,
+          speaker: "",
+        };
+      }).concat([{
+        id: `b-${banner.length}`,
+        kind: "spacer",
+        text: "",
         speaker: "",
-      })),
+      }]),
       input_history: [],
       agents: agentsSnap.agents,
       attachment_count: pendingAttachments.length,
@@ -509,17 +561,28 @@ async function runUcodeRust(props = {}) {
       tools.beginScope();
       thinking.reset();
       publish("stream.start", { id: streamId });
+      const thinkingLog = createThinkingLogPublisher(publish, thinking, streamId);
+      let responseStarted = false;
+      const beginResponse = () => {
+        if (responseStarted) return;
+        responseStarted = true;
+        thinkingLog.stop();
+        publish("status.set", { text: "Generating response…", busy: true });
+      };
       try {
         const result = await submit(answerText, props.state, {
           signal: abort.signal,
           onDelta: (delta) => {
+            beginResponse();
             publish("stream.delta", { id: streamId, text: String(delta || "") });
           },
-          onThinkingDelta: thinking.onThinkingDelta,
+          onThinkingDelta: (delta) => {
+            if (!responseStarted) thinkingLog.onThinkingDelta(delta);
+          },
           onToolLog: ingestToolLog,
         });
         tools.flush();
-        thinking.reset();
+        thinkingLog.stop();
         publish("stream.done", { id: streamId });
         if (!result || result.ok === false) {
           appendLog(`Error: ${(result && result.error) || "resume failed"}`, "error");
@@ -535,7 +598,7 @@ async function runUcodeRust(props = {}) {
         return { ok: true, waiting: false };
       } catch (err) {
         tools.flush();
-        thinking.reset();
+        thinkingLog.stop();
         publish("stream.done", { id: streamId });
         if (abort.signal.aborted) {
           appendLog("Task cancelled.", "system");
@@ -557,20 +620,31 @@ async function runUcodeRust(props = {}) {
       tools.beginScope();
       thinking.reset();
       publish("stream.start", { id: streamId });
+      const thinkingLog = createThinkingLogPublisher(publish, thinking, streamId);
+      let responseStarted = false;
+      const beginResponse = () => {
+        if (responseStarted) return;
+        responseStarted = true;
+        thinkingLog.stop();
+        publish("status.set", { text: "Generating response…", busy: true });
+      };
       try {
         const nlResult = await props.runNaturalLanguageTask(text, props.state, {
           signal: abort.signal,
           onDelta: (delta) => {
+            beginResponse();
             publish("stream.delta", { id: streamId, text: String(delta || "") });
           },
-          onThinkingDelta: thinking.onThinkingDelta,
+          onThinkingDelta: (delta) => {
+            if (!responseStarted) thinkingLog.onThinkingDelta(delta);
+          },
           onToolLog: ingestToolLog,
           onPhase: (event) => {
             if (!event || typeof event !== "object") return;
             if (event.type === "request_start") {
               publish("status.set", { text: "Waiting for model…", busy: true });
             } else if (event.type === "text_delta") {
-              publish("status.set", { text: "Generating response…", busy: true });
+              beginResponse();
             } else if (event.type === "tool_request") {
               const tool = String(event.name || "tool").trim() || "tool";
               const label = (fmt.TOOL_LABELS && fmt.TOOL_LABELS[tool.toLowerCase()])
@@ -580,7 +654,7 @@ async function runUcodeRust(props = {}) {
           },
         });
         tools.flush();
-        thinking.reset();
+        thinkingLog.stop();
         publish("stream.done", { id: streamId });
         if (nlResult && nlResult.summary) appendLog(nlResult.summary, "system");
         if (typeof props.formatNlResult === "function" && nlResult) {
@@ -596,7 +670,7 @@ async function runUcodeRust(props = {}) {
         return { ok: true, waiting: false, result: nlResult };
       } catch (err) {
         tools.flush();
-        thinking.reset();
+        thinkingLog.stop();
         publish("stream.done", { id: streamId });
         if (abort.signal.aborted) {
           appendLog("Task cancelled.", "system");
@@ -994,6 +1068,8 @@ module.exports = {
   runUcodeRust,
   buildPlanSetPayload,
   normalizeToolLogEntry,
+  splitUcodeBannerRow,
+  createThinkingLogPublisher,
   buildUcodeAgentsSnapshot,
   buildUcodeCompletionItems,
 };

package/src/ui/toolMergeBridge.js

@@ -23,13 +23,11 @@ function createToolMergePublisher(publish) {
       merge = null;
       return;
     }
-    const summary = fmt.buildMergedToolSummaryText(merge.entries);
+    const summary = fmt.buildUcodeToolRowText(merge.entries);
     const detail = fmt.buildMergedToolExpandedLines(merge.entries).join("\n");
-    const row = typeof fmt.buildToolMergeRowText === "function"
-      ? fmt.buildToolMergeRowText(merge.entries)
-      : (merge.entries.length >= 2
-        ? `· ${summary} (Ctrl+O expand)`
-        : summary);
+    const row = merge.entries.length >= 2
+      ? `${summary} (Ctrl+O expand)`
+      : summary;
     publish("tool.group", {
       id: `tool-merge-${merge.id}`,
       summary: row || summary,
@@ -47,7 +45,7 @@ function createToolMergePublisher(publish) {
     if (merge) {
       publish("tool.start", {
         id: `tool-merge-${merge.id}`,
-        summary: fmt.buildMergedToolSummaryText(merge.entries),
+        summary: fmt.buildUcodeToolRowText(merge.entries),
       });
     }
   }