ethagent 2.2.0 → 2.3.0

package/src/chat/commands.ts

@@ -132,9 +132,9 @@ const COMMANDS: CommandSpec[] = [
       try {
         const next = setCwd(target, ctx.cwd)
         ctx.onChangeCwd(next)
-        return { kind: 'note', text: `cwd: ${next}`, variant: 'dim' }
+        return { kind: 'note', text: `Cwd: ${next}`, variant: 'dim' }
       } catch (err: unknown) {
-        return { kind: 'note', variant: 'error', text: `cd failed: ${(err as Error).message}` }
+        return { kind: 'note', variant: 'error', text: `Cd failed: ${(err as Error).message}` }
       }
     },
   },
@@ -200,7 +200,7 @@ const COMMANDS: CommandSpec[] = [
           return {
             kind: 'note',
             variant: 'error',
-            text: `'${name}' was not found for ${ctx.config.provider}. use /models to inspect available models.`,
+            text: `'${name}' was not found for ${providerDisplayName(ctx.config.provider)}. use /models to inspect available models.`,
           }
         }
       }
@@ -244,12 +244,12 @@ const COMMANDS: CommandSpec[] = [
       }
       const result = await rewindWorkspaceEdits(ctx.cwd, steps)
       if (result.reverted === 0) {
-        return { kind: 'note', variant: 'error', text: 'no managed edits available to rewind in this directory.' }
+        return { kind: 'note', variant: 'error', text: 'No managed edits available to rewind in this directory.' }
       }
       const files = result.files.map(file => path.relative(ctx.cwd, file) || path.basename(file))
       return {
         kind: 'note',
-        text: `rewound ${result.reverted} edit${result.reverted === 1 ? '' : 's'}.\n${files.join('\n')}`,
+        text: `Rewound ${result.reverted} edit${result.reverted === 1 ? '' : 's'}.\n${files.join('\n')}`,
         variant: 'dim',
       }
     },
