ethagent 0.2.1 → 1.0.0

package/src/ui/TextInput.tsx

@@ -0,0 +1,97 @@
+import React, { useState } from 'react'
+import { Box, Text } from 'ink'
+import { theme } from './theme.js'
+import { useAppInput } from '../app/input/AppInputProvider.js'
+
+type TextInputProps = {
+  label?: string
+  placeholder?: string
+  isSecret?: boolean
+  initialValue?: string
+  allowEmpty?: boolean
+  maxLength?: number
+  validate?: (value: string) => string | null
+  onSubmit: (value: string) => void
+  onCancel?: () => void
+}
+
+export function TextInput({
+  label,
+  placeholder,
+  isSecret,
+  initialValue = '',
+  allowEmpty = false,
+  maxLength = 4096,
+  validate,
+  onSubmit,
+  onCancel,
+}: TextInputProps) {
+  const [value, setValue] = useState(initialValue)
+  const [error, setError] = useState<string | null>(null)
+
+  useAppInput((input, key) => {
+    if (key.return) {
+      if (!allowEmpty && value.trim().length === 0) {
+        setError('value cannot be empty')
+        return
+      }
+      const validationError = validate?.(value) ?? null
+      if (validationError) {
+        setError(validationError)
+        return
+      }
+      setError(null)
+      onSubmit(value)
+      return
+    }
+    if (key.escape) {
+      onCancel?.()
+      return
+    }
+    if (key.backspace || key.delete) {
+      setValue(v => v.slice(0, -1))
+      if (error) setError(null)
+      return
+    }
+    if (key.ctrl && input === 'u') {
+      setValue('')
+      if (error) setError(null)
+      return
+    }
+    if (key.ctrl || key.meta || key.leftArrow || key.rightArrow || key.upArrow || key.downArrow || key.tab) {
+      return
+    }
+    if (input) {
+      const clean = input.replace(/[\r\n]/g, '')
+      if (clean) {
+        setValue(v => (v + clean).slice(0, maxLength))
+        if (error) setError(null)
+      }
+    }
+  })
+
+  const display = isSecret ? '*'.repeat(value.length) : value
+  const showPlaceholder = value.length === 0 && placeholder
+
+  return (
+    <Box flexDirection="column">
+      {label ? <Text color={theme.dim}>{label}</Text> : null}
+      <Box flexDirection="row">
+        <Text color={theme.accentPrimary}>{'> '}</Text>
+        {showPlaceholder ? (
+          <>
+            <Text color={theme.accentPrimary}>|</Text>
+            <Text color={theme.dim}>{placeholder}</Text>
+          </>
+        ) : (
+          <>
+            <Text color={theme.text}>{display}</Text>
+            <Text color={theme.accentPrimary}>|</Text>
+          </>
+        )}
+      </Box>
+      {error ? <Text color="#e87070">{error}</Text> : null}
+    </Box>
+  )
+}
+

package/src/ui/theme.ts

@@ -0,0 +1,59 @@
+export const palette: Array<[number, number, number]> = [
+  [0xff, 0xff, 0xff],
+  [0xf2, 0xf9, 0xf4],
+  [0xe7, 0xf4, 0xec],
+  [0xd4, 0xee, 0xdd],
+  [0xe7, 0xf4, 0xec],
+  [0xff, 0xff, 0xff],
+]
+
+export const eyePalette: Array<[number, number, number]> = [
+  [0xf5, 0xd8, 0xd8],
+  [0xf5, 0xe7, 0xcf],
+  [0xf5, 0xf0, 0xd4],
+  [0xd4, 0xee, 0xdd],
+  [0xd4, 0xe6, 0xf5],
+] as const
+
+export const theme = {
+  accentPrimary: '#d4eedd',
+  accentWarm: '#d8cda8',
+  accentNeutral: '#e4e3b5',
+  accentSecondary: '#c0e3cb',
+  accentMint: '#e7f4ec',
+  accentPeach: '#e7cdb7',
+  accentLavender: '#d9cae8',
+  accentInfo: '#90b8e8',
+  border: '#555555',
+  dim: '#777777',
+  text: '#f1f1f1',
+  textSubtle: '#9b9b9b',
+} as const
+
+export function gradientColor(t: number): string {
+  const s = Math.max(0, Math.min(1, t)) * (palette.length - 1)
+  const i = Math.min(Math.floor(s), palette.length - 2)
+  const f = s - i
+  const lo = palette[i] ?? palette[0]!
+  const hi = palette[i + 1] ?? palette[palette.length - 1]!
+  const [r1, g1, b1] = lo
+  const [r2, g2, b2] = hi
+  const r = Math.round(r1 + (r2 - r1) * f)
+  const g = Math.round(g1 + (g2 - g1) * f)
+  const b = Math.round(b1 + (b2 - b1) * f)
+  return `#${r.toString(16).padStart(2, '0')}${g.toString(16).padStart(2, '0')}${b.toString(16).padStart(2, '0')}`
+}
+
+export function eyeGradientColor(t: number): string {
+  const s = Math.max(0, Math.min(1, t)) * (eyePalette.length - 1)
+  const i = Math.min(Math.floor(s), eyePalette.length - 2)
+  const f = s - i
+  const lo = eyePalette[i] ?? eyePalette[0]!
+  const hi = eyePalette[i + 1] ?? eyePalette[eyePalette.length - 1]!
+  const [r1, g1, b1] = lo
+  const [r2, g2, b2] = hi
+  const r = Math.round(r1 + (r2 - r1) * f)
+  const g = Math.round(g1 + (g2 - g1) * f)
+  const b = Math.round(b1 + (b2 - b1) * f)
+  return `#${r.toString(16).padStart(2, '0')}${g.toString(16).padStart(2, '0')}${b.toString(16).padStart(2, '0')}`
+}

