@bahulam/code 2.6.14 → 2.6.16

package/src/ui/tool-card.mjs

@@ -231,32 +231,47 @@ function summarizeJsonOutput(value) {
 
 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++;
       }
@@ -265,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');
 }
@@ -274,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}`);
@@ -365,8 +483,19 @@ export function formatCardHead(tool, args, opts = {}) {
   if (tool === 'shell') {
     const profile = shellCommandProfile(toolDisplaySummary(tool, args || {}, { cwd }), { cwd });
     if (profile.compact) {
-      const argsTruncated = truncateMiddle(argsText, budget);
       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;
     }
   }
@@ -394,10 +523,15 @@ function formatHeadLead(tool, label) {
   return `${paint.text.dim('• shell ·')} ${paintLabel(tool, label)}`;
 }
 
-function compactShellProfile(profile) {
-  const parts = [`${paint.text.dim('$')} ${paint.text.primary(profile.summary)}`];
+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)}`);
-  parts.push(paint.text.dim(profile.detailHint || 'details: F2 or /last'));
+  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(' · ');
 }
 
@@ -478,6 +612,15 @@ 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)'];

package/src/ui/tool-details.mjs

@@ -14,6 +14,7 @@
 import { paint } from './palette.mjs';
 import { icon, toolFamily } from './icons.mjs';
 import { shellCommandProfile, toolDisplayLabel, toolDisplaySummary } from '../terminal/tool-display.mjs';
+import { isSensitiveConfigPath } from '../core/safety.mjs';
 
 const MAX_DETAIL_LINES = 60;
 const MAX_SHELL_DETAIL_LINES = 220;
