@bahulam/code 2.6.13 → 2.6.15

package/src/ui/tool-card.mjs

@@ -29,6 +29,7 @@ import {
   toolDisplaySummary,
   formatShellCommand,
   shellCommandDisplay,
+  shellCommandProfile,
 } from '../terminal/tool-display.mjs';
 
 // ── Family → label colorizer ─────────────────────────────────────────────
@@ -50,8 +51,10 @@ function formatArgs(tool, args, cwd) {
   const summary = toolDisplaySummary(tool, args || {}, { cwd });
   if (!summary) return '';
   if (tool === 'shell') {
+    const profile = shellCommandProfile(summary, { cwd });
+    if (profile.compact) return compactShellProfile(profile);
     const display = shellCommandDisplay(summary, { cwd });
-    const command = formatShellCommand(display.command, paintShellAdapter);
+    const command = `${paint.text.dim('$')} ${formatShellCommand(display.command, paintShellAdapter)}`;
     return display.cwdLabel
       ? `${command} ${paint.text.dim('in')} ${paint.brand.data(display.cwdLabel)}`
       : command;
@@ -150,6 +153,10 @@ export function summarizeResult(tool, data) {
       if (exit != null && exit !== 0) {
         return { text: `exit ${exit}`, tone: 'danger' };
       }
+      if (tool === 'shell') {
+        const structured = structuredOutputSummary(data.output_preview || data.output);
+        if (structured) return structured;
+      }
       const head = firstOutputLine(data).slice(0, 100);
       return { text: head || 'ok', tone: 'success' };
     }
@@ -179,34 +186,92 @@ export function summarizeResult(tool, data) {
   }
 }
 
+function structuredOutputSummary(output) {
+  const raw = String(output || '').trim();
+  if (!raw || !/^[\[{]/.test(raw)) return null;
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    const first = raw.split('\n').find(line => /^[\[{]/.test(line.trim()));
+    if (!first) return null;
+    try { value = JSON.parse(first.trim()); } catch { return null; }
+  }
+  return summarizeJsonOutput(value);
+}
+
+function summarizeJsonOutput(value) {
+  if (Array.isArray(value)) {
+    return { text: `json array · ${value.length} item${value.length === 1 ? '' : 's'}`, tone: 'success' };
+  }
+  if (!value || typeof value !== 'object') return null;
+
+  if ('service' in value && 'profile' in value && 'inSync' in value) {
+    const service = String(value.service || 'service');
+    const profile = value.profile ? ` · ${value.profile}` : '';
+    const status = value.inSync === true ? 'in sync'
+      : value.inSync === false ? 'out of sync'
+      : 'sync status unknown';
+    const diffs = Array.isArray(value.diff) ? value.diff
+      : Array.isArray(value.diffs) ? value.diffs
+      : [];
+    const diffText = diffs.length ? ` · ${diffs.length} diff${diffs.length === 1 ? '' : 's'}` : '';
+    return {
+      text: `${service} ${status}${profile}${diffText}`,
+      tone: value.inSync === false ? 'warn' : 'success',
+    };
+  }
+
+  const keys = Object.keys(value).slice(0, 4);
+  return {
+    text: keys.length ? `json · ${keys.join(', ')}` : 'json object',
+    tone: 'success',
+  };
+}
+
 export function formatCompactFileDiff(result, {
   indent = '  ',
-  maxLines = 14,
-  maxFiles = 2,
+  maxLines = Infinity,
+  maxFiles = Infinity,
   columns = term().columns || 120,
+  showFileHeader = false,
 } = {}) {
-  const diffs = fileDiffs(result).filter(diff => diff?.hunks?.length);
+  const diffs = fileDiffs(result)
+    .map(normalizeFileDiff)
+    .filter(diff => diff && (diff.redacted || diff?.hunks?.length));
   if (!diffs.length) return '';
 
   const out = [];
   let shown = 0;
   let truncated = false;
+  const lineLimit = Number.isFinite(maxLines) ? Math.max(0, Math.floor(maxLines)) : Infinity;
+  const fileLimit = Number.isFinite(maxFiles) ? Math.max(0, Math.floor(maxFiles)) : diffs.length;
   const lineBudget = Math.max(40, columns - visibleWidth(indent) - 4);
 
-  for (const diff of diffs.slice(0, maxFiles)) {
-    if (diffs.length > 1) {
-      if (shown >= maxLines) { truncated = true; break; }
+  for (const diff of diffs.slice(0, fileLimit)) {
+    if (showFileHeader || diffs.length > 1) {
+      if (shown >= lineLimit) { truncated = true; break; }
       out.push(`${indent}${paint.brand.primary(diff.relative_path || diff.path || 'file')} ${paint.text.dim(diffDelta(diff))}`);
       shown++;
     }
 
+    if (diff.redacted) {
+      if (shown >= lineLimit) { truncated = true; break; }
+      const subject = (showFileHeader || diffs.length > 1)
+        ? ''
+        : `${[diff.relative_path || diff.path || 'file', diffDelta(diff)].filter(Boolean).join(' ')} · `;
+      out.push(`${indent}${paint.text.dim(`${subject}diff redacted for sensitive config`)}`);
+      shown++;
+      continue;
+    }
+
     for (const hunk of diff.hunks || []) {
-      if (shown >= maxLines) { truncated = true; break; }
+      if (shown >= lineLimit) { truncated = true; break; }
       out.push(`${indent}${paint.text.dim(`@@ -${hunk.old_start},${hunk.old_count} +${hunk.new_start},${hunk.new_count} @@`)}`);
       shown++;
 
       for (const line of hunk.lines || []) {
-        if (shown >= maxLines) { truncated = true; break; }
+        if (shown >= lineLimit) { truncated = true; break; }
         out.push(`${indent}${paintDiffLine(line, lineBudget)}`);
         shown++;
       }
@@ -215,7 +280,7 @@ export function formatCompactFileDiff(result, {
     if (truncated) break;
   }
 
-  if (diffs.length > maxFiles) truncated = true;
+  if (diffs.length > fileLimit) truncated = true;
   if (truncated) out.push(`${indent}${paint.text.dim('… diff preview truncated; use /last to expand')}`);
   return out.join('\n');
 }
@@ -224,9 +289,112 @@ function fileDiffs(result) {
   if (!result) return [];
   if (Array.isArray(result.file_diffs)) return result.file_diffs;
   if (result.file_diff) return [result.file_diff];
+  if (result.type === 'file_diff' || result.hunks || result.unified) return [result];
   return [];
 }
 
+function normalizeFileDiff(diff) {
+  if (!diff) return null;
+  return {
+    ...diff,
+    hunks: normalizeHunks(diff),
+  };
+}
+
+function normalizeHunks(diff) {
+  if (Array.isArray(diff?.hunks) && diff.hunks.length) {
+    return diff.hunks.map(normalizeHunk).filter(hunk => hunk.lines.length);
+  }
+  if (diff?.unified) return parseUnifiedHunks(diff.unified);
+  return [];
+}
+
+function normalizeHunk(hunk = {}) {
+  const lines = Array.isArray(hunk.lines)
+    ? hunk.lines.map(normalizeDiffLine).filter(Boolean)
+    : typeof hunk.body === 'string'
+      ? parseDiffBody(hunk.body)
+      : [];
+  const oldCount = hunk.old_count ?? hunk.old_lines ?? hunk.oldCount ?? countDiffLines(lines, 'old');
+  const newCount = hunk.new_count ?? hunk.new_lines ?? hunk.newCount ?? countDiffLines(lines, 'new');
+  return {
+    ...hunk,
+    old_start: hunk.old_start ?? hunk.oldStart ?? 1,
+    old_count: oldCount,
+    new_start: hunk.new_start ?? hunk.newStart ?? 1,
+    new_count: newCount,
+    lines,
+  };
+}
+
+function normalizeDiffLine(line) {
+  if (typeof line === 'string') return parseUnifiedLine(line);
+  if (!line || typeof line !== 'object') return null;
+  const rawType = String(line.type || line.kind || '').toLowerCase();
+  const text = String(line.text ?? line.content ?? line.value ?? '');
+  if (rawType === 'add' || rawType === 'added' || rawType === '+') return { ...line, type: 'add', text };
+  if (rawType === 'remove' || rawType === 'removed' || rawType === 'delete' || rawType === '-') return { ...line, type: 'remove', text };
+  if (rawType === 'context' || rawType === 'same' || rawType === ' ') return { ...line, type: 'context', text };
+  return parseUnifiedLine(text);
+}
+
+function parseDiffBody(body) {
+  return String(body || '')
+    .replace(/\r\n?/g, '\n')
+    .split('\n')
+    .filter(line => line && !line.startsWith('@@'))
+    .map(parseUnifiedLine)
+    .filter(Boolean);
+}
+
+function parseUnifiedHunks(unified) {
+  const hunks = [];
+  let current = null;
+  for (const raw of String(unified || '').replace(/\r\n?/g, '\n').split('\n')) {
+    if (raw.startsWith('--- ') || raw.startsWith('+++ ')) continue;
+    const header = raw.match(/^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@/);
+    if (header) {
+      current = {
+        old_start: Number(header[1]) || 1,
+        old_count: Number(header[2] || 1),
+        new_start: Number(header[3]) || 1,
+        new_count: Number(header[4] || 1),
+        lines: [],
+      };
+      hunks.push(current);
+      continue;
+    }
+    if (!current) {
+      if (!raw || (!raw.startsWith('+') && !raw.startsWith('-') && !raw.startsWith(' '))) continue;
+      current = { old_start: 1, old_count: 0, new_start: 1, new_count: 0, lines: [] };
+      hunks.push(current);
+    }
+    const line = parseUnifiedLine(raw);
+    if (line) current.lines.push(line);
+  }
+  for (const hunk of hunks) {
+    if (!hunk.old_count) hunk.old_count = countDiffLines(hunk.lines, 'old');
+    if (!hunk.new_count) hunk.new_count = countDiffLines(hunk.lines, 'new');
+  }
+  return hunks.filter(hunk => hunk.lines.length);
+}
+
+function parseUnifiedLine(raw) {
+  const line = String(raw ?? '');
+  if (!line && raw !== '') return null;
+  if (line.startsWith('+') && !line.startsWith('+++')) return { type: 'add', text: line.slice(1) };
+  if (line.startsWith('-') && !line.startsWith('---')) return { type: 'remove', text: line.slice(1) };
+  if (line.startsWith(' ')) return { type: 'context', text: line.slice(1) };
+  return { type: 'context', text: line };
+}
+
+function countDiffLines(lines, side) {
+  return lines.filter(line => {
+    if (side === 'old') return line.type !== 'add';
+    return line.type !== 'remove';
+  }).length;
+}
+
 function paintDiffLine(line, maxWidth) {
   const text = truncatePlain(String(line?.text ?? ''), Math.max(20, maxWidth - 2));
   if (line?.type === 'add') return paint.state.success(`+ ${text}`);
@@ -303,20 +471,41 @@ function tone(text, t) {
 export function formatCardHead(tool, args, opts = {}) {
   const cwd = opts.cwd || safeCwd();
   const cols = opts.columns || term().columns || 120;
-  const indent = opts.indent || '  ';
+  const indent = opts.indent ?? (tool === 'shell' ? '' : '  ');
 
   const label     = toolDisplayLabel(tool);
   const argsText  = formatArgs(tool, args, cwd);
+  const leadText  = formatHeadLead(tool, label);
 
-  const leadVisible = visibleWidth(`${indent}${label}`);
+  const leadVisible = visibleWidth(`${indent}${leadText}`);
   const budget = Math.max(20, cols - leadVisible - 4);
 
+  if (tool === 'shell') {
+    const profile = shellCommandProfile(toolDisplaySummary(tool, args || {}, { cwd }), { cwd });
+    if (profile.compact) {
+      const head = `${indent}${leadText}`;
+      if (profile.preview) {
+        const fullArgs = compactShellProfile(profile);
+        if (visibleWidth(fullArgs) <= budget) return `${head} ${fullArgs}`;
+        const previewTail = `${paint.text.dim(' · preview:')} ${paint.text.primary(profile.preview)}`;
+        const baseArgs = compactShellProfile(profile, { includePreview: false, includeDetails: false });
+        const baseBudget = budget - visibleWidth(previewTail);
+        if (baseBudget >= 12) {
+          const baseTruncated = truncateEndVisible(baseArgs, baseBudget);
+          return `${head} ${baseTruncated}${previewTail}`;
+        }
+      }
+      const argsTruncated = truncateMiddle(argsText, budget);
+      return argsTruncated ? `${head} ${argsTruncated}` : head;
+    }
+  }
+
   if (tool === 'shell' && visibleWidth(argsText) > budget) {
     const wrapWidth = Math.max(32, cols - visibleWidth(indent) - 4);
     const display = shellCommandDisplay(toolDisplaySummary(tool, args || {}, { cwd }), { cwd });
     const commandLines = wrapCommand(display.command, wrapWidth)
-      .map(line => `${indent}${paint.text.dim('  ')}${formatShellCommand(line, paintShellAdapter)}`);
-    const head = `${indent}${paintLabel(tool, label)}`;
+      .map((line, index) => `${indent}${paint.text.dim(index === 0 ? '$ ' : '> ')}${formatShellCommand(line, paintShellAdapter)}`);
+    const head = `${indent}${leadText}`;
     const cwdLine = display.cwdLabel
       ? `\n${indent}${paint.text.dim('  in ')}${paint.brand.data(display.cwdLabel)}`
       : '';
@@ -325,10 +514,27 @@ export function formatCardHead(tool, args, opts = {}) {
 
   const argsTruncated = truncateMiddle(argsText, budget);
 
-  const head = `${indent}${paintLabel(tool, label)}`;
+  const head = `${indent}${leadText}`;
   return argsTruncated ? `${head} ${argsTruncated}` : head;
 }
 
+function formatHeadLead(tool, label) {
+  if (tool !== 'shell') return paintLabel(tool, label);
+  return `${paint.text.dim('• shell ·')} ${paintLabel(tool, label)}`;
+}
+
+function compactShellProfile(profile, { includePreview = true, includeDetails = true } = {}) {
+  const previewSuffix = profile.preview ? ` · preview: ${profile.preview}` : '';
+  const summary = previewSuffix && profile.summary.endsWith(previewSuffix)
+    ? profile.summary.slice(0, -previewSuffix.length)
+    : profile.summary;
+  const parts = [`${paint.text.dim('$')} ${paint.text.primary(summary)}`];
+  if (profile.cwdLabel) parts.push(`${paint.text.dim('in')} ${paint.brand.data(profile.cwdLabel)}`);
+  if (includeDetails) parts.push(paint.text.dim(profile.detailHint || 'details: F2 or /last'));
+  if (includePreview && profile.preview) parts.push(`${paint.text.dim('preview:')} ${paint.text.primary(profile.preview)}`);
+  return parts.join(' · ');
+}
+
 /**
  * Render a full card with outcome.
  *
@@ -346,7 +552,7 @@ export function formatCard({ tool, args, result, durationMs, indent, columns, cw
 
   if (!summary.text && !duration) return head;
 
-  const arrow = paint.text.dim('—');
+  const arrow = outcomeLead(tool);
   const body  = summary.text ? tone(summary.text, summary.tone) : '';
   // Hide the duration tail when the tool was effectively instant (<200ms).
   // For fast reads, "1ms" / "0ms" was noise that broke the prose feel.
@@ -374,6 +580,19 @@ export function formatCard({ tool, args, result, durationMs, indent, columns, cw
   return `${head}\n${gutterIndent}${arrow} ${body}${tail}`;
 }
 
+function outcomeLead(tool) {
+  return isShellOutcomeTool(tool)
+    ? `${paint.text.dim('result')} ${paint.text.dim('—')}`
+    : paint.text.dim('—');
+}
+
+function isShellOutcomeTool(tool) {
+  return [
+    'shell', 'run_tests', 'validate_build', 'lint_check',
+    'validate_file', 'validate_structure',
+  ].includes(String(tool || '').toLowerCase());
+}
+
 function isInlineOutcomeTool(tool) {
   return [
     'read_file', 'read_files', 'read_batch', 'get_file_info',
@@ -393,26 +612,38 @@ function truncateMiddle(text, max) {
   return paint.text.muted(`${head}…${tail}`);
 }
 
+function truncateEndVisible(text, max) {
+  if (!text) return '';
+  if (visibleWidth(text) <= max) return text;
+  const plain = text.replace(/\x1b\[[0-9;]*m/g, '');
+  const limit = Math.max(1, Math.floor(max));
+  if (limit <= 1) return '';
+  return paint.text.muted(`${plain.slice(0, limit - 1)}…`);
+}
+
 function wrapCommand(command, width) {
   const text = String(command || '');
   if (!text) return ['(empty command)'];
   const lines = [];
-  let line = '';
-  for (const token of text.match(/\S+\s*/g) || [text]) {
-    const next = line + token;
-    if (line && visibleWidth(next.trimEnd()) > width) {
-      lines.push(line.trimEnd());
-      line = token;
-      continue;
-    }
-    if (!line && visibleWidth(token.trimEnd()) > width) {
-      lines.push(...chunkLongToken(token.trimEnd(), width));
-      line = '';
-      continue;
+  for (const physicalLine of text.replace(/\r\n?/g, '\n').split('\n')) {
+    let line = '';
+    for (const token of physicalLine.match(/\S+\s*/g) || [physicalLine]) {
+      const next = line + token;
+      if (line && visibleWidth(next.trimEnd()) > width) {
+        lines.push(line.trimEnd());
+        line = token;
+        continue;
+      }
+      if (!line && visibleWidth(token.trimEnd()) > width) {
+        lines.push(...chunkLongToken(token.trimEnd(), width));
+        line = '';
+        continue;
+      }
+      line = next;
     }
-    line = next;
+    if (line.trimEnd()) lines.push(line.trimEnd());
+    else if (!physicalLine.trim()) lines.push('');
   }
-  if (line.trimEnd()) lines.push(line.trimEnd());
   return lines.length ? lines : ['(empty command)'];
 }