ethagent 3.0.2 → 3.1.0

package/src/chat/input/inputRendering.tsx

@@ -0,0 +1,93 @@
+import React from 'react'
+import { Text } from 'ink'
+import { theme } from '../../ui/theme.js'
+import {
+  getVisibleVisualLineWindow,
+  getVisualLineIndex,
+  getVisualLines,
+} from './textCursor.js'
+
+const STACK_HORIZONTAL_PADDING = 2
+const INPUT_BORDER_WIDTH = 2
+const INPUT_HORIZONTAL_PADDING = 4
+const PROMPT_PREFIX_WIDTH = 2
+
+type RenderedVisualLine = {
+  visualLineIndex: number
+  node: React.ReactNode
+}
+
+type RenderedInputViewport = {
+  lines: RenderedVisualLine[]
+  hiddenAbove: number
+  hiddenBelow: number
+  visibleLineCount: number
+}
+
+export function renderWithCursor(
+  value: string,
+  cursor: number,
+  showCursor: boolean,
+  wrapWidth: number,
+  maxVisibleLines: number,
+): RenderedInputViewport {
+  const lines = getVisualLines(value, wrapWidth)
+  const cursorLine = getVisualLineIndex(lines, cursor)
+  const window = getVisibleVisualLineWindow(lines.length, cursorLine, maxVisibleLines)
+  const visibleLines = lines.slice(window.start, window.end)
+
+  if (!showCursor) {
+    return {
+      lines: visibleLines.map((line, i) => ({
+        visualLineIndex: window.start + i,
+        node: (
+          <Text color={theme.text} wrap="wrap">
+            {value.slice(line.start, line.end) || ' '}
+          </Text>
+        ),
+      })),
+      hiddenAbove: window.start,
+      hiddenBelow: lines.length - window.end,
+      visibleLineCount: Math.max(1, visibleLines.length),
+    }
+  }
+
+  return {
+    lines: visibleLines.map((line, i) => {
+      const visualLineIndex = window.start + i
+      const text = value.slice(line.start, line.end)
+      if (visualLineIndex !== cursorLine) {
+        return {
+          visualLineIndex,
+          node: <Text color={theme.text} wrap="wrap">{text || ' '}</Text>,
+        }
+      }
+      const column = Math.max(0, Math.min(cursor - line.start, text.length))
+      const before = text.slice(0, column)
+      const atChar = text[column] ?? ' '
+      const after = text.slice(column + 1)
+      return {
+        visualLineIndex,
+        node: (
+          <Text color={theme.text} wrap="wrap">
+            {before}
+            <Text backgroundColor={theme.accentPeriwinkle} color="#0c0c1f">{atChar}</Text>
+            {after}
+          </Text>
+        ),
+      }
+    }),
+    hiddenAbove: window.start,
+    hiddenBelow: lines.length - window.end,
+    visibleLineCount: Math.max(1, visibleLines.length),
+  }
+}
+
+export function inputWrapWidth(columns: number): number {
+  const fixedChromeWidth =
+    STACK_HORIZONTAL_PADDING
+    + INPUT_BORDER_WIDTH
+    + INPUT_HORIZONTAL_PADDING
+    + PROMPT_PREFIX_WIDTH
+  return Math.max(1, Math.floor(columns) - fixedChromeWidth)
+}

package/src/chat/messageMarkdown.ts

