ethagent 2.2.0 → 2.3.0

package/src/tools/fileDiff.ts

@@ -0,0 +1,261 @@
+export const DEFAULT_DIFF_CONTEXT_LINES = 3
+export const DEFAULT_DIFF_MAX_CHARS = 2400
+export const FILE_DIFF_RESULT_MARKER = '\n\n<!-- ethagent:file-diff:v1 -->\n'
+
+type DiffOp =
+  | { type: 'equal'; line: string }
+  | { type: 'delete'; line: string }
+  | { type: 'insert'; line: string }
+
+type HunkRange = {
+  start: number
+  end: number
+}
+
+type RenderUnifiedFileDiffInput = {
+  filePath: string
+  before: string
+  after: string
+  contextLines?: number
+  maxChars?: number
+}
+
+const LARGE_DIFF_MATRIX_LIMIT = 500_000
+
+export function renderUnifiedFileDiff(input: RenderUnifiedFileDiffInput): string {
+  const contextLines = input.contextLines ?? DEFAULT_DIFF_CONTEXT_LINES
+  const maxChars = input.maxChars ?? DEFAULT_DIFF_MAX_CHARS
+  const header = [`--- ${input.filePath}`, `+++ ${input.filePath}`]
+
+  if (input.before === input.after) {
+    return header.concat('(no changes)').join('\n')
+  }
+
+  const beforeLines = normalizedLines(input.before)
+  const afterLines = normalizedLines(input.after)
+  const ops = buildLineDiff(beforeLines, afterLines)
+  const hunks = buildHunkRanges(ops, contextLines)
+
+  if (hunks.length === 0) {
+    return header.concat('(only line ending changes)').join('\n')
+  }
+
+  const lines = [...header]
+  for (const hunk of hunks) {
+    const oldStart = countOldLines(ops, 0, hunk.start) + 1
+    const newStart = countNewLines(ops, 0, hunk.start) + 1
+    const oldCount = countOldLines(ops, hunk.start, hunk.end)
+    const newCount = countNewLines(ops, hunk.start, hunk.end)
+    lines.push(`@@ -${formatRange(oldStart, oldCount)} +${formatRange(newStart, newCount)} @@`)
+    for (const op of ops.slice(hunk.start, hunk.end)) {
+      if (op.type === 'equal') lines.push(` ${op.line}`)
+      else if (op.type === 'delete') lines.push(`-${op.line}`)
+      else lines.push(`+${op.line}`)
+    }
+  }
+
+  return truncateDiff(lines, maxChars)
+}
+
+export function formatFileChangeResult(content: string, diff: string): string {
+  return `${content}${FILE_DIFF_RESULT_MARKER}${diff}`
+}
+
+export function splitFileChangeResult(content: string): { content: string; diff?: string } {
+  const markerIndex = content.indexOf(FILE_DIFF_RESULT_MARKER)
+  if (markerIndex === -1) return { content }
+  const diff = content.slice(markerIndex + FILE_DIFF_RESULT_MARKER.length).trimEnd()
+  return {
+    content: content.slice(0, markerIndex).trimEnd(),
+    diff: diff.length > 0 ? diff : undefined,
+  }
+}
+
+export function stripFileChangeResultDiff(content: string): string {
+  return splitFileChangeResult(content).content
+}
+
+export function computeLineDiffStats(before: string, after: string): { inserts: number; deletes: number } {
+  if (before === after) return { inserts: 0, deletes: 0 }
+  const beforeLines = normalizedLines(before)
+  const afterLines = normalizedLines(after)
+  const ops = buildLineDiff(beforeLines, afterLines)
+  let inserts = 0
+  let deletes = 0
+  for (const op of ops) {
+    if (op.type === 'insert') inserts += 1
+    else if (op.type === 'delete') deletes += 1
+  }
+  return { inserts, deletes }
+}
+
+function buildLineDiff(beforeLines: string[], afterLines: string[]): DiffOp[] {
+  if (beforeLines.length * afterLines.length > LARGE_DIFF_MATRIX_LIMIT) {
+    return buildPrefixSuffixDiff(beforeLines, afterLines)
+  }
+
+  const lengths = lcsLengths(beforeLines, afterLines)
+  const ops: DiffOp[] = []
+  let beforeIndex = 0
+  let afterIndex = 0
+
+  while (beforeIndex < beforeLines.length && afterIndex < afterLines.length) {
+    const beforeLine = beforeLines[beforeIndex]!
+    const afterLine = afterLines[afterIndex]!
+    if (beforeLine === afterLine) {
+      ops.push({ type: 'equal', line: beforeLine })
+      beforeIndex += 1
+      afterIndex += 1
+      continue
+    }
+
+    const deleteScore = lengths[beforeIndex + 1]![afterIndex]!
+    const insertScore = lengths[beforeIndex]![afterIndex + 1]!
+    const deleteRevealsMatch = beforeLines[beforeIndex + 1] === afterLine
+    const insertRevealsMatch = beforeLine === afterLines[afterIndex + 1]
+
+    if (insertRevealsMatch && insertScore >= deleteScore) {
+      ops.push({ type: 'insert', line: afterLine })
+      afterIndex += 1
+    } else if (deleteRevealsMatch && deleteScore >= insertScore) {
+      ops.push({ type: 'delete', line: beforeLine })
+      beforeIndex += 1
+    } else if (deleteScore >= insertScore) {
+      ops.push({ type: 'delete', line: beforeLine })
+      beforeIndex += 1
+    } else {
+      ops.push({ type: 'insert', line: afterLine })
+      afterIndex += 1
+    }
+  }
+
+  while (beforeIndex < beforeLines.length) {
+    ops.push({ type: 'delete', line: beforeLines[beforeIndex]! })
+    beforeIndex += 1
+  }
+  while (afterIndex < afterLines.length) {
+    ops.push({ type: 'insert', line: afterLines[afterIndex]! })
+    afterIndex += 1
+  }
+
+  return ops
+}
+
+function buildPrefixSuffixDiff(beforeLines: string[], afterLines: string[]): DiffOp[] {
+  let prefixLength = 0
+  while (
+    prefixLength < beforeLines.length &&
+    prefixLength < afterLines.length &&
+    beforeLines[prefixLength] === afterLines[prefixLength]
+  ) {
+    prefixLength += 1
+  }
+
+  let beforeEnd = beforeLines.length
+  let afterEnd = afterLines.length
+  while (
+    beforeEnd > prefixLength &&
+    afterEnd > prefixLength &&
+    beforeLines[beforeEnd - 1] === afterLines[afterEnd - 1]
+  ) {
+    beforeEnd -= 1
+    afterEnd -= 1
+  }
+
+  const ops: DiffOp[] = []
+  for (let index = 0; index < prefixLength; index += 1) {
+    ops.push({ type: 'equal', line: beforeLines[index]! })
+  }
+  for (let index = prefixLength; index < beforeEnd; index += 1) {
+    ops.push({ type: 'delete', line: beforeLines[index]! })
+  }
+  for (let index = prefixLength; index < afterEnd; index += 1) {
+    ops.push({ type: 'insert', line: afterLines[index]! })
+  }
+  for (let index = beforeEnd; index < beforeLines.length; index += 1) {
+    ops.push({ type: 'equal', line: beforeLines[index]! })
+  }
+  return ops
+}
+
+function lcsLengths(beforeLines: string[], afterLines: string[]): number[][] {
+  const lengths = Array.from(
+    { length: beforeLines.length + 1 },
+    () => Array<number>(afterLines.length + 1).fill(0),
+  )
+
+  for (let beforeIndex = beforeLines.length - 1; beforeIndex >= 0; beforeIndex -= 1) {
+    for (let afterIndex = afterLines.length - 1; afterIndex >= 0; afterIndex -= 1) {
+      lengths[beforeIndex]![afterIndex] = beforeLines[beforeIndex] === afterLines[afterIndex]
+        ? lengths[beforeIndex + 1]![afterIndex + 1]! + 1
+        : Math.max(lengths[beforeIndex + 1]![afterIndex]!, lengths[beforeIndex]![afterIndex + 1]!)
+    }
+  }
+
+  return lengths
+}
+
+function buildHunkRanges(ops: DiffOp[], contextLines: number): HunkRange[] {
+  const ranges: HunkRange[] = []
+  const context = Math.max(0, contextLines)
+
+  for (let index = 0; index < ops.length; index += 1) {
+    if (ops[index]?.type === 'equal') continue
+    const start = Math.max(0, index - context)
+    const end = Math.min(ops.length, index + context + 1)
+    const previous = ranges[ranges.length - 1]
+    if (previous && start <= previous.end) {
+      previous.end = Math.max(previous.end, end)
+    } else {
+      ranges.push({ start, end })
+    }
+  }
+
+  return ranges
+}
+
+function countOldLines(ops: DiffOp[], start: number, end: number): number {
+  let count = 0
+  for (let index = start; index < end; index += 1) {
+    const type = ops[index]?.type
+    if (type === 'equal' || type === 'delete') count += 1
+  }
+  return count
+}
+
+function countNewLines(ops: DiffOp[], start: number, end: number): number {
+  let count = 0
+  for (let index = start; index < end; index += 1) {
+    const type = ops[index]?.type
+    if (type === 'equal' || type === 'insert') count += 1
+  }
+  return count
+}
+
+function formatRange(start: number, count: number): string {
+  if (count === 0) return `${Math.max(0, start - 1)},0`
+  if (count === 1) return String(start)
+  return `${start},${count}`
+}
+
+function normalizedLines(value: string): string[] {
+  if (value.length === 0) return []
+  const lines = value.replace(/\r\n?/g, '\n').split('\n')
+  if (lines[lines.length - 1] === '') lines.pop()
+  return lines
+}
+
+function truncateDiff(lines: string[], maxChars: number): string {
+  const diff = lines.join('\n')
+  if (diff.length <= maxChars) return diff
+
+  const out: string[] = []
+  let length = 0
+  for (const line of lines) {
+    const nextLength = length + (out.length > 0 ? 1 : 0) + line.length
+    if (nextLength > maxChars) break
+    out.push(line)
+    length = nextLength
+  }
+  return out.join('\n')
+}