@@ -276,7 +276,7 @@ const COMMANDS: CommandSpec[] = [
     run: async (args, ctx) => {
       const assistant = ctx.assistantTurns()
       if (assistant.length === 0) {
-        return { kind: 'note', variant: 'error', text: 'nothing to copy yet.' }
+        return { kind: 'note', variant: 'error', text: 'Nothing to copy yet.' }
       }
       let offset = 1
       const trimmed = args.trim()
@@ -289,17 +289,17 @@ const COMMANDS: CommandSpec[] = [
       }
       const index = assistant.length - offset
       if (index < 0) {
-        return { kind: 'note', variant: 'error', text: `only ${assistant.length} assistant reply on record.` }
+        return { kind: 'note', variant: 'error', text: `Only ${assistant.length} assistant reply on record.` }
       }
       const text = assistant[index] ?? ''
-      const label = offset === 1 ? 'latest reply' : `reply #${offset} back`
+      const label = offset === 1 ? 'Latest reply' : `Reply #${offset} back`
       const segments = parseSegments(text)
       if (segments.length <= 1) {
         const result = await copyToClipboard(text)
         if (!result.ok) {
-          return { kind: 'note', variant: 'error', text: `copy failed: ${result.error}` }
+          return { kind: 'note', variant: 'error', text: `Copy failed: ${result.error}` }
         }
-        return { kind: 'note', text: `copied ${text.length} chars via ${result.method}.`, variant: 'dim' }
+        return { kind: 'note', text: `${label} copied to clipboard · ${result.chars} chars`, variant: 'dim' }
       }
       ctx.onCopyPickerRequest(text, label)
       return { kind: 'handled' }
@@ -312,16 +312,16 @@ const COMMANDS: CommandSpec[] = [
     run: async (_args, ctx) => {
       const messages = ctx.sessionMessages()
       if (messages.length === 0) {
-        return { kind: 'note', variant: 'error', text: 'nothing to export yet.' }
+        return { kind: 'note', variant: 'error', text: 'Nothing to export yet.' }
       }
       try {
         const file = await exportSessionMarkdown(ctx.sessionId, messages, {
           model: ctx.config.model,
           provider: ctx.config.provider,
         })
-        return { kind: 'note', text: `exported to ${file}` }
+        return { kind: 'note', text: `Exported to ${file}` }
       } catch (err: unknown) {
-        return { kind: 'note', variant: 'error', text: `export failed: ${(err as Error).message}` }
+        return { kind: 'note', variant: 'error', text: `Export failed: ${(err as Error).message}` }
       }
     },
   },
@@ -437,7 +437,7 @@ async function runMcp(args: string, ctx: SlashContext): Promise<SlashResult> {
       return { kind: 'note', text: await ctx.mcp.addJson(name, json, project ? 'project' : 'user'), variant: 'dim' }
     }
   } catch (err: unknown) {
-    return { kind: 'note', variant: 'error', text: `mcp failed: ${(err as Error).message}` }
+    return { kind: 'note', variant: 'error', text: `MCP failed: ${(err as Error).message}` }
   }
 
   return {
@@ -463,7 +463,7 @@ async function runIdentity(args: string, ctx: SlashContext): Promise<SlashResult
       return {
         kind: 'note',
         variant: 'dim',
-        text: 'no Ethereum identity set. run /identity create to make one.',
+        text: 'No Ethereum identity set. Run /identity create to make one.',
       }
     }
     const lines = [
@@ -491,16 +491,16 @@ async function runIdentity(args: string, ctx: SlashContext): Promise<SlashResult
       return {
         kind: 'note',
         variant: 'error',
-        text: 'remove deletes local identity metadata and any legacy stored key. re-run with: /identity remove confirm',
+        text: 'Remove deletes local identity metadata and any legacy stored key. Re-run with: /identity remove confirm',
       }
     }
     const status = await getIdentityStatus(ctx.config)
     if (!status) {
-      return { kind: 'note', variant: 'dim', text: 'no Ethereum identity to remove.' }
+      return { kind: 'note', variant: 'dim', text: 'No Ethereum identity to remove.' }
     }
     const next = await clearIdentity(ctx.config)
     ctx.onReplaceConfig(next)
-    return { kind: 'note', text: `removed identity ${status.address}.`, variant: 'dim' }
+    return { kind: 'note', text: `Removed identity ${status.address}.`, variant: 'dim' }
   }
 
   return {
@@ -537,7 +537,7 @@ function renderStatus(ctx: SlashContext): string {
   const elapsed = minutes > 0 ? `${minutes}m${seconds.toString().padStart(2, '0')}s` : `${seconds}s`
   const displayModel = formatModelDisplayName(ctx.config.provider, ctx.config.model, { maxLength: 72 })
   return [
-    `provider   ${ctx.config.provider}`,
+    `provider   ${providerDisplayName(ctx.config.provider)}`,
     `model      ${displayModel}`,
     `cwd        ${ctx.cwd}`,
     `session    ${ctx.sessionId.slice(0, 8)}`,
@@ -560,7 +560,7 @@ function renderContext(ctx: SlashContext): string {
         : 'Context has comfortable room.'
   return [
     'context usage:',
-    `  model      ${ctx.config.provider} · ${formatModelDisplayName(ctx.config.provider, ctx.config.model, { maxLength: 72 })}`,
+    `  model      ${providerDisplayName(ctx.config.provider)} · ${formatModelDisplayName(ctx.config.provider, ctx.config.model, { maxLength: 72 })}`,
     `  used       ~${usage.usedTokens} / ${usage.windowTokens} tokens (${usage.percent}%)`,
     `  free       ~${free} tokens`,
     `  estimate   ${usage.confidence} (${usage.source})`,
@@ -585,7 +585,7 @@ function renderDoctor(
   lines.push(`  hf models  ${hfModelCount} downloaded`)
   lines.push('')
   lines.push('config:')
-  lines.push(`  provider   ${ctx.config.provider}`)
+  lines.push(`  provider   ${providerDisplayName(ctx.config.provider)}`)
   lines.push(`  model      ${formatModelDisplayName(ctx.config.provider, ctx.config.model, { maxLength: 72 })}`)
   if (ctx.config.baseUrl) lines.push(`  baseUrl    ${ctx.config.baseUrl}`)
   if (ctx.config.provider === 'llamacpp') lines.push(`  hf cache   ${getLocalHfCacheDir()}`)
@@ -593,7 +593,7 @@ function renderDoctor(
   lines.push('')
   lines.push('keys:')
   for (const [provider, present] of keys) {
-    lines.push(`  ${provider.padEnd(9)}  ${present ? 'set' : 'not set'}`)
+    lines.push(`  ${providerDisplayName(provider).padEnd(9)}  ${present ? 'set' : 'not set'}`)
   }
   lines.push('')
   lines.push('identity:')
@@ -610,8 +610,8 @@ function renderDoctor(
 
 function renderModelCatalog(catalog: ModelCatalogResult, currentModel: string): string {
   const title = catalog.status === 'fallback'
-    ? `${catalog.provider} models (fallback${catalog.error ? `: ${catalog.error}` : ''}):`
-    : `${catalog.provider} models:`
+    ? `${providerDisplayName(catalog.provider)} models (fallback${catalog.error ? `: ${catalog.error}` : ''}):`
+    : `${providerDisplayName(catalog.provider)} models:`
   const lines = catalog.entries.map(entry => {
     const marker = entry.id === currentModel ? '*' : ' '
     const suffix = entry.source === 'fallback' ? '  fallback' : ''
@@ -649,9 +649,9 @@ export async function dispatchSlash(input: string, ctx: SlashContext): Promise<S
       const promptText = await ctx.mcp?.runPromptSlash(parsed.name, parsed.args)
       if (promptText !== null && promptText !== undefined) return { kind: 'submit', text: promptText }
     } catch (err: unknown) {
-      return { kind: 'note', variant: 'error', text: `mcp prompt failed: ${(err as Error).message}` }
+      return { kind: 'note', variant: 'error', text: `MCP prompt failed: ${(err as Error).message}` }
     }
-    return { kind: 'note', variant: 'error', text: `unknown command: /${parsed.name}. try /help` }
+    return { kind: 'note', variant: 'error', text: `Unknown command: /${parsed.name}. Try /help` }
   }
   if (ctx.mode === 'plan' && cmd.blockedInPlan) {
     return { kind: 'note', variant: 'error', text: `/${cmd.name} is blocked in plan mode.` }

package/src/chat/display/DiffView.tsx

@@ -0,0 +1,193 @@
+import React from 'react'
+import { Box, Text } from 'ink'
+import { theme } from '../../ui/theme.js'
+import { inferLanguageFromPath, SyntaxLine } from './SyntaxText.js'
+
+const EMPTY_DIFF_LINE = ' '
+
+type DiffLineTone = 'added' | 'removed' | 'added-header' | 'removed-header' | 'hunk' | 'context' | 'marker'
+
+type DiffLineStyle = {
+  tone: DiffLineTone
+  color: string
+  backgroundColor?: string
+}
+
+type NumberedDiffLine = {
+  line: string
+  oldLine?: number
+  newLine?: number
+}
+
+export function diffLineColor(line: string): string {
+  return diffLineStyle(line).color
+}
+
+export function diffLineStyle(line: string): DiffLineStyle {
+  if (line.startsWith('+++')) return { tone: 'added-header', color: theme.diffAdded }
+  if (line.startsWith('---')) return { tone: 'removed-header', color: theme.diffRemoved }
+  if (line.startsWith('+')) {
+    return { tone: 'added', color: theme.text, backgroundColor: theme.diffAddedBackground }
+  }
+  if (line.startsWith('-')) {
+    return { tone: 'removed', color: theme.text, backgroundColor: theme.diffRemovedBackground }
+  }
+  if (line.startsWith('@@')) return { tone: 'hunk', color: theme.accentPeriwinkle }
+  if (line.startsWith('...')) return { tone: 'marker', color: theme.dim }
+  return { tone: 'context', color: theme.textSubtle }
+}
+
+export const DiffView: React.FC<{ diff: string }> = ({ diff }) => (
+  <DiffLines lines={visibleDiffLines(numberDiffLines(diff))} language={inferDiffLanguage(diff)} />
+)
+
+const DiffLines: React.FC<{ lines: NumberedDiffLine[]; language: string | null }> = ({ lines, language }) => {
+  const width = lineNumberWidth(lines)
+  return (
+    <Box flexDirection="column">
+      {lines.map((line, index) => (
+        <DiffLine
+          key={index}
+          line={line.line}
+          oldLine={line.oldLine}
+          newLine={line.newLine}
+          width={width}
+          language={language}
+        />
+      ))}
+    </Box>
+  )
+}
+
+const DiffLine: React.FC<{
+  line: string
+  oldLine?: number
+  newLine?: number
+  width: number
+  language: string | null
+}> = ({
+  line,
+  oldLine,
+  newLine,
+  width,
+  language,
+}) => {
+  const style = diffLineStyle(line)
+  const number = renderLineNumber(displayLineNumber(oldLine, newLine, style.tone), width)
+  if (line.length === 0) {
+    return <Text color={style.color}>{EMPTY_DIFF_LINE}</Text>
+  }
+
+  if (style.tone === 'added' || style.tone === 'removed') {
+    const prefixColor = style.tone === 'added' ? theme.diffAdded : theme.diffRemoved
+    return (
+      <Box width="100%" backgroundColor={style.backgroundColor}>
+        <Text>
+          {number}
+          <Text color={prefixColor}>{line.slice(0, 1)} </Text>
+          <SyntaxLine line={line.slice(1)} lang={language} fallbackColor={style.color} />
+        </Text>
+      </Box>
+    )
+  }
+
+  if (style.tone === 'context' && line.startsWith(' ')) {
+    return (
+      <Text color={style.color}>
+        {number}
+        <Text>{' '}</Text>
+        <SyntaxLine line={line.slice(1)} lang={language} fallbackColor={style.color} />
+      </Text>
+    )
+  }
+
+  return <Text color={style.color}>{line}</Text>
+}
+
+function lineNumberWidth(lines: NumberedDiffLine[]): number {
+  return Math.max(
+    2,
+    ...lines.map(line => String(displayLineNumber(line.oldLine, line.newLine, diffLineStyle(line.line).tone) ?? '').length),
+  )
+}
+
+function displayLineNumber(
+  oldLine: number | undefined,
+  newLine: number | undefined,
+  tone: DiffLineTone,
+): number | undefined {
+  if (tone === 'removed') return oldLine
+  return newLine ?? oldLine
+}
+
+function renderLineNumber(line: number | undefined, width: number): React.ReactNode {
+  if (line === undefined) return null
+  return <Text color={theme.dim}>{String(line).padStart(width, ' ')} </Text>
+}
+
+function visibleDiffLines(lines: NumberedDiffLine[]): NumberedDiffLine[] {
+  return lines.filter(line => {
+    const tone = diffLineStyle(line.line).tone
+    return tone !== 'added-header' && tone !== 'removed-header' && tone !== 'hunk'
+  })
+}
+
+function inferDiffLanguage(diff: string): string | null {
+  for (const line of diff.split('\n')) {
+    if (!line.startsWith('+++ ') || line === '+++ /dev/null') continue
+    return inferLanguageFromPath(line.slice(4).trim())
+  }
+  for (const line of diff.split('\n')) {
+    if (!line.startsWith('--- ') || line === '--- /dev/null') continue
+    return inferLanguageFromPath(line.slice(4).trim())
+  }
+  return null
+}
+
+export function numberDiffLines(diff: string): NumberedDiffLine[] {
+  const out: NumberedDiffLine[] = []
+  let oldLine: number | undefined
+  let newLine: number | undefined
+
+  for (const line of diff.split('\n')) {
+    const hunk = parseHunkHeader(line)
+    if (hunk) {
+      oldLine = hunk.oldStart
+      newLine = hunk.newStart
+      out.push({ line })
+      continue
+    }
+
+    if (oldLine !== undefined && newLine !== undefined) {
+      if (line.startsWith(' ')) {
+        out.push({ line, oldLine, newLine })
+        oldLine += 1
+        newLine += 1
+        continue
+      }
+      if (line.startsWith('-') && !line.startsWith('---')) {
+        out.push({ line, oldLine })
+        oldLine += 1
+        continue
+      }
+      if (line.startsWith('+') && !line.startsWith('+++')) {
+        out.push({ line, newLine })
+        newLine += 1
+        continue
+      }
+    }
+
+    out.push({ line })
+  }
+
+  return out
+}
+
+function parseHunkHeader(line: string): { oldStart: number; newStart: number } | null {
+  const match = line.match(/^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/)
+  if (!match) return null
+  return {
+    oldStart: Number(match[1]),
+    newStart: Number(match[2]),
+  }
+}

package/src/chat/display/SyntaxText.tsx

@@ -0,0 +1,192 @@
+import React from 'react'
+import { Text } from 'ink'
+import { styledCharsFromTokens, tokenize } from '@alcalzone/ansi-tokenize'
+import { highlight, supportsLanguage, type Theme } from 'cli-highlight'
+import { theme } from '../../ui/theme.js'
+
+type Span = {
+  text: string
+  color?: string
+  bold?: boolean
+  italic?: boolean
+}
+
+const ANSI_RESET_FG = '\x1B[39m'
+const ANSI_RESET_BOLD = '\x1B[22m'
+const ANSI_RESET_ITALIC = '\x1B[23m'
+
+const HIGHLIGHT_THEME: Theme = {
+  keyword: style(theme.codeKeyword, { bold: true }),
+  built_in: style(theme.codeBuiltin),
+  type: style(theme.codeType),
+  literal: style(theme.codeKeyword),
+  number: style(theme.codeNumber),
+  regexp: style(theme.codeString),
+  string: style(theme.codeString),
+  class: style(theme.codeType),
+  function: style(theme.codeFunction),
+  title: style(theme.codeFunction),
+  comment: style(theme.codeComment, { italic: true }),
+  doctag: style(theme.codeComment, { italic: true }),
+  meta: style(theme.dim),
+  tag: style(theme.codeTag, { bold: true }),
+  name: style(theme.codeTag, { bold: true }),
+  attr: style(theme.codeAttribute),
+  attribute: style(theme.codeProperty),
+  variable: style(theme.codeProperty),
+  addition: style(theme.diffAdded),
+  deletion: style(theme.diffRemoved),
+  default: style(theme.textSubtle),
+}
+
+const PROGRAMMING_LANGUAGES = new Set([
+  'bash',
+  'css',
+  'go',
+  'java',
+  'javascript',
+  'json',
+  'python',
+  'rust',
+  'solidity',
+  'sql',
+  'typescript',
+  'xml',
+  'yaml',
+])
+
+const LANGUAGE_BY_EXTENSION: Record<string, string> = {
+  cjs: 'javascript',
+  css: 'css',
+  html: 'xml',
+  js: 'javascript',
+  json: 'json',
+  jsonc: 'json',
+  jsx: 'javascript',
+  md: 'markdown',
+  mjs: 'javascript',
+  py: 'python',
+  sh: 'bash',
+  ts: 'typescript',
+  tsx: 'typescript',
+  yml: 'yaml',
+  yaml: 'yaml',
+}
+
+export const SyntaxLine: React.FC<{ line: string; lang?: string | null; fallbackColor?: string }> = ({
+  line,
+  lang,
+  fallbackColor = theme.textSubtle,
+}) => (
+  <>
+    {syntaxLineSpans(line, lang, fallbackColor).map((span, index) => (
+      <Text key={index} color={span.color} bold={span.bold} italic={span.italic}>
+        {span.text}
+      </Text>
+    ))}
+  </>
+)
+
+export function syntaxLineSpans(line: string, lang?: string | null, fallbackColor: string = theme.textSubtle): Span[] {
+  const code = line.length === 0 ? ' ' : line
+  const language = supportedLanguage(lang)
+  if (!language || !PROGRAMMING_LANGUAGES.has(language)) {
+    return [{ text: code, color: fallbackColor }]
+  }
+  const highlighted = highlight(code, {
+    language: language ?? undefined,
+    ignoreIllegals: true,
+    theme: HIGHLIGHT_THEME,
+  })
+  const spans = spansFromAnsi(highlighted)
+  return spans.length > 0 ? spans : [{ text: code, color: fallbackColor }]
+}
+
+export function inferLanguageFromPath(path: string): string | null {
+  const clean = path
+    .replace(/^["']|["']$/g, '')
+    .replace(/^[ab]\//, '')
+    .replace(/\\/g, '/')
+    .split('/')
+    .pop()
+  const extension = clean?.match(/\.([A-Za-z0-9]+)$/)?.[1]?.toLowerCase()
+  return extension ? LANGUAGE_BY_EXTENSION[extension] ?? null : null
+}
+
+function supportedLanguage(lang?: string | null): string | null {
+  if (!lang) return null
+  const normalized = LANGUAGE_BY_EXTENSION[lang.toLowerCase()] ?? lang.toLowerCase()
+  return supportsLanguage(normalized) ? normalized : null
+}
+
+function style(color: string, options: { bold?: boolean; italic?: boolean } = {}): (text: string) => string {
+  return text => [
+    colorCode(color),
+    options.bold ? '\x1B[1m' : '',
+    options.italic ? '\x1B[3m' : '',
+    text,
+    options.italic ? ANSI_RESET_ITALIC : '',
+    options.bold ? ANSI_RESET_BOLD : '',
+    ANSI_RESET_FG,
+  ].join('')
+}
+
+function colorCode(hex: string): string {
+  const [r, g, b] = parseHexColor(hex)
+  return `\x1B[38;2;${r};${g};${b}m`
+}
+
+function parseHexColor(hex: string): [number, number, number] {
+  const clean = hex.replace(/^#/, '')
+  return [
+    Number.parseInt(clean.slice(0, 2), 16),
+    Number.parseInt(clean.slice(2, 4), 16),
+    Number.parseInt(clean.slice(4, 6), 16),
+  ]
+}
+
+function spansFromAnsi(value: string): Span[] {
+  const chars = styledCharsFromTokens(tokenize(value))
+  const spans: Span[] = []
+  for (const char of chars) {
+    const span = spanFromCodes(char.value, char.styles.map(styleCode => styleCode.code))
+    const previous = spans[spans.length - 1]
+    if (previous && sameStyle(previous, span)) {
+      previous.text += span.text
+    } else {
+      spans.push(span)
+    }
+  }
+  return spans
+}
+
+function spanFromCodes(text: string, codes: string[]): Span {
+  return {
+    text,
+    color: colorFromCodes(codes),
+    bold: codes.includes('\x1B[1m') || undefined,
+    italic: codes.includes('\x1B[3m') || undefined,
+  }
+}
+
+function colorFromCodes(codes: string[]): string | undefined {
+  for (let index = codes.length - 1; index >= 0; index -= 1) {
+    const match = codes[index]?.match(/\x1B\[38;2;(\d+);(\d+);(\d+)m/)
+    if (match) {
+      return rgbToHex(Number(match[1]), Number(match[2]), Number(match[3]))
+    }
+  }
+  return undefined
+}
+
+function rgbToHex(r: number, g: number, b: number): string {
+  return `#${hexByte(r)}${hexByte(g)}${hexByte(b)}`
+}
+
+function hexByte(value: number): string {
+  return Math.max(0, Math.min(255, value)).toString(16).padStart(2, '0')
+}
+
+function sameStyle(a: Span, b: Span): boolean {
+  return a.color === b.color && a.bold === b.bold && a.italic === b.italic
+}

package/src/chat/display/toolCallDisplay.ts

@@ -0,0 +1,103 @@
+const MAX_ARG_SUMMARY = 80
+
+export function formatToolCall(
+  name: string,
+  input: Record<string, unknown> | undefined,
+): { displayName: string; argSummary: string } {
+  const safeInput = isRecord(input) ? input : {}
+  switch (name) {
+    case 'read_file':
+      return { displayName: 'Read', argSummary: readArgs(safeInput) }
+    case 'list_directory':
+      return { displayName: 'List', argSummary: pathArg(safeInput, '.') }
+    case 'run_bash':
+      return { displayName: 'Bash', argSummary: bashArgs(safeInput) }
+    case 'edit_file':
+      return { displayName: 'Edit', argSummary: pathArg(safeInput) }
+    case 'write_file':
+      return { displayName: 'Write', argSummary: pathArg(safeInput) }
+    case 'delete_file':
+      return { displayName: 'Delete', argSummary: pathArg(safeInput) }
+    case 'change_directory':
+      return { displayName: 'Cd', argSummary: pathArg(safeInput) }
+    case 'read_private_continuity_file':
+      return { displayName: 'ReadPrivate', argSummary: privateArgs(safeInput) }
+    case 'propose_private_continuity_edit':
+      return { displayName: 'EditPrivate', argSummary: stringArg(safeInput, 'file') }
+    case 'list_mcp_resources':
+      return { displayName: 'ListMcp', argSummary: stringArg(safeInput, 'server') }
+    case 'read_mcp_resource':
+      return { displayName: 'ReadMcp', argSummary: mcpReadArgs(safeInput) }
+    default:
+      return { displayName: humanize(name), argSummary: '' }
+  }
+}
+
+function readArgs(input: Record<string, unknown>): string {
+  const filePath = pathArg(input)
+  const start = numberArg(input, 'startLine')
+  const end = numberArg(input, 'endLine')
+  if (start || end) {
+    const range = `lines ${start ?? 1}-${end ?? 'end'}`
+    return truncate(filePath ? `${filePath} · ${range}` : range)
+  }
+  return truncate(filePath)
+}
+
+function privateArgs(input: Record<string, unknown>): string {
+  const file = stringArg(input, 'file')
+  const start = numberArg(input, 'startLine')
+  const end = numberArg(input, 'endLine')
+  if (start || end) {
+    return truncate(`${file} · lines ${start ?? 1}-${end ?? 'end'}`)
+  }
+  return truncate(file)
+}
+
+function bashArgs(input: Record<string, unknown>): string {
+  const command = stringArg(input, 'command')
+  if (!command) return ''
+  const firstLine = command.split('\n')[0]?.trim() ?? ''
+  return truncate(firstLine)
+}
+
+function mcpReadArgs(input: Record<string, unknown>): string {
+  const server = stringArg(input, 'server')
+  const uri = stringArg(input, 'uri')
+  if (server && uri) return truncate(`${server} / ${uri}`)
+  return truncate(server || uri)
+}
+
+function pathArg(input: Record<string, unknown>, fallback = ''): string {
+  const raw = stringArg(input, 'path')
+  if (!raw) return fallback
+  return raw.replace(/\\/g, '/')
+}
+
+function stringArg(input: Record<string, unknown>, key: string): string {
+  const value = input[key]
+  return typeof value === 'string' ? value : ''
+}
+
+function numberArg(input: Record<string, unknown>, key: string): number | undefined {
+  const value = input[key]
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined
+}
+
+function truncate(text: string): string {
+  const flat = text.replace(/\s+/g, ' ').trim()
+  if (flat.length <= MAX_ARG_SUMMARY) return flat
+  return `${flat.slice(0, MAX_ARG_SUMMARY - 1)}…`
+}
+
+function humanize(name: string): string {
+  return name
+    .split('_')
+    .filter(part => part.length > 0)
+    .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+    .join('')
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}

package/src/chat/display/toolResultDisplay.ts

@@ -0,0 +1,19 @@
+import { splitFileChangeResult } from '../../tools/fileDiff.js'
+
+const COMPACT_SUCCESS_TOOL_RESULTS = new Set([
+  'read_file',
+  'read_private_continuity_file',
+])
+
+export function hidesSuccessfulToolResultContent(name: string, isError?: boolean): boolean {
+  return !isError && COMPACT_SUCCESS_TOOL_RESULTS.has(name)
+}
+
+export function toolResultDiffContent(content: string, isError?: boolean): string | undefined {
+  if (isError) return undefined
+  return splitFileChangeResult(content).diff
+}
+
+export function toolResultTextContent(content: string): string {
+  return splitFileChangeResult(content).content
+}