@volter-ai-dev/supercode-ui 0.1.8 → 0.1.10

package/core.mjs

@@ -63,6 +63,11 @@ const MODES = new Set(['none', 'control', 'mirror']);
 const STRATEGIES = new Set(['start', 'resume', 'attach', 'branch', 'reduce']);
 const STARTUP = new Set(['connecting', 'starting', 'discovering', 'ready']);
 const FIDELITY = new Set(['byte_lossless', 'value_lossless', 'semantic']);
+const TOOL_CATEGORIES = new Set(['read', 'search', 'edit', 'command', 'test', 'web', 'agent', 'plan', 'other']);
+const TOOL_DETAILS = new Set(['file', 'matches', 'diff', 'terminal', 'web', 'agent', 'plan', 'fields']);
+const MAX_TOOL_FIELDS = 8;
+const MAX_TOOL_FIELD_CHARS = 800;
+const MAX_TOOL_PREVIEW_CHARS = 4_000;
 
 function record(value) {
   return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null;
@@ -80,6 +85,234 @@ function nullableNumber(value) {
   return typeof value === 'number' && Number.isFinite(value) ? value : null;
 }
 
+function boundedString(value, max) {
+  if (typeof value !== 'string') return '';
+  return value.length <= max ? value : `${value.slice(0, max)}…`;
+}
+
+function argumentValue(argumentsText) {
+  if (!argumentsText) return null;
+  try {
+    return JSON.parse(argumentsText);
+  } catch {
+    return null;
+  }
+}
+
+function argumentObject(argumentsText) {
+  return record(argumentValue(argumentsText));
+}
+
+function firstString(source, keys) {
+  for (const key of keys) {
+    if (typeof source?.[key] === 'string' && source[key].trim()) return source[key].trim();
+  }
+  return '';
+}
+
+function decodedLiteral(value) {
+  if (!value) return '';
+  if (value.startsWith('"')) {
+    try { return JSON.parse(value); } catch { return ''; }
+  }
+  return value.slice(1, -1)
+    .replaceAll('\\n', '\n')
+    .replaceAll('\\t', '\t')
+    .replaceAll('\\r', '\r')
+    .replaceAll('\\`', '`')
+    .replaceAll("\\'", "'")
+    .replaceAll('\\\\', '\\');
+}
+
+function sourceString(source, keys) {
+  if (!source) return '';
+  const names = keys.join('|');
+  const match = new RegExp(`\\b(?:${names})\\s*:\\s*(\"(?:\\\\.|[^\"\\\\])*\"|'(?:\\\\.|[^'\\\\])*'|\`(?:\\\\.|[^\`\\\\])*\`)`).exec(source);
+  return decodedLiteral(match?.[1]);
+}
+
+function toolEnvelope(entry) {
+  const value = argumentValue(entry.arguments);
+  const source = typeof value === 'string' ? value : '';
+  const tools = source
+    ? [...new Set([...source.matchAll(/\btools\.([A-Za-z0-9_]+)/g)].map((match) => match[1]))].slice(0, 8)
+    : [];
+  const name = tools.length === 1 ? tools[0] : entry.label ?? 'tool';
+  return { args: record(value), source, tools, name };
+}
+
+function patchPath(source) {
+  return /\*\*\* (?:Update|Add|Delete) File:\s*([^\r\n]+)/.exec(source)?.[1]?.trim() ?? '';
+}
+
+function explicitNumber(sources, keys) {
+  for (const source of sources) {
+    for (const key of keys) {
+      const value = source?.[key];
+      const parsed = typeof value === 'string' && value.trim() !== '' ? Number(value) : value;
+      if (typeof parsed === 'number' && Number.isFinite(parsed)) return parsed;
+    }
+  }
+  return null;
+}
+
+function toolDetail(category) {
+  return ({ read: 'file', search: 'matches', edit: 'diff', command: 'terminal', test: 'terminal', web: 'web', agent: 'agent', plan: 'plan' })[category] ?? 'fields';
+}
+
+function usefulToolFields(args) {
+  if (!args) return [];
+  const hidden = new Set(['command', 'cmd', 'file_path', 'target_file', 'path', 'query', 'pattern', 'url', 'patch', 'diff', 'old_string', 'new_string', 'content', 'prompt', 'description', 'task', 'plan', 'todos']);
+  return Object.entries(args).flatMap(([key, value]) => {
+    if (hidden.has(key) || value === null || value === undefined) return [];
+    const rendered = typeof value === 'string' ? value : JSON.stringify(value);
+    if (!rendered) return [];
+    return [{ label: key.replaceAll(/[_-]+/g, ' ').replace(/^./, (letter) => letter.toLocaleUpperCase()), value: boundedString(rendered, MAX_TOOL_FIELD_CHARS) }];
+  }).slice(0, MAX_TOOL_FIELDS);
+}
+
+function planItems(args) {
+  const source = Array.isArray(args?.plan) ? args.plan : Array.isArray(args?.todos) ? args.todos : [];
+  return source.flatMap((item) => {
+    if (typeof item === 'string' && item.trim()) return [{ label: boundedString(item.trim(), 300), status: '' }];
+    const value = record(item);
+    const label = firstString(value, ['step', 'title', 'content', 'text']);
+    if (!label) return [];
+    return [{ label: boundedString(label, 300), status: firstString(value, ['status']) }];
+  }).slice(0, 12);
+}
+
+function editPreview(args, resultText, source) {
+  const direct = firstString(args, ['patch', 'diff']);
+  if (direct) return direct;
+  const oldText = firstString(args, ['old_string']);
+  const newText = firstString(args, ['new_string']);
+  if (oldText || newText) {
+    return [
+      ...oldText.split('\n').map((line) => `- ${line}`),
+      ...newText.split('\n').map((line) => `+ ${line}`),
+    ].join('\n');
+  }
+  const patch = /\*\*\* Begin Patch[\s\S]*?\*\*\* End Patch/.exec(source ?? '')?.[0];
+  if (patch) return patch;
+  return /^(?:diff --git|@@ |--- |\+\+\+ )/m.test(resultText ?? '') ? resultText : '';
+}
+
+function classifyTool(name, command) {
+  const normalized = name.toLocaleLowerCase();
+  if (/write_stdin|^wait$/.test(normalized)) return 'command';
+  if (/update.?plan|todo|checklist|taskcreate|taskupdate/.test(normalized)) return 'plan';
+  if (/search.?replace|edit|write|patch|replace|create_file|apply_patch/.test(normalized)) return 'edit';
+  if (/read|view|open_file|list_dir/.test(normalized)) return 'read';
+  if (/search|find|grep|glob|toolsearch/.test(normalized)) return 'search';
+  if (/browser|web|fetch|url/.test(normalized)) return 'web';
+  if (/agent|subagent|sendmessage|delegate|^task$/.test(normalized)) return 'agent';
+  if (/test|typecheck|lint|build/.test(normalized)) return 'test';
+  if (/terminal|bash|shell|command|exec|write_stdin|^wait$/.test(normalized)) return /\b(test|typecheck|lint|build)\b/i.test(command) ? 'test' : 'command';
+  return 'other';
+}
+
+function toolAction(status, category, name, tools) {
+  const position = status === 'pending' ? 0 : status === 'error' ? 2 : 1;
+  if (tools.length > 1) return [`Running ${tools.length} actions`, `Ran ${tools.length} actions`, `${tools.length} actions failed`][position];
+  const normalized = name.toLocaleLowerCase();
+  if (/sendmessage/.test(normalized)) return ['Messaging agent', 'Messaged agent', 'Agent message failed'][position];
+  if (/kill_command_or_subagent/.test(normalized)) return ['Stopping', 'Stopped', 'Stop failed'][position];
+  if (/get_command_or_subagent_output|write_stdin|^wait$/.test(normalized)) return ['Waiting for', 'Checked', 'Check failed'][position];
+  const actions = {
+    read: ['Reading', 'Read', 'Read failed'],
+    search: ['Searching', 'Searched', 'Search failed'],
+    edit: ['Editing', 'Edited', 'Edit failed'],
+    command: ['Running command', 'Ran command', 'Command failed'],
+    test: ['Running tests', 'Ran tests', 'Tests failed'],
+    web: ['Browsing', 'Browsed', 'Browser action failed'],
+    agent: ['Starting agent', 'Started agent', 'Agent failed'],
+    plan: ['Updating plan', 'Updated plan', 'Plan update failed'],
+  };
+  return actions[category]?.[position] ?? (status === 'error' ? `${name} failed` : name.replaceAll(/[_-]+/g, ' '));
+}
+
+export function createToolPresentation(entry) {
+  const envelope = toolEnvelope(entry);
+  const args = envelope.args;
+  const command = firstString(args, ['command', 'cmd']) || sourceString(envelope.source, ['command', 'cmd']);
+  const category = classifyTool(envelope.name, command || envelope.source || entry.arguments || '');
+  const path = firstString(args, ['file_path', 'target_file', 'target_directory', 'path']) || sourceString(envelope.source, ['file_path', 'target_file', 'target_directory', 'path']) || patchPath(envelope.source);
+  const query = firstString(args, ['query', 'pattern']) || sourceString(envelope.source, ['query', 'pattern', 'q']);
+  const url = firstString(args, ['url']) || sourceString(envelope.source, ['url', 'ref_id']);
+  const subject = firstString(args, ['subject', 'description', 'summary', 'task', 'prompt']) || sourceString(envelope.source, ['subject', 'description', 'summary', 'task', 'prompt']);
+  const background = /get_command_or_subagent_output|kill_command_or_subagent/i.test(envelope.name) ? 'background task' : /write_stdin|^wait$/i.test(envelope.name) ? 'background command' : '';
+  const items = planItems(args);
+  const taskId = firstString(args, ['taskId', 'task_id']);
+  const planTarget = category === 'plan' ? items.length ? `${items.length} ${items.length === 1 ? 'item' : 'items'}` : taskId ? `task ${taskId}` : '' : '';
+  const target = path || command || query || url || subject || background || planTarget || (envelope.tools.length > 1 ? `${envelope.tools.length} coordinated actions` : toolTarget(entry.arguments));
+  const previewSource = category === 'edit' ? editPreview(args, entry.resultText, envelope.source) : (entry.resultText ?? '');
+  const result = record(entry.resultContent);
+  const metadata = record(entry.metadata);
+  const resultMetadata = record(result?.metadata);
+  return {
+    name: boundedString(envelope.name, 120),
+    action: boundedString(toolAction(entry.status ?? 'completed', category, envelope.name, envelope.tools), 120),
+    category,
+    detail: toolDetail(category),
+    target: boundedString(target, 300),
+    command: boundedString(command, MAX_TOOL_FIELD_CHARS),
+    path: boundedString(path, MAX_TOOL_FIELD_CHARS),
+    query: boundedString(query, MAX_TOOL_FIELD_CHARS),
+    url: boundedString(url, MAX_TOOL_FIELD_CHARS),
+    subject: boundedString(subject, MAX_TOOL_FIELD_CHARS),
+    preview: boundedString(previewSource, MAX_TOOL_PREVIEW_CHARS),
+    fields: usefulToolFields(args),
+    items,
+    tools: envelope.tools,
+    exitCode: explicitNumber([result, resultMetadata, metadata], ['exit_code', 'exitCode', 'pi_bash_exit_code']),
+    durationMs: explicitNumber([result, resultMetadata, metadata], ['duration_ms', 'durationMs', 'elapsed_ms', 'elapsedMs', 'totalDurationMs']),
+    additions: explicitNumber([result, resultMetadata, metadata], ['additions', 'lines_added']),
+    deletions: explicitNumber([result, resultMetadata, metadata], ['deletions', 'lines_removed']),
+    matches: explicitNumber([result, resultMetadata, metadata], ['matches', 'match_count', 'result_count']),
+  };
+}
+
+function readToolPresentation(value, entry) {
+  const generated = createToolPresentation(entry);
+  const item = record(value);
+  if (!item) return generated;
+  const fields = Array.isArray(item.fields) ? item.fields.flatMap((raw) => {
+    const field = record(raw);
+    return field && typeof field.label === 'string' && typeof field.value === 'string'
+      ? [{ label: boundedString(field.label, 80), value: boundedString(field.value, MAX_TOOL_FIELD_CHARS) }]
+      : [];
+  }).slice(0, MAX_TOOL_FIELDS) : generated.fields;
+  const items = Array.isArray(item.items) ? item.items.flatMap((raw) => {
+    const planItem = record(raw);
+    return planItem && typeof planItem.label === 'string'
+      ? [{ label: boundedString(planItem.label, 300), status: boundedString(planItem.status, 40) }]
+      : [];
+  }).slice(0, 12) : generated.items;
+  const tools = Array.isArray(item.tools) ? item.tools.filter((tool) => typeof tool === 'string').map((tool) => boundedString(tool, 120)).slice(0, 8) : generated.tools;
+  return {
+    name: boundedString(item.name, 120) || generated.name,
+    action: boundedString(item.action, 120) || generated.action,
+    category: TOOL_CATEGORIES.has(item.category) ? item.category : generated.category,
+    detail: TOOL_DETAILS.has(item.detail) ? item.detail : generated.detail,
+    target: boundedString(item.target, 300) || generated.target,
+    command: boundedString(item.command, MAX_TOOL_FIELD_CHARS) || generated.command,
+    path: boundedString(item.path, MAX_TOOL_FIELD_CHARS) || generated.path,
+    query: boundedString(item.query, MAX_TOOL_FIELD_CHARS) || generated.query,
+    url: boundedString(item.url, MAX_TOOL_FIELD_CHARS) || generated.url,
+    subject: boundedString(item.subject, MAX_TOOL_FIELD_CHARS) || generated.subject,
+    preview: boundedString(item.preview, MAX_TOOL_PREVIEW_CHARS) || generated.preview,
+    fields,
+    items,
+    tools,
+    exitCode: nullableNumber(item.exitCode) ?? generated.exitCode,
+    durationMs: nullableNumber(item.durationMs) ?? generated.durationMs,
+    additions: nullableNumber(item.additions) ?? generated.additions,
+    deletions: nullableNumber(item.deletions) ?? generated.deletions,
+    matches: nullableNumber(item.matches) ?? generated.matches,
+  };
+}
+
 function readTranscript(value) {
   if (!Array.isArray(value)) return [];
   const result = [];
@@ -97,6 +330,7 @@ function readTranscript(value) {
       if (typeof item[key] === 'string') entry[key] = item[key];
     }
     if (['pending', 'completed', 'error'].includes(item.status)) entry.status = item.status;
+    if (item.role === 'tool') entry.presentation = readToolPresentation(item.presentation, entry);
     if (typeof item.streaming === 'boolean') entry.streaming = item.streaming;
     if (Array.isArray(item.context)) {
       entry.context = item.context.flatMap((raw) => {
@@ -358,15 +592,10 @@ export function groupConversation(entries) {
 }
 
 export function toolCategory(entry) {
-  const name = entry.label?.toLocaleLowerCase() ?? '';
-  if (/read|view|open_file|list_dir/.test(name)) return 'read';
-  if (/search|find|grep|glob/.test(name)) return 'search';
-  if (/edit|write|patch|replace|create_file/.test(name)) return 'edit';
-  if (/test|typecheck|lint|build/.test(name)) return 'test';
-  if (/terminal|bash|shell|command|exec/.test(name)) return /\b(test|typecheck|lint|build)\b/i.test(entry.arguments ?? '') ? 'test' : 'command';
-  if (/browser|web|fetch|url/.test(name)) return 'web';
-  if (/subagent|spawn|task/.test(name)) return 'agent';
-  return 'other';
+  if (TOOL_CATEGORIES.has(entry.presentation?.category)) return entry.presentation.category;
+  const envelope = toolEnvelope(entry);
+  const command = firstString(envelope.args, ['command', 'cmd']) || sourceString(envelope.source, ['command', 'cmd']);
+  return classifyTool(envelope.name, command || envelope.source || entry.arguments || '');
 }
 
 export function toolTarget(argumentsText) {
@@ -395,7 +624,8 @@ export function activitySummary(entries) {
   if (pending) return `${entries.length} actions in progress`;
   if (failed) return `${entries.length} actions · ${failed} failed`;
   if ([...counts.keys()].every((key) => key === 'read' || key === 'search')) return `Explored ${entries.length} ${entries.length === 1 ? 'item' : 'items'}`;
-  return `${entries.length} actions`;
+  const nouns = { read: ['read', 'reads'], search: ['search', 'searches'], edit: ['edit', 'edits'], command: ['command', 'commands'], test: ['test run', 'test runs'], web: ['web action', 'web actions'], agent: ['agent action', 'agent actions'], plan: ['plan update', 'plan updates'], other: ['action', 'actions'] };
+  return [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([category, count]) => `${count} ${nouns[category][count === 1 ? 0 : 1]}`).join(' · ');
 }
 
 export function canContinueHere(state) {