package/src/tools/privateContinuityEditTool.ts

@@ -6,6 +6,7 @@ import {
 import { recordPrivateContinuityHistorySnapshot } from '../identity/continuity/history.js'
 import { readContinuityFiles, readPublicSkillsFile } from '../identity/continuity/storage.js'
 import type { Tool } from './contracts.js'
+import { formatFileChangeResult } from './fileDiff.js'
 
 const schema = z.object({
   file: z.preprocess(normalizePrivateContinuityFile, z.enum(['SOUL.md', 'MEMORY.md'])),
@@ -141,7 +142,10 @@ export const privateContinuityEditTool: Tool<typeof schema> = {
     return {
       ok: true,
       summary: prepared.changeSummary,
-      content: formatPrivateContinuityEditResult(prepared.file, prepared.fullPath),
+      content: formatFileChangeResult(
+        formatPrivateContinuityEditResult(prepared.file, prepared.fullPath),
+        prepared.diff,
+      ),
     }
   },
 }

package/src/tools/writeFileTool.ts

@@ -4,6 +4,7 @@ import { z } from 'zod'
 import { recordRewindSnapshot } from '../storage/rewind.js'
 import type { EthagentConfig } from '../storage/config.js'
 import type { Tool } from './contracts.js'
+import { formatFileChangeResult, renderUnifiedFileDiff } from './fileDiff.js'
 import { resolveWorkspacePath } from './readTool.js'
 
 const schema = z.object({
@@ -40,6 +41,7 @@ export const writeFileTool: Tool<typeof schema> = {
       subtitle: prepared.fullPath,
       before: previewText(prepared.before),
       after: previewText(input.content),
+      diff: renderUnifiedFileDiff({ filePath: prepared.relativePath, before: prepared.before, after: input.content }),
       changeSummary: prepared.existedBefore ? `replace entire ${prepared.relativePath}` : `create ${prepared.relativePath}`,
     }
   },
@@ -64,9 +66,12 @@ export const writeFileTool: Tool<typeof schema> = {
     return {
       ok: true,
       summary: prepared.existedBefore ? `replace entire ${prepared.relativePath}` : `create ${prepared.relativePath}`,
-      content: rewindWarning
-        ? `updated ${prepared.fullPath}\nwarning: ${rewindWarning}`
-        : `updated ${prepared.fullPath}`,
+      content: formatFileChangeResult(
+        rewindWarning
+          ? `updated ${prepared.fullPath}\nwarning: ${rewindWarning}`
+          : `updated ${prepared.fullPath}`,
+        renderUnifiedFileDiff({ filePath: prepared.relativePath, before: prepared.before, after: input.content }),
+      ),
     }
   },
 }

package/src/ui/Spinner.tsx

@@ -226,6 +226,7 @@ export const Spinner: React.FC<SpinnerProps> = ({
   const stickyVerbRef = useRef<string | null>(null)
   const internalStartedAtRef = useRef<number>(Date.now())
   const [frame, setFrame] = useState(0)
+  const [shimmerPos, setShimmerPos] = useState(0)
 
   useEffect(() => {
     if (!active) {
@@ -252,19 +253,40 @@ export const Spinner: React.FC<SpinnerProps> = ({
     return () => clearInterval(timer)
   }, [active])
 
-  if (!active) return null
-
   const autoLabel = stickyVerbRef.current ?? verb ?? 'thinking'
   const text = spinnerText(label ?? `${autoLabel}…`)
+
+  useEffect(() => {
+    if (!active) return
+    const period = text.length + 12
+    const timer = setInterval(() => {
+      setShimmerPos(prev => (prev + 1) % period)
+    }, 90)
+    return () => clearInterval(timer)
+  }, [active, text.length])
+
+  if (!active) return null
+
   const glyph = FRAMES[frame] ?? 'o'
   const elapsed = showElapsed ? formatElapsedSeconds(Date.now() - (startedAt ?? internalStartedAtRef.current)) : null
   const renderedHint = [rawHint, elapsed].filter(Boolean).join(' · ')
   const hint = renderedHint ? spinnerHintText(renderedHint) : ''
 
+  const shimmerStart = shimmerPos - 1
+  const shimmerEnd = shimmerPos + 1
+  const visibleStart = Math.max(0, shimmerStart)
+  const visibleEnd = Math.min(text.length, shimmerEnd + 1)
+  const before = text.slice(0, visibleStart)
+  const shimmer = shimmerStart < text.length && shimmerEnd >= 0 ? text.slice(visibleStart, visibleEnd) : ''
+  const after = text.slice(visibleEnd)
+
   return (
     <Text>
       <Text color={color}>{glyph}</Text>
-      <Text color={theme.dim}> {text}</Text>
+      <Text> </Text>
+      {before ? <Text color={theme.accentPeriwinkle}>{before}</Text> : null}
+      {shimmer ? <Text color={theme.accentWhite} bold>{shimmer}</Text> : null}
+      {after ? <Text color={theme.accentPeriwinkle}>{after}</Text> : null}
       {hint ? <Text color={theme.dim}> · {hint}</Text> : null}
     </Text>
   )

package/src/ui/TextInput.tsx

@@ -2,11 +2,11 @@ import React, { useState, useRef, useEffect } from 'react'
 import { Box, Text, useStdout } from 'ink'
 import { theme } from './theme.js'
 import { useAppInput } from '../app/input/AppInputProvider.js'
-import { moveVerticalVisual } from '../chat/chatInputState.js'
+import { moveVerticalVisual } from '../chat/input/chatInputState.js'
 import {
   getVisualLineIndex,
   getVisualLines,
-} from '../chat/textCursor.js'
+} from '../chat/input/textCursor.js'
 
 const DEFAULT_CHROME_WIDTH = 10
 

package/src/ui/theme.ts

@@ -11,6 +11,23 @@ export const theme = {
   accentBlue: '#e8eefd',
   accentWhite: '#f5f8ff',
   accentError: '#d99898',
+  diffAdded: '#8fd49d',
+  diffRemoved: '#d99898',
+  diffAddedBackground: '#16351f',
+  diffRemovedBackground: '#3a1717',
+  blockBackground: '#0b0d12',
+  codeKeyword: '#e8eefd',
+  codeString: '#c9e08f',
+  codeNumber: '#d8dcfa',
+  codeComment: '#777777',
+  codeFunction: '#8fc7ff',
+  codeType: '#f2d087',
+  codeBuiltin: '#b8a7ff',
+  codeProperty: '#91dcc0',
+  codeOperator: '#d8dcfa',
+  codePunctuation: '#aeb4c8',
+  codeTag: '#ffb3b3',
+  codeAttribute: '#f2d087',
   border: '#555555',
   dim: '#777777',
   text: '#f1f1f1',

package/src/utils/clipboard.ts

@@ -3,26 +3,29 @@ import { mkdir, stat } from 'node:fs/promises'
 import os from 'node:os'
 import path from 'node:path'
 
-export type CopyResult = { ok: true; method: string } | { ok: false; error: string }
+export type CopyResult = { ok: true; method: string; chars: number } | { ok: false; error: string }
 export type ReadResult = { ok: true; text: string; method: string } | { ok: false; error: string }
 export type ReadImageResult = { ok: true; path: string; method: string } | { ok: false; error: string }
 
+type CopyAttempt = { ok: true; method: string } | { ok: false; error: string }
+
 export async function copyToClipboard(text: string): Promise<CopyResult> {
+  const chars = text.length
   const native = await tryNative(text)
-  if (native.ok) return native
+  if (native.ok) return { ...native, chars }
 
   const tmux = await tryTmux(text)
-  if (tmux.ok) return tmux
+  if (tmux.ok) return { ...tmux, chars }
 
   try {
     process.stdout.write(osc52(text))
-    return { ok: true, method: 'osc52' }
+    return { ok: true, method: 'osc52', chars }
   } catch (err: unknown) {
     return { ok: false, error: (err as Error).message || 'osc52 write failed' }
   }
 }
 
-async function tryNative(text: string): Promise<CopyResult> {
+async function tryNative(text: string): Promise<CopyAttempt> {
   if (process.platform === 'darwin') {
     return pipeTo('pbcopy', [], text, 'pbcopy')
   }
@@ -38,12 +41,12 @@ async function tryNative(text: string): Promise<CopyResult> {
   return { ok: false, error: 'no native clipboard tool found' }
 }
 
-async function tryTmux(text: string): Promise<CopyResult> {
+async function tryTmux(text: string): Promise<CopyAttempt> {
   if (!process.env['TMUX']) return { ok: false, error: 'not in tmux' }
   return pipeTo('tmux', ['load-buffer', '-w', '-'], text, 'tmux load-buffer')
 }
 
-function pipeTo(cmd: string, args: string[], text: string, method: string): Promise<CopyResult> {
+function pipeTo(cmd: string, args: string[], text: string, method: string): Promise<CopyAttempt> {
   return new Promise(resolve => {
     let child
     try {