mixdog 0.9.2 → 0.9.4

package/src/tui/engine/tool-result-status.mjs

@@ -0,0 +1,135 @@
+/**
+ * src/tui/engine/tool-result-status.mjs — pure tool-result status + aggregate
+ * text helpers extracted from createEngineSession (engine.mjs).
+ *
+ * These functions were function-declared inside the closure but reference only
+ * their arguments plus toolErrorDisplay (imported below) — no session state —
+ * so they move out verbatim as free functions. engine.mjs imports them and
+ * keeps calling them unchanged.
+ */
+import { toolErrorDisplay } from './tool-result-text.mjs';
+
+export const CANCELLED_RESULT_STATUS_LINE = '[status: cancelled]';
+
+export function normalizedResultStatusToken(value) {
+  const raw = String(value || '').trim().toLowerCase();
+  if (!raw) return '';
+  if (/^(running|pending|queued|in_progress|in-progress)$/.test(raw)) return 'running';
+  if (/^(completed|complete|done|success|succeeded|ok)$/.test(raw)) return 'completed';
+  if (/^(failed|fail|error|errored|timeout|timed_out|killed)$/.test(raw)) return 'failed';
+  if (/^(cancelled|canceled|cancel)$/.test(raw)) return 'cancelled';
+  return '';
+}
+
+export function resultTextTerminalStatus(text) {
+  const body = String(text || '');
+  const tagged = body.match(/<status[^>]*>([\s\S]*?)<\/status>/i)?.[1]?.trim();
+  if (tagged) return normalizedResultStatusToken(tagged);
+  const bracketed = body.match(/^\[status:\s*([^\]]*)\]/mi)?.[1]?.trim();
+  if (bracketed) return normalizedResultStatusToken(bracketed);
+  const inline = body.match(/^(?:status|state):\s*([^\s·,;]+)/mi)?.[1]?.trim();
+  return normalizedResultStatusToken(inline);
+}
+
+export function itemHasKnownTerminalStatus(item, texts = []) {
+  const settled = (token) => token === 'completed' || token === 'failed' || token === 'cancelled';
+  if (settled(normalizedResultStatusToken(item?.args?.status))) return true;
+  for (const text of texts) {
+    if (settled(resultTextTerminalStatus(text))) return true;
+  }
+  return false;
+}
+
+export function withCancelledResultMarker(text, item) {
+  const body = String(text || '');
+  // Do NOT inspect item.rawResult here: aggregate rawResult is child tool
+  // output (`1. grep\n<result>…`) that can incidentally contain a `status:`
+  // line, which would false-positive as an already-terminal status and skip
+  // the cancelled marker. Only result/text/body are engine-controlled
+  // collapsed detail (empty / status word / an existing marker), so they are
+  // the trustworthy terminal-status sources.
+  const sources = [item?.result, item?.text, body];
+  if (itemHasKnownTerminalStatus(item, sources)) return body;
+  if (!body.trim()) return `${CANCELLED_RESULT_STATUS_LINE}\n`;
+  return `${CANCELLED_RESULT_STATUS_LINE}\n${body}`;
+}
+
+export function groupedToolResultText(group) {
+  const completed = Math.min(group.count, group.completed);
+  if (group.count <= 1) return group.results.at(-1)?.text ?? '';
+  if (group.errors > 0) {
+    const succeeded = Math.max(0, completed - group.errors);
+    const reasons = group.results
+      .filter((result) => result?.isError)
+      .map((result) => firstErrorLine(result?.text))
+      .filter(Boolean);
+    const uniqueReasons = [...new Set(reasons)].slice(0, 2);
+    const base = succeeded > 0
+      ? `${succeeded} Ok · ${group.errors} Failed`
+      : `${group.errors} Failed`;
+    return [
+      `${base}${uniqueReasons[0] ? ` · ${uniqueReasons[0]}` : ''}`,
+      ...uniqueReasons.slice(1),
+    ].join('\n');
+  }
+  for (const result of group.results || []) {
+    const line = String(result?.text || '').trim();
+    if (line) return result.text;
+  }
+  return '';
+}
+
+export function firstErrorLine(text) {
+  const clean = toolErrorDisplay(text, 'tool');
+  if (clean) return clean;
+  for (const line of String(text || '').split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (/^(Error|\[?error|FAIL\b)/i.test(trimmed)) return trimmed;
+  }
+  return String(text || '').split('\n').map((line) => line.trim()).find(Boolean) || '';
+}
+
+export function aggregateRawResult(calls) {
+  const chunks = [];
+  for (const rec of calls || []) {
+    if (rec?.resolved !== true) continue;
+    let text = String(rec?.resultText || '').replace(/\s+$/, '');
+    if (!text.trim()) continue;
+    const label = String(rec?.name || rec?.category || 'tool').trim() || 'tool';
+    chunks.push(`${chunks.length + 1}. ${label}\n${text}`);
+  }
+  return chunks.join('\n\n');
+}
+
+export function aggregateBucketForCategory(category) {
+  // Merge consecutive tool calls of the SAME category into one aggregate card;
+  // a different category opens a fresh card (no cross-category merge). The
+  // bucket key is the category itself, so a run of Search calls collapses into
+  // one Search card while an adjacent Read/Patch stays separate. Falls back to
+  // 'default' when a call has no resolved category. Hook/approval denials keep
+  // their dedicated ToolHookDenialCard path in App.jsx.
+  const key = String(category || '').trim();
+  // Exception: Read and Search share one lookup bucket so a batched turn of
+  // read+grep renders as ONE card ("Reading 3 files · Searching 2 patterns")
+  // instead of two adjacent cards. The per-category entries in
+  // aggregateCard.categories keep their own verbs/counts, so the merged
+  // header still spells out both. State-changing categories (Patch/Shell/…)
+  // stay separate.
+  if (key === 'Read' || key === 'Search') return 'category:Read+Search';
+  return key ? `category:${key}` : 'default';
+}
+
+export function aggregateSummaries(aggregate) {
+  return [...(aggregate?.calls?.values?.() || [])]
+    .filter((r) => r.summary)
+    .sort((a, b) => Number(a.summarySeq ?? 0) - Number(b.summarySeq ?? 0))
+    .map((r) => r.summary);
+}
+
+export function assignAggregateSummaryOrder(aggregate, callRec) {
+  if (!aggregate || !callRec?.summary || callRec.summarySeq != null) return;
+  const next = Math.max(0, Number(aggregate.nextSummarySeq || 0));
+  callRec.summarySeq = next;
+  aggregate.nextSummarySeq = next + 1;
+}

package/src/tui/engine/tool-result-text.mjs

@@ -0,0 +1,126 @@
+/**
+ * src/tui/engine/tool-result-text.mjs - flatten tool-result content shapes into
+ * display text, plus collapsed-detail/grouped fallbacks and error framing.
+ * Extracted from engine.mjs; toolResultText/toolAggregateDetailFallback/
+ * toolGroupedDisplayFallback remain part of engine.mjs's public surface.
+ */
+import { presentErrorText } from '../../runtime/shared/err-text.mjs';
+
+export function toolResultText(content) {
+  if (content == null) return '';
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content.map((c) => toolResultPartText(c)).filter((t) => t !== '').join('\n');
+  }
+  if (typeof content === 'object') {
+    if (Array.isArray(content.content)) {
+      const nested = content.content.map((c) => toolResultPartText(c)).filter((t) => t !== '').join('\n');
+      if (nested) return nested;
+    } else if (content.content != null && typeof content.content === 'object') {
+      const nested = toolResultPartText(content.content);
+      if (nested) return nested;
+    }
+    if (Array.isArray(content.parts)) {
+      const nested = content.parts.map((c) => toolResultPartText(c)).filter((t) => t !== '').join('\n');
+      if (nested) return nested;
+    }
+    const fromPart = toolResultPartText(content);
+    if (fromPart) return fromPart;
+    if (content?.type === 'tool_result') return '';
+    if (typeof content.text === 'string') return content.text;
+    if (typeof content.content === 'string') return content.content;
+  }
+  try { return JSON.stringify(content); } catch { return String(content); }
+}
+
+const TOOL_RESULT_PART_MAX_DEPTH = 12;
+const TOOL_RESULT_JSON_FALLBACK_MAX = 480;
+// Absolute cap for a collapsed tool detail line (the second row under the ⎿
+// gutter). Terminal-width independent so a wide terminal never lets a long line
+// stretch the row; lockstep with ToolExecution RESULT_LINE_HARD_MAX (80).
+const TOOL_DETAIL_LINE_MAX = 80;
+
+function compactToolResultObjectFallback(obj) {
+  if (obj?.type === 'tool_result') return '';
+  try {
+    const json = JSON.stringify(obj);
+    if (!json || json === '{}') return '';
+    if (json.length <= TOOL_RESULT_JSON_FALLBACK_MAX) return json;
+    return `${json.slice(0, TOOL_RESULT_JSON_FALLBACK_MAX - 1)}…`;
+  } catch {
+    return String(obj);
+  }
+}
+
+export function toolResultPartText(part, depth = 0) {
+  if (part == null) return '';
+  if (depth > TOOL_RESULT_PART_MAX_DEPTH) return '';
+  if (typeof part === 'string') return part;
+  if (part?.type === 'image' || part?.type === 'input_image') {
+    return `[image: ${part.mimeType || part.mediaType || part.source?.media_type || 'image'}]`;
+  }
+  if (part?.type === 'tool_result') {
+    const inner = part.content;
+    if (typeof inner === 'string') return inner;
+    if (Array.isArray(inner)) {
+      return inner.map((c) => toolResultPartText(c, depth + 1)).filter((t) => t !== '').join('\n');
+    }
+    if (inner != null && typeof inner === 'object') {
+      return toolResultPartText(inner, depth + 1);
+    }
+    return '';
+  }
+  if (part?.type === 'text' || part?.type === 'output_text' || part?.type === 'input_text') {
+    return part.text ?? '';
+  }
+  if (Array.isArray(part)) {
+    return part.map((c) => toolResultPartText(c, depth + 1)).filter((t) => t !== '').join('\n');
+  }
+  if (typeof part === 'object') {
+    if (Array.isArray(part.content)) {
+      const nested = part.content.map((c) => toolResultPartText(c, depth + 1)).filter((t) => t !== '').join('\n');
+      if (nested) return nested;
+    }
+    if (part.content != null && typeof part.content === 'object') {
+      const nested = toolResultPartText(part.content, depth + 1);
+      if (nested) return nested;
+    }
+    if (Array.isArray(part.parts)) {
+      const nested = part.parts.map((c) => toolResultPartText(c, depth + 1)).filter((t) => t !== '').join('\n');
+      if (nested) return nested;
+    }
+    if (typeof part.text === 'string' && part.text) return part.text;
+    if (typeof part.output === 'string' && part.output) return part.output;
+    if (typeof part.message === 'string' && part.message) return part.message;
+    if (typeof part.content === 'string') return part.content;
+    if (part.source?.type === 'base64' && part.source?.data) {
+      return `[image: ${part.source.media_type || part.source.mediaType || 'base64'}]`;
+    }
+    return compactToolResultObjectFallback(part);
+  }
+  return '';
+}
+
+export function toolAggregateDetailFallback(detailText, rawResult) {
+  if (String(detailText || '').trim()) return detailText;
+  const raw = String(rawResult || '').replace(/\s+$/, '').trim();
+  if (!raw) return detailText;
+  const line = raw.split('\n').map((l) => l.trim()).find(Boolean) || '';
+  if (!line) return detailText;
+  return line.length > TOOL_DETAIL_LINE_MAX ? `${line.slice(0, TOOL_DETAIL_LINE_MAX - 3)}…` : line;
+}
+
+export function toolGroupedDisplayFallback(resultText, text, rawText) {
+  if (String(resultText || '').trim()) return resultText;
+  const body = String(text || rawText || '').trim();
+  if (body) return text || rawText;
+  return resultText;
+}
+
+export function toolErrorDisplay(value, surface = 'tool') {
+  const text = presentErrorText(value, { surface });
+  if (/^(?:Search failed|Fetch failed|No first response|The .+ went stale|(?:Web search agent|Agent|Tool) (?:stopped|was cancelled))/i.test(text)) {
+    return text;
+  }
+  return /^error\s*:/i.test(text) ? text : `Error: ${text}`;
+}