ethagent 3.3.4 → 4.0.0

package/src/chat/display/DiffView.tsx

@@ -1,193 +0,0 @@
-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

@@ -1,192 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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
-}