@@ -0,0 +1,220 @@
+export type MarkdownBlock =
+  | { kind: 'heading'; level: 1 | 2 | 3 | 4 | 5 | 6; text: string }
+  | { kind: 'paragraph'; text: string }
+  | { kind: 'quote'; lines: string[] }
+  | { kind: 'list'; ordered: boolean; items: string[] }
+  | { kind: 'code'; lang: string | null; code: string; open?: boolean }
+
+export type InlineToken =
+  | { kind: 'text'; text: string }
+  | { kind: 'bold'; text: string }
+  | { kind: 'italic'; text: string }
+  | { kind: 'code'; text: string }
+
+const UNREADABLE_REASONING_TEXT = 'reasoning output was not readable text'
+
+export function blockContentWidth(lines: string[]): number {
+  return Math.max(1, ...lines.map(displayWidth))
+}
+
+function displayWidth(line: string): number {
+  return (line || ' ').replace(/\t/g, '  ').length
+}
+
+export function parseMarkdownBlocks(markdown: string): MarkdownBlock[] {
+  const text = markdown.replace(/\r\n/g, '\n').replace(/\r/g, '\n')
+  if (!text.trim()) return []
+
+  const blocks: MarkdownBlock[] = []
+  const lines = text.split('\n')
+  let index = 0
+
+  while (index < lines.length) {
+    const line = lines[index] ?? ''
+    const trimmed = line.trim()
+
+    if (!trimmed) {
+      index += 1
+      continue
+    }
+
+    const fence = trimmed.match(/^```([\w+-]*)\s*$/)
+    if (fence) {
+      const lang = fence[1] && fence[1].length > 0 ? fence[1] : null
+      index += 1
+      const body: string[] = []
+      let closed = false
+      while (index < lines.length) {
+        const nextLine = lines[index] ?? ''
+        if (nextLine.trim().match(/^```\s*$/)) {
+          closed = true
+          index += 1
+          break
+        }
+        body.push(nextLine)
+        index += 1
+      }
+      blocks.push({ kind: 'code', lang, code: body.join('\n'), open: !closed })
+      continue
+    }
+
+    const heading = line.match(/^(#{1,6})\s+(.*)$/)
+    if (heading) {
+      const [, hashes = '#', headingText = ''] = heading
+      blocks.push({
+        kind: 'heading',
+        level: hashes.length as 1 | 2 | 3 | 4 | 5 | 6,
+        text: headingText.trim(),
+      })
+      index += 1
+      continue
+    }
+
+    if (/^>\s?/.test(trimmed)) {
+      const quoteLines: string[] = []
+      while (index < lines.length) {
+        const nextLine = lines[index] ?? ''
+        if (!/^>\s?/.test(nextLine.trim())) break
+        quoteLines.push(nextLine.trim().replace(/^>\s?/, ''))
+        index += 1
+      }
+      blocks.push({ kind: 'quote', lines: quoteLines })
+      continue
+    }
+
+    const ordered = trimmed.match(/^\d+\.\s+(.*)$/)
+    const unordered = trimmed.match(/^[-*+]\s+(.*)$/)
+    if (ordered || unordered) {
+      const items: string[] = []
+      const orderedList = Boolean(ordered)
+      while (index < lines.length) {
+        const nextLine = lines[index] ?? ''
+        const match = orderedList
+          ? nextLine.trim().match(/^\d+\.\s+(.*)$/)
+          : nextLine.trim().match(/^[-*+]\s+(.*)$/)
+        if (!match) break
+        items.push(match[1] ?? '')
+        index += 1
+      }
+      blocks.push({ kind: 'list', ordered: orderedList, items })
+      continue
+    }
+
+    const paragraph: string[] = []
+    while (index < lines.length) {
+      const nextLine = lines[index] ?? ''
+      const nextTrimmed = nextLine.trim()
+      if (!nextTrimmed) break
+      if (nextTrimmed.match(/^```([\w+-]*)\s*$/)) break
+      if (nextLine.match(/^(#{1,6})\s+(.*)$/)) break
+      if (/^>\s?/.test(nextTrimmed)) break
+      if (nextTrimmed.match(/^\d+\.\s+(.*)$/) || nextTrimmed.match(/^[-*+]\s+(.*)$/)) break
+      paragraph.push(nextLine)
+      index += 1
+    }
+    blocks.push({ kind: 'paragraph', text: paragraph.join('\n').trim() })
+  }
+
+  return blocks
+}
+
+export function parseInlineTokens(text: string): InlineToken[] {
+  const tokens: InlineToken[] = []
+  const source = normalizeInlineDisplayText(text)
+  const pattern = /(`[^`\n]+`|\*\*[^*\n]+?\*\*|__[^_\n]+?__|\*[^*\n]+?\*|_[^_\n]+?_)/g
+  let lastIndex = 0
+  let match: RegExpExecArray | null
+
+  while ((match = pattern.exec(source)) !== null) {
+    if (match.index > lastIndex) {
+      tokens.push({ kind: 'text', text: cleanPlainInlineText(source.slice(lastIndex, match.index)) })
+    }
+
+    const token = match[0]
+    if ((token.startsWith('**') && token.endsWith('**')) || (token.startsWith('__') && token.endsWith('__'))) {
+      tokens.push({ kind: 'bold', text: cleanPlainInlineText(token.slice(2, -2)) })
+    } else if ((token.startsWith('*') && token.endsWith('*')) || (token.startsWith('_') && token.endsWith('_'))) {
+      tokens.push({ kind: 'italic', text: cleanPlainInlineText(token.slice(1, -1)) })
+    } else if (token.startsWith('`') && token.endsWith('`')) {
+      tokens.push({ kind: 'code', text: token.slice(1, -1) })
+    }
+
+    lastIndex = match.index + token.length
+  }
+
+  if (lastIndex < source.length || tokens.length === 0) {
+    tokens.push({ kind: 'text', text: cleanPlainInlineText(source.slice(lastIndex)) })
+  }
+
+  return tokens.filter(token => token.text.length > 0)
+}
+
+function normalizeInlineDisplayText(text: string): string {
+  return text
+    .replace(/\\\(/g, '')
+    .replace(/\\\)/g, '')
+    .replace(/\\\[/g, '')
+    .replace(/\\\]/g, '')
+    .replace(/\$\$([^$]+)\$\$/g, '$1')
+    .replace(/\$([^$\n]+)\$/g, '$1')
+    .replace(/\\([{}[\]()])/g, '$1')
+    .replace(/\/([{}])/g, '$1')
+}
+
+function cleanPlainInlineText(text: string): string {
+  return text.replace(/\*+/g, '')
+}
+
+export function summarizeThinking(text: string): string {
+  const sample = text.length > 1000 ? text.slice(-1000) : text
+  const normalized = sample.replace(/\s+/g, ' ').trim()
+  if (!normalized) return ''
+  const prefix = text.length > sample.length ? '...' : ''
+  if (normalized.length + prefix.length <= 120) return `${prefix}${normalized}`
+  return `${prefix}${normalized.slice(Math.max(0, normalized.length - (120 - prefix.length)))}`
+}
+
+export function clipTextForDisplay(text: string, maxChars: number): { text: string; omittedChars: number } {
+  if (text.length <= maxChars) return { text, omittedChars: 0 }
+  const rawStart = Math.max(0, text.length - maxChars)
+  const newline = text.indexOf('\n', rawStart)
+  const start = newline >= 0 && newline - rawStart <= 240 ? newline + 1 : rawStart
+  return {
+    text: text.slice(start),
+    omittedChars: start,
+  }
+}
+
+export function sanitizeReasoningForDisplay(text: string): string {
+  const normalized = text
+    .replace(/\r\n/g, '\n')
+    .replace(/\r/g, '\n')
+    .replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, '')
+  const controlCount = countMatches(normalized, /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F\uFFFD]/g)
+  const cleaned = normalized
+    .replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F\uFFFD]/g, '')
+    .replace(/\t/g, '  ')
+  const visibleLength = cleaned.replace(/\s/g, '').length
+  if (visibleLength === 0) return ''
+  if (controlCount > 0 && controlCount / Math.max(1, text.length) > 0.05) return UNREADABLE_REASONING_TEXT
+  if (looksLikeUnreadableReasoning(cleaned)) return UNREADABLE_REASONING_TEXT
+  return cleaned
+}
+
+function looksLikeUnreadableReasoning(text: string): boolean {
+  const visible = text.replace(/\s/g, '')
+  if (visible.length < 120) return false
+  const letters = countMatches(visible, /[A-Za-z]/g)
+  const digits = countMatches(visible, /\d/g)
+  const words = text.match(/[A-Za-z]{3,}/g) ?? []
+  const wordChars = words.reduce((sum, word) => sum + word.length, 0)
+  const whitespace = countMatches(text, /\s/g)
+  const symbolDensity = (visible.length - letters - digits) / visible.length
+  const wordDensity = wordChars / visible.length
+  const whitespaceDensity = whitespace / Math.max(1, text.length)
+  return symbolDensity > 0.38 && wordDensity < 0.32 && whitespaceDensity < 0.12
+}
+
+function countMatches(text: string, pattern: RegExp): number {
+  return text.match(pattern)?.length ?? 0
+}