package/src/utils/clipboard.ts

@@ -0,0 +1,216 @@
+import { spawn } from 'node:child_process'
+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 ReadResult = { ok: true; text: string; method: string } | { ok: false; error: string }
+export type ReadImageResult = { ok: true; path: string; method: string } | { ok: false; error: string }
+
+export async function copyToClipboard(text: string): Promise<CopyResult> {
+  const native = await tryNative(text)
+  if (native.ok) return native
+
+  const tmux = await tryTmux(text)
+  if (tmux.ok) return tmux
+
+  try {
+    process.stdout.write(osc52(text))
+    return { ok: true, method: 'osc52' }
+  } catch (err: unknown) {
+    return { ok: false, error: (err as Error).message || 'osc52 write failed' }
+  }
+}
+
+async function tryNative(text: string): Promise<CopyResult> {
+  if (process.platform === 'darwin') {
+    return pipeTo('pbcopy', [], text, 'pbcopy')
+  }
+  if (process.platform === 'win32') {
+    return pipeTo('clip', [], text, 'clip.exe')
+  }
+  const wl = await probe('wl-copy', ['--version'])
+  if (wl) return pipeTo('wl-copy', [], text, 'wl-copy')
+  const xclip = await probe('xclip', ['-version'])
+  if (xclip) return pipeTo('xclip', ['-selection', 'clipboard'], text, 'xclip')
+  const xsel = await probe('xsel', ['--version'])
+  if (xsel) return pipeTo('xsel', ['--clipboard', '--input'], text, 'xsel')
+  return { ok: false, error: 'no native clipboard tool found' }
+}
+
+async function tryTmux(text: string): Promise<CopyResult> {
+  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> {
+  return new Promise(resolve => {
+    let child
+    try {
+      child = spawn(cmd, args, { stdio: ['pipe', 'ignore', 'ignore'] })
+    } catch (err: unknown) {
+      resolve({ ok: false, error: (err as Error).message })
+      return
+    }
+    child.on('error', err => resolve({ ok: false, error: err.message }))
+    child.on('close', code => {
+      if (code === 0) resolve({ ok: true, method })
+      else resolve({ ok: false, error: `${cmd} exited ${code}` })
+    })
+    child.stdin?.end(text, 'utf8')
+  })
+}
+
+function probe(cmd: string, args: string[]): Promise<boolean> {
+  return new Promise(resolve => {
+    let child
+    try {
+      child = spawn(cmd, args, { stdio: 'ignore' })
+    } catch {
+      resolve(false)
+      return
+    }
+    child.on('error', () => resolve(false))
+    child.on('close', code => resolve(code === 0))
+  })
+}
+
+function osc52(text: string): string {
+  const b64 = Buffer.from(text, 'utf8').toString('base64')
+  return `\x1b]52;c;${b64}\x07`
+}
+
+export async function readClipboard(): Promise<ReadResult> {
+  const native = await tryReadNative()
+  if (native.ok) return native
+  const tmux = await tryReadTmux()
+  if (tmux.ok) return tmux
+  return { ok: false, error: native.error || tmux.error || 'no clipboard tool available' }
+}
+
+async function tryReadNative(): Promise<ReadResult> {
+  if (process.platform === 'darwin') {
+    return readFrom('pbpaste', [], 'pbpaste')
+  }
+  if (process.platform === 'win32') {
+    return readFrom('powershell', ['-NoProfile', '-Command', 'Get-Clipboard -Raw'], 'powershell Get-Clipboard')
+  }
+  if (process.env['WAYLAND_DISPLAY']) {
+    const wl = await probe('wl-paste', ['--version'])
+    if (wl) return readFrom('wl-paste', ['--no-newline'], 'wl-paste')
+  }
+  const xclip = await probe('xclip', ['-version'])
+  if (xclip) return readFrom('xclip', ['-o', '-selection', 'clipboard'], 'xclip')
+  const xsel = await probe('xsel', ['--version'])
+  if (xsel) return readFrom('xsel', ['--output', '--clipboard'], 'xsel')
+  return { ok: false, error: 'no native clipboard tool found' }
+}
+
+async function tryReadTmux(): Promise<ReadResult> {
+  if (!process.env['TMUX']) return { ok: false, error: 'not in tmux' }
+  return readFrom('tmux', ['save-buffer', '-'], 'tmux save-buffer')
+}
+
+function readFrom(cmd: string, args: string[], method: string): Promise<ReadResult> {
+  return new Promise(resolve => {
+    let child
+    try {
+      child = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'ignore'] })
+    } catch (err: unknown) {
+      resolve({ ok: false, error: (err as Error).message })
+      return
+    }
+    const chunks: Buffer[] = []
+    child.stdout?.on('data', (chunk: Buffer) => chunks.push(chunk))
+    child.on('error', err => resolve({ ok: false, error: err.message }))
+    child.on('close', code => {
+      if (code === 0) {
+        const text = Buffer.concat(chunks).toString('utf8').replace(/\r\n/g, '\n').replace(/\r/g, '\n')
+        resolve({ ok: true, text: text.replace(/\n$/, ''), method })
+      } else {
+        resolve({ ok: false, error: `${cmd} exited ${code}` })
+      }
+    })
+  })
+}
+
+export async function readClipboardImage(): Promise<ReadImageResult> {
+  const dir = path.join(os.homedir(), '.ethagent', 'pastes')
+  try {
+    await mkdir(dir, { recursive: true })
+  } catch (err: unknown) {
+    return { ok: false, error: (err as Error).message }
+  }
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-')
+  const dest = path.join(dir, `paste-${stamp}.png`)
+
+  if (process.platform === 'win32') return readImageWindows(dest)
+  if (process.platform === 'darwin') return readImageMac(dest)
+  return readImageLinux(dest)
+}
+
+function readImageWindows(dest: string): Promise<ReadImageResult> {
+  const script = [
+    "Add-Type -AssemblyName System.Windows.Forms",
+    "$img = [System.Windows.Forms.Clipboard]::GetImage()",
+    "if ($null -eq $img) { exit 2 }",
+    "$img.Save($env:ETHAGENT_PASTE_PATH, [System.Drawing.Imaging.ImageFormat]::Png)",
+  ].join('; ')
+  return spawnImage(
+    'powershell',
+    ['-NoProfile', '-Sta', '-Command', script],
+    { ETHAGENT_PASTE_PATH: dest },
+    dest,
+    'powershell',
+  )
+}
+
+async function readImageMac(dest: string): Promise<ReadImageResult> {
+  const has = await probe('pngpaste', ['-v'])
+  if (!has) return { ok: false, error: 'pngpaste not installed (brew install pngpaste)' }
+  return spawnImage('pngpaste', [dest], {}, dest, 'pngpaste')
+}
+
+async function readImageLinux(dest: string): Promise<ReadImageResult> {
+  const hasXclip = await probe('xclip', ['-version'])
+  if (!hasXclip) return { ok: false, error: 'xclip not available' }
+  return spawnImage('sh', ['-c', `xclip -selection clipboard -t image/png -o > "${dest}"`], {}, dest, 'xclip')
+}
+
+function spawnImage(
+  cmd: string,
+  args: string[],
+  env: Record<string, string>,
+  destPath: string,
+  method: string,
+): Promise<ReadImageResult> {
+  return new Promise(resolve => {
+    let child
+    try {
+      child = spawn(cmd, args, {
+        stdio: ['ignore', 'ignore', 'ignore'],
+        env: { ...process.env, ...env },
+      })
+    } catch (err: unknown) {
+      resolve({ ok: false, error: (err as Error).message })
+      return
+    }
+    child.on('error', err => resolve({ ok: false, error: err.message }))
+    child.on('close', code => {
+      if (code === 2) {
+        resolve({ ok: false, error: 'no image on clipboard' })
+        return
+      }
+      if (code !== 0) {
+        resolve({ ok: false, error: `${cmd} exited ${code}` })
+        return
+      }
+      void stat(destPath)
+        .then(s => {
+          if (s.size === 0) resolve({ ok: false, error: 'no image saved' })
+          else resolve({ ok: true, path: destPath, method })
+        })
+        .catch(() => resolve({ ok: false, error: 'image file not created' }))
+    })
+  })
+}