@@ -136,6 +137,12 @@ function safeDetailArgs(tool, args) {
   }
   if (tool === 'edit_file') {
     const next = { ...args };
+    if (isSensitiveConfigPath(next.file_path || next.path)) {
+      for (const key of ['search', 'replace', 'old_string', 'new_string']) {
+        if (typeof next[key] === 'string') next[key] = '[redacted]';
+      }
+      return next;
+    }
     for (const key of ['search', 'replace', 'old_string', 'new_string']) {
       if (typeof next[key] === 'string' && next[key].length > 80) {
         next[key] = `[${next[key].split('\n').length} lines omitted]`;
@@ -213,7 +220,16 @@ function detailListFiles(card) {
 // ── Write / edit ────────────────────────────────────────────────────────
 
 function detailEditFile(card) {
-  const diff = card.result?.file_diff?.unified || card.result?.diff || card.result?.patch || card.result?.output;
+  const redacted = redactedFileDiff(card.result?.file_diff)
+    || (isSensitiveConfigPath(card.args?.file_path || card.args?.path)
+      ? sensitiveFallbackDiff(card)
+      : null);
+  if (redacted) return renderRedactedDiff(redacted);
+
+  const diff = unifiedForFileDiff(card.result?.file_diff)
+    || card.result?.diff
+    || card.result?.patch
+    || card.result?.output;
   if (diff) return renderDiff(String(diff));
 
   const before = card.args?.search;
@@ -228,7 +244,13 @@ function detailEditFile(card) {
 }
 
 function detailWriteFile(card) {
-  const diff = card.result?.file_diff?.unified || card.result?.diff;
+  const redacted = redactedFileDiff(card.result?.file_diff)
+    || (isSensitiveConfigPath(card.args?.file_path || card.args?.path)
+      ? sensitiveFallbackDiff(card)
+      : null);
+  if (redacted) return renderRedactedDiff(redacted);
+
+  const diff = unifiedForFileDiff(card.result?.file_diff) || card.result?.diff;
   if (diff) return renderDiff(String(diff));
   const content = card.args?.content;
   if (!content) return paint.text.dim('    (no content)');
@@ -238,7 +260,12 @@ function detailWriteFile(card) {
 function detailWriteProject(card) {
   const diffs = card.result?.file_diffs || [];
   if (diffs.length) {
-    return renderDiff(diffs.map(diff => diff.unified).filter(Boolean).join('\n'));
+    return diffs.map(diff => {
+      const redacted = redactedFileDiff(diff);
+      if (redacted) return renderRedactedDiff(redacted);
+      const unified = unifiedForFileDiff(diff);
+      return unified ? renderDiff(unified) : '';
+    }).filter(Boolean).join('\n');
   }
   const files = card.args?.files || [];
   if (!files.length) return paint.text.dim('    (no files)');
@@ -249,6 +276,26 @@ function detailWriteProject(card) {
   }).join('\n');
 }
 
+function redactedFileDiff(diff) {
+  return diff?.redacted ? diff : null;
+}
+
+function sensitiveFallbackDiff(card) {
+  return {
+    relative_path: card.args?.file_path || card.args?.path || 'sensitive config',
+    lines_added: card.result?.lines_added,
+    lines_removed: card.result?.lines_removed,
+    redacted: true,
+  };
+}
+
+function renderRedactedDiff(diff = {}) {
+  const file = diff.relative_path || diff.path || 'sensitive config';
+  const add = diff.lines_added ?? 0;
+  const rem = diff.lines_removed ?? 0;
+  return `    ${paint.brand.primary(file)} ${paint.text.dim(`+${add} −${rem}`)}\n    ${paint.text.dim('diff redacted for sensitive config')}`;
+}
+
 function detailDeleteFile(card) {
   const p = card.args?.file_path || card.args?.path || '';
   return `    ${paint.state.danger('✗')} ${paint.text.primary(p)}`;
@@ -405,6 +452,52 @@ function renderDiff(text) {
   }).join('\n');
 }
 
+function unifiedForFileDiff(diff) {
+  if (!diff) return '';
+  if (diff.unified) return String(diff.unified);
+  const hunks = Array.isArray(diff.hunks) ? diff.hunks : [];
+  if (!hunks.length) return '';
+  const file = diff.relative_path || diff.path || 'file';
+  const out = [`--- a/${file}`, `+++ b/${file}`];
+  for (const hunk of hunks) {
+    const lines = hunkLines(hunk);
+    if (!lines.length) continue;
+    const oldCount = hunk.old_count ?? hunk.old_lines ?? countLinesForSide(lines, 'old');
+    const newCount = hunk.new_count ?? hunk.new_lines ?? countLinesForSide(lines, 'new');
+    out.push(`@@ -${hunk.old_start ?? 1},${oldCount} +${hunk.new_start ?? 1},${newCount} @@`);
+    for (const line of lines) out.push(toUnifiedLine(line));
+  }
+  return out.length > 2 ? out.join('\n') : '';
+}
+
+function hunkLines(hunk = {}) {
+  if (Array.isArray(hunk.lines)) return hunk.lines;
+  if (typeof hunk.body !== 'string') return [];
+  return hunk.body.replace(/\r\n?/g, '\n').split('\n').filter(line => line && !line.startsWith('@@'));
+}
+
+function toUnifiedLine(line) {
+  if (typeof line === 'string') {
+    if (line.startsWith('+') || line.startsWith('-') || line.startsWith(' ')) return line;
+    return ` ${line}`;
+  }
+  const type = String(line?.type || '').toLowerCase();
+  const text = String(line?.text ?? line?.content ?? '');
+  if (type === 'add' || type === 'added') return `+${text}`;
+  if (type === 'remove' || type === 'removed' || type === 'delete') return `-${text}`;
+  return ` ${text}`;
+}
+
+function countLinesForSide(lines, side) {
+  return lines.filter(line => {
+    const type = typeof line === 'string'
+      ? (line.startsWith('+') ? 'add' : line.startsWith('-') ? 'remove' : 'context')
+      : String(line?.type || 'context').toLowerCase();
+    if (side === 'old') return type !== 'add' && type !== 'added';
+    return type !== 'remove' && type !== 'removed' && type !== 'delete';
+  }).length;
+}
+
 function formatDuration(ms) {
   if (ms < 1000) return `${Math.round(ms)}ms`;
   return `${(ms / 1000).toFixed(1)}s`;