package/src/chat/messageRows.ts

@@ -0,0 +1,43 @@
+import type { RowSlice } from './transcript/transcriptViewport.js'
+import type { MessageRow } from './MessageList.js'
+
+export function rowsToFullSlices(rows: MessageRow[]): Array<RowSlice<MessageRow>> {
+  return rows.map(row => ({ row, clipStart: 0, clipEnd: Number.MAX_SAFE_INTEGER, rowHeight: Number.MAX_SAFE_INTEGER }))
+}
+
+export function toggleLatestReasoningRow(rows: MessageRow[]): MessageRow[] {
+  return toggleInspectableRow(rows)
+}
+
+export function toggleReasoningRow(rows: MessageRow[], rowId?: string): MessageRow[] {
+  return toggleInspectableRow(rows, rowId)
+}
+
+export function toggleInspectableRow(rows: MessageRow[], rowId?: string): MessageRow[] {
+  let index = -1
+  if (rowId) {
+    index = rows.findIndex(row => row.id === rowId && isInspectableRole(row.role))
+  }
+  if (index === -1) {
+    for (let cursor = rows.length - 1; cursor >= 0; cursor -= 1) {
+      const role = rows[cursor]?.role
+      if (role && isInspectableRole(role)) {
+        index = cursor
+        break
+      }
+    }
+  }
+  if (index === -1) return rows
+  const row = rows[index]
+  if (!row) return rows
+  if (row.role === 'thinking') {
+    const next = rows.slice()
+    next[index] = { ...row, expanded: !row.expanded }
+    return next
+  }
+  return rows
+}
+
+function isInspectableRole(role: MessageRow['role']): boolean {
+  return role === 'thinking'
+}