package/src/utils/markdownSegments.ts

@@ -0,0 +1,51 @@
+export type Segment =
+  | { kind: 'text'; content: string; preview: string }
+  | { kind: 'code'; lang: string | null; content: string; preview: string }
+
+const FENCE = /^[ \t]{0,3}```([\w+-]*)[ \t]*\r?\n([\s\S]*?)\r?\n[ \t]{0,3}```[ \t]*(?:\r?\n|$)/gm
+
+export function parseSegments(markdown: string): Segment[] {
+  if (!markdown) return []
+  const segments: Segment[] = []
+  let lastIndex = 0
+  FENCE.lastIndex = 0
+  let match: RegExpExecArray | null
+  while ((match = FENCE.exec(markdown)) !== null) {
+    const before = markdown.slice(lastIndex, match.index)
+    const textSeg = toTextSegment(before)
+    if (textSeg) segments.push(textSeg)
+    const lang = match[1] && match[1].length > 0 ? match[1] : null
+    const body = match[2] ?? ''
+    segments.push({
+      kind: 'code',
+      lang,
+      content: body,
+      preview: codePreview(lang, body),
+    })
+    lastIndex = match.index + match[0].length
+  }
+  const tail = markdown.slice(lastIndex)
+  const tailSeg = toTextSegment(tail)
+  if (tailSeg) segments.push(tailSeg)
+  return segments
+}
+
+function toTextSegment(raw: string): Segment | null {
+  const cleaned = raw.replace(/\r\n/g, '\n').replace(/\n{3,}/g, '\n\n').trim()
+  if (!cleaned) return null
+  return { kind: 'text', content: cleaned, preview: textPreview(cleaned) }
+}
+
+function textPreview(text: string): string {
+  const firstLine = text.split('\n').find(line => line.trim().length > 0) ?? text
+  const trimmed = firstLine.trim()
+  const chars = text.length
+  const snippet = trimmed.length > 48 ? trimmed.slice(0, 47) + '…' : trimmed
+  return `text · ${chars} chars · ${snippet}`
+}
+
+function codePreview(lang: string | null, body: string): string {
+  const lineCount = body.length === 0 ? 0 : body.split('\n').length
+  const label = lang ?? 'code'
+  return `code · ${label} · ${lineCount} line${lineCount === 1 ? '' : 's'}`
+}

package/src/utils/messages.ts

@@ -0,0 +1,35 @@
+import type { Message, MessageContentBlock } from '../providers/contracts.js'
+
+export function systemMessage(content: string): Message {
+  return { role: 'system', content }
+}
+
+export function userMessage(content: string | MessageContentBlock[]): Message {
+  return { role: 'user', content }
+}
+
+export function assistantMessage(content: string | MessageContentBlock[]): Message {
+  return { role: 'assistant', content }
+}
+
+export function messageTextContent(message: Message): string {
+  return typeof message.content === 'string' ? message.content : blocksToText(message.content)
+}
+
+export function blocksToText(blocks: MessageContentBlock[]): string {
+  return blocks
+    .map(block => {
+      if (block.type === 'text') return block.text
+      if (block.type === 'tool_use') return `[tool use: ${block.name}]`
+      return block.isError
+        ? `[tool error: ${block.content}]`
+        : `[tool result: ${block.content}]`
+    })
+    .join('\n')
+}
+
+export function approximateTokens(messages: Message[]): number {
+  let chars = 0
+  for (const m of messages) chars += messageTextContent(m).length
+  return Math.ceil(chars / 4)
+}