package/src/chat/planImplementation.ts

@@ -0,0 +1,62 @@
+import type { SessionMessage } from '../storage/sessions.js'
+
+const MAX_HANDOFF_SUMMARY_CHARS = 12_000
+
+export function chatFooterShortcutText(_canScrollTranscript: boolean): string {
+  return 'alt+p model · alt+i identity'
+}
+
+export function buildPlanImplementationPrompt(plan: string): string {
+  return [
+    'Implement the approved plan below.',
+    '',
+    'Use native ethagent tools directly. Do not translate tool names into shell commands.',
+    'For workspace inspection, call list_directory and read_file directly.',
+    'For file creation or edits, call edit_file directly.',
+    'Use run_bash only for an actual shell command that cannot be performed by a narrower native tool, such as starting a local server after files exist.',
+    'Ignore any plan wording that says to execute file work as a Bash script or directly in the terminal; the native tools above are authoritative.',
+    'Read the relevant files before editing, make the required changes, and verify the result when possible.',
+    '',
+    plan,
+  ].join('\n')
+}
+
+export function buildPlanTransferSeedMessages(args: {
+  sourceSessionId: string
+  summary: string
+  plan: string
+  createdAt: string
+}): SessionMessage[] {
+  return [
+    {
+      role: 'user',
+      synthetic: true,
+      content: [
+        `Planning handoff from ${args.sourceSessionId.slice(0, 8)}:`,
+        '',
+        args.summary.trim(),
+      ].join('\n'),
+      createdAt: args.createdAt,
+    },
+    {
+      role: 'user',
+      synthetic: true,
+      content: [
+        'Approved plan to implement:',
+        '',
+        args.plan.trim(),
+      ].join('\n'),
+      createdAt: args.createdAt,
+    },
+  ]
+}
+
+export function normalizeHandoffSummary(summary: string): string {
+  const trimmed = summary.trim()
+  if (trimmed.length <= MAX_HANDOFF_SUMMARY_CHARS) return trimmed
+  return [
+    trimmed.slice(0, MAX_HANDOFF_SUMMARY_CHARS - 96).trimEnd(),
+    '',
+    '[handoff truncated to keep the resumed conversation responsive]',
+  ].join('\n')
+}

package/src/chat/slashCommandHandlers.ts

@@ -0,0 +1,165 @@
+import { clearIdentity, getIdentityStatus } from '../storage/identity.js'
+import { formatModelDisplayName } from '../models/modelDisplay.js'
+import { loadLocalHfModels } from '../models/huggingface.js'
+import type { SlashContext, SlashResult } from './commands.js'
+import { formatBytes } from './slashCommandViews.js'
+
+export async function runHuggingFace(args: string, ctx: SlashContext): Promise<SlashResult> {
+  const tokens = args.trim().split(/\s+/).filter(Boolean)
+  const sub = tokens[0]?.toLowerCase() ?? ''
+
+  if (!sub || sub === 'installed') {
+    const installed = await loadLocalHfModels()
+    if (installed.length === 0) {
+      return {
+        kind: 'note',
+        variant: 'dim',
+        text: 'No local model files downloaded. Press Alt+P and choose "Add Local Model File".',
+      }
+    }
+    const lines = installed.map(model => {
+      const marker = model.id === ctx.config.model && ctx.config.provider === 'llamacpp' ? '*' : ' '
+      const displayName = formatModelDisplayName('llamacpp', model.id, { displayName: model.displayName, maxLength: 64 })
+      return `${marker} ${displayName}  ${formatBytes(model.sizeBytes)}  ${model.risk}`
+    })
+    return { kind: 'note', text: ['installed Hugging Face models:', ...lines].join('\n') }
+  }
+
+  if (sub === 'download' || sub === 'model') {
+    const link = tokens.slice(1).join(' ')
+    ctx.onModelPickerRequest()
+    return {
+      kind: 'note',
+      variant: 'dim',
+      text: link
+        ? `Alt+P opened. Choose "Add Local Model File" and paste: ${link}`
+        : 'Alt+P opened. Choose "Add Local Model File" and paste the model URL or repo ID.',
+    }
+  }
+
+  return {
+    kind: 'note',
+    variant: 'error',
+    text: 'usage: /hf [installed|download <huggingface.co link or repo id>]',
+  }
+}
+
+export async function runMcp(args: string, ctx: SlashContext): Promise<SlashResult> {
+  if (!ctx.mcp) {
+    return { kind: 'note', variant: 'error', text: 'MCP runtime is not available in this session.' }
+  }
+
+  const tokens = args.trim().split(/\s+/).filter(Boolean)
+  const sub = tokens[0]?.toLowerCase() ?? ''
+  if (!sub || sub === 'status' || sub === 'list') {
+    return { kind: 'note', text: ctx.mcp.renderStatus(), variant: 'info' }
+  }
+
+  try {
+    if (sub === 'approve') {
+      const name = tokens.slice(1).join(' ')
+      if (!name) return { kind: 'note', variant: 'error', text: 'usage: /mcp approve <server>' }
+      return { kind: 'note', text: await ctx.mcp.approveServer(name), variant: 'dim' }
+    }
+    if (sub === 'reject') {
+      const name = tokens.slice(1).join(' ')
+      if (!name) return { kind: 'note', variant: 'error', text: 'usage: /mcp reject <server>' }
+      return { kind: 'note', text: await ctx.mcp.rejectServer(name), variant: 'dim' }
+    }
+    if (sub === 'reconnect') {
+      const name = tokens.slice(1).join(' ') || undefined
+      return { kind: 'note', text: await ctx.mcp.reconnect(name), variant: 'dim' }
+    }
+    if (sub === 'enable' || sub === 'disable') {
+      const name = tokens.slice(1).join(' ')
+      if (!name) return { kind: 'note', variant: 'error', text: `usage: /mcp ${sub} <server>` }
+      return { kind: 'note', text: await ctx.mcp.setEnabled(name, sub === 'enable'), variant: 'dim' }
+    }
+    if (sub === 'add-json') {
+      const project = tokens[1] === '--project'
+      const nameIndex = project ? 2 : 1
+      const name = tokens[nameIndex]
+      if (!name) return { kind: 'note', variant: 'error', text: 'usage: /mcp add-json [--project] <name> <json>' }
+      const jsonStart = nthTokenStart(args, nameIndex + 1)
+      const json = jsonStart >= 0 ? args.slice(jsonStart).trim() : ''
+      if (!json) return { kind: 'note', variant: 'error', text: 'usage: /mcp add-json [--project] <name> <json>' }
+      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: 'usage: /mcp [status|approve <server>|reject <server>|reconnect [server]|enable <server>|disable <server>|add-json [--project] <name> <json>]',
+  }
+}
+
+export async function runIdentity(args: string, ctx: SlashContext): Promise<SlashResult> {
+  const tokens = args.trim().split(/\s+/).filter(Boolean)
+  const sub = tokens[0]?.toLowerCase() ?? ''
+  const rest = tokens.slice(1)
+
+  if (!sub) {
+    ctx.onIdentityRequest('manage')
+    return { kind: 'handled' }
+  }
+
+  if (sub === 'status') {
+    const status = await getIdentityStatus(ctx.config)
+    if (!status) {
+      return {
+        kind: 'note',
+        variant: 'dim',
+        text: 'No Ethereum identity set. Run /identity create to make one.',
+      }
+    }
+    const lines = [
+      `address    ${status.address}`,
+      `created    ${status.createdAt}`,
+      `backend    ${status.backend}`,
+    ]
+    if (status.source) lines.push(`source     ${status.source}`)
+    if (status.agentId) lines.push(`token      #${status.agentId}`)
+    return { kind: 'note', text: lines.join('\n') }
+  }
+
+  if (sub === 'create') {
+    ctx.onIdentityRequest('create')
+    return { kind: 'handled' }
+  }
+
+  if (sub === 'load') {
+    ctx.onIdentityRequest('load')
+    return { kind: 'handled' }
+  }
+
+  if (sub === 'remove') {
+    if (rest[0] !== 'confirm') {
+      return {
+        kind: 'note',
+        variant: 'error',
+        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.' }
+    }
+    const next = await clearIdentity(ctx.config)
+    ctx.onReplaceConfig(next)
+    return { kind: 'note', text: `Removed identity ${status.address}.`, variant: 'dim' }
+  }
+
+  return {
+    kind: 'note',
+    variant: 'error',
+    text: 'usage: /identity [status|create|load|remove confirm]',
+  }
+}
+
+function nthTokenStart(value: string, tokenIndex: number): number {
+  const matches = [...value.matchAll(/\S+/g)]
+  return matches[tokenIndex]?.index ?? -1
+}