ethagent 3.3.4 → 4.0.0

package/src/chat/input/chatInputState.ts

@@ -1,247 +0,0 @@
-import {
-  cursorColumn,
-  cursorOnLastLineAtColumn,
-  getVisualLines,
-  moveVerticalVisualCursor,
-  moveVerticalCursor,
-  normalizeCursor,
-} from './textCursor.js'
-
-export type ChatBuffer = {
-  value: string
-  cursor: number
-}
-
-export type FileMentionToken = {
-  start: number
-  end: number
-  query: string
-}
-
-export type HistoryPreviewState = {
-  historyIndex: number | null
-  historyPreviewActive: boolean
-  draftBuffer: ChatBuffer
-  preferredColumn: number | null
-}
-
-export type VerticalMoveResult =
-  | { kind: 'moved'; cursor: number; preferredColumn: number }
-  | { kind: 'boundary-top'; cursor: number; preferredColumn: number }
-  | { kind: 'boundary-bottom'; cursor: number; preferredColumn: number }
-
-export function emptyBuffer(): ChatBuffer {
-  return { value: '', cursor: 0 }
-}
-
-export function bufferFromValue(value: string, cursor = value.length): ChatBuffer {
-  const next = normalizeCursor(value, cursor)
-  return { value: next.value, cursor: next.offset }
-}
-
-export function canNavigateHistory(
-  _buffer: ChatBuffer,
-  historyLength: number,
-  _historyIndex: number | null,
-  _historyPreviewActive: boolean,
-): boolean {
-  return historyLength > 0
-}
-
-export function beginHistoryPreview(
-  buffer: ChatBuffer,
-  history: string[],
-  direction: 1 | -1,
-  _preferredColumn: number | null,
-): { preview: HistoryPreviewState; buffer: ChatBuffer } | null {
-  if (history.length === 0) return null
-  const nextIndex = direction === -1 ? history.length - 1 : 0
-  const chosen = history[nextIndex] ?? ''
-  return {
-    preview: {
-      historyIndex: nextIndex,
-      historyPreviewActive: true,
-      draftBuffer: buffer,
-      preferredColumn: null,
-    },
-    buffer: bufferFromValue(chosen),
-  }
-}
-
-export function moveThroughHistory(
-  history: string[],
-  historyIndex: number,
-  direction: 1 | -1,
-  draftBuffer: ChatBuffer,
-  _preferredColumn: number | null,
-): { preview: HistoryPreviewState; buffer: ChatBuffer } {
-  const next = historyIndex + direction
-  if (next < 0) {
-    const chosen = history[0] ?? ''
-    return {
-      preview: {
-        historyIndex: 0,
-        historyPreviewActive: true,
-        draftBuffer,
-        preferredColumn: null,
-      },
-      buffer: bufferFromValue(chosen),
-    }
-  }
-  if (next >= history.length) {
-    return {
-      preview: {
-        historyIndex: null,
-        historyPreviewActive: false,
-        draftBuffer,
-        preferredColumn: null,
-      },
-      buffer: bufferFromValue(draftBuffer.value),
-    }
-  }
-  const chosen = history[next] ?? ''
-  return {
-    preview: {
-      historyIndex: next,
-      historyPreviewActive: true,
-      draftBuffer,
-      preferredColumn: null,
-    },
-    buffer: bufferFromValue(chosen),
-  }
-}
-
-export function exitHistoryPreview(
-  buffer: ChatBuffer,
-): { historyIndex: null; historyPreviewActive: false; draftBuffer: ChatBuffer; preferredColumn: null } {
-  return {
-    historyIndex: null,
-    historyPreviewActive: false,
-    draftBuffer: buffer,
-    preferredColumn: null,
-  }
-}
-
-export function bufferFromLastLine(value: string, preferredColumn: number | null = null): ChatBuffer {
-  const next = cursorOnLastLineAtColumn(value, preferredColumn ?? 0)
-  return { value: next.value, cursor: next.offset }
-}
-
-export function deleteToLineStart(buffer: ChatBuffer, wrapWidth: number): ChatBuffer {
-  const normalized = normalizeCursor(buffer.value, buffer.cursor)
-  const { value, offset } = normalized
-  if (offset <= 0) return { value, cursor: 0 }
-
-  if (value[offset - 1] === '\n') {
-    return {
-      value: value.slice(0, offset - 1) + value.slice(offset),
-      cursor: offset - 1,
-    }
-  }
-
-  const lineStart = visualLineStart(value, offset, wrapWidth)
-  return {
-    value: value.slice(0, lineStart) + value.slice(offset),
-    cursor: lineStart,
-  }
-}
-
-export function moveVertical(
-  text: string,
-  cursor: number,
-  direction: 1 | -1,
-  preferredColumn: number | null = null,
-): VerticalMoveResult {
-  const normalized = normalizeCursor(text, cursor)
-  const nextColumn = preferredColumn ?? cursorColumn(normalized.value, normalized.offset)
-  const moved = moveVerticalCursor(normalized, direction, nextColumn)
-  if (moved.moved) {
-    return { kind: 'moved', cursor: moved.cursor.offset, preferredColumn: nextColumn }
-  }
-  return {
-    kind: direction === -1 ? 'boundary-top' : 'boundary-bottom',
-    cursor: normalized.offset,
-    preferredColumn: nextColumn,
-  }
-}
-
-export function moveVerticalVisual(
-  text: string,
-  cursor: number,
-  direction: 1 | -1,
-  wrapWidth: number,
-  preferredColumn: number | null = null,
-): VerticalMoveResult {
-  const normalized = normalizeCursor(text, cursor)
-  const position = visualPosition(normalized.value, normalized.offset, wrapWidth)
-  const nextColumn = preferredColumn ?? position.column
-  const moved = moveVerticalVisualCursor(normalized, direction, wrapWidth, nextColumn)
-  if (moved.moved) {
-    return { kind: 'moved', cursor: moved.cursor.offset, preferredColumn: nextColumn }
-  }
-  return {
-    kind: direction === -1 ? 'boundary-top' : 'boundary-bottom',
-    cursor: normalized.offset,
-    preferredColumn: nextColumn,
-  }
-}
-
-export function detectActiveFileMention(value: string, cursor: number): FileMentionToken | undefined {
-  const safeCursor = Math.max(0, Math.min(cursor, value.length))
-  const left = value.slice(0, safeCursor)
-  const atIndex = left.lastIndexOf('@')
-  if (atIndex === -1) return undefined
-  const before = atIndex === 0 ? '' : value[atIndex - 1]
-  if (before && !/\s|\(|\[|\{/.test(before)) return undefined
-  const between = value.slice(atIndex + 1, safeCursor)
-  if (/\s/.test(between)) return undefined
-  let end = safeCursor
-  while (end < value.length && !/\s/.test(value[end]!)) end += 1
-  return { start: atIndex, end, query: between }
-}
-
-export function replaceActiveFileMention(buffer: ChatBuffer, replacementPath: string): ChatBuffer {
-  const mention = detectActiveFileMention(buffer.value, buffer.cursor)
-  if (!mention) return buffer
-  const replacement = `@${replacementPath}`
-  const value = buffer.value.slice(0, mention.start) + replacement + buffer.value.slice(mention.end)
-  return { value, cursor: mention.start + replacement.length }
-}
-
-function visualPosition(value: string, offset: number, wrapWidth: number): { column: number } {
-  const lines = getVisualLines(value, wrapWidth)
-  for (const entry of lines) {
-    if (entry.start === entry.end && offset === entry.start) {
-      return { column: 0 }
-    }
-    if (offset >= entry.start && offset < entry.end) {
-      return { column: offset - entry.start }
-    }
-  }
-
-  for (let index = lines.length - 1; index >= 0; index -= 1) {
-    const entry = lines[index]!
-    if (offset === entry.end) {
-      return { column: entry.end - entry.start }
-    }
-  }
-
-  return { column: 0 }
-}
-
-function visualLineStart(value: string, offset: number, wrapWidth: number): number {
-  const lines = getVisualLines(value, wrapWidth)
-  for (let index = 0; index < lines.length; index += 1) {
-    const entry = lines[index]!
-    if (entry.start === entry.end && offset === entry.start) return entry.start
-    if (offset > entry.start && offset <= entry.end) return entry.start
-    if (offset === entry.start) {
-      const previous = lines[index - 1]
-      if (previous && previous.end === entry.start) return previous.start
-      return entry.start
-    }
-  }
-
-  const last = lines[lines.length - 1]
-  return last ? last.start : 0
-}

package/src/chat/input/chatPaste.ts

@@ -1,49 +0,0 @@
-export const LARGE_PASTE_THRESHOLD = 800
-
-export type PastedTextRef = {
-  id: number
-  content: string
-}
-
-export function normalizePastedText(text: string): string {
-  return text
-    .replaceAll('\x1b[200~', '')
-    .replaceAll('\x1b[201~', '')
-    .replace(/(^|\n)(?:\[?200~|\[?201~)(?=\n|$)/g, '$1')
-    .replace(/\r\n/g, '\n')
-    .replace(/\r/g, '\n')
-}
-
-export function shouldCollapsePastedText(
-  text: string,
-  maxInlineLines: number,
-  threshold = LARGE_PASTE_THRESHOLD,
-): boolean {
-  return text.length > threshold || countPastedTextLineBreaks(text) > maxInlineLines
-}
-
-export function countPastedTextLineBreaks(text: string): number {
-  return (text.match(/\n/g) ?? []).length
-}
-
-export function formatPastedTextRef(id: number, chars: number): string {
-  return `[Pasted Content ${chars} chars #${id}]`
-}
-
-export function expandPastedTextRefs(input: string, refs: Map<number, PastedTextRef>): string {
-  const matches = [...input.matchAll(/\[Pasted Content (\d+) chars #(\d+)\]/g)]
-  let expanded = input
-
-  for (let index = matches.length - 1; index >= 0; index -= 1) {
-    const match = matches[index]!
-    const id = Number(match[2])
-    const ref = refs.get(id)
-    if (!ref) continue
-    expanded =
-      expanded.slice(0, match.index) +
-      ref.content +
-      expanded.slice((match.index ?? 0) + match[0].length)
-  }
-
-  return expanded
-}

package/src/chat/input/imageRefs.ts

@@ -1,30 +0,0 @@
-export type ImageRef = { path: string; mimeType?: string }
-
-const IMAGE_REF_MARKER_RE = /\[Image\s+#(\d+)\]/g
-
-export function expandImageRefs(text: string, refs: Map<number, ImageRef>): string {
-  return text.replace(IMAGE_REF_MARKER_RE, (full, raw: string) => {
-    const ref = refs.get(Number(raw))
-    return ref ? `[image: ${ref.path}]` : full
-  })
-}
-
-export function referencedImageIds(text: string): Set<number> {
-  const out = new Set<number>()
-  for (const match of text.matchAll(IMAGE_REF_MARKER_RE)) {
-    const id = Number(match[1])
-    if (Number.isFinite(id)) out.add(id)
-  }
-  return out
-}
-
-export function pruneImageRefs(refs: Map<number, ImageRef>, text: string): void {
-  const referenced = referencedImageIds(text)
-  for (const id of [...refs.keys()]) {
-    if (!referenced.has(id)) refs.delete(id)
-  }
-}
-
-export function formatImageRefMarker(id: number): string {
-  return `[Image #${id}]`
-}

package/src/chat/input/inputRendering.tsx

@@ -1,93 +0,0 @@
-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/input/textCursor.ts

@@ -1,212 +0,0 @@
-import wrapAnsi from 'wrap-ansi'
-
-export type TextCursor = {
-  value: string
-  offset: number
-}
-
-export type CursorMoveResult = {
-  cursor: TextCursor
-  moved: boolean
-}
-
-export type VisualLine = {
-  start: number
-  end: number
-}
-
-export type VisualLineWindow = {
-  start: number
-  end: number
-}
-
-export function normalizeCursor(value: string, offset: number): TextCursor {
-  return { value, offset: clampOffset(value, offset) }
-}
-
-export function moveLeft(cursor: TextCursor): TextCursor {
-  return normalizeCursor(cursor.value, cursor.offset - 1)
-}
-
-export function moveRight(cursor: TextCursor): TextCursor {
-  return normalizeCursor(cursor.value, cursor.offset + 1)
-}
-
-export function moveVerticalCursor(
-  cursor: TextCursor,
-  direction: 1 | -1,
-  preferredColumn?: number,
-): CursorMoveResult {
-  const lines = getLogicalLines(cursor.value)
-  const position = positionFromOffset(lines, cursor.offset)
-  const targetLine = position.line + direction
-  if (targetLine < 0 || targetLine >= lines.length) {
-    return { cursor, moved: false }
-  }
-  const targetOffset = offsetFromPosition(lines, targetLine, preferredColumn ?? position.column)
-  return {
-    cursor: normalizeCursor(cursor.value, targetOffset),
-    moved: targetOffset !== cursor.offset,
-  }
-}
-
-export function getVisualLines(value: string, wrapWidth: number): VisualLine[] {
-  const safeWrapWidth = Math.max(1, Math.floor(wrapWidth))
-  const lines: VisualLine[] = []
-  let start = 0
-
-  for (let index = 0; index <= value.length; index += 1) {
-    if (index !== value.length && value[index] !== '\n') continue
-
-    const end = index
-    if (start === end) {
-      lines.push({ start, end })
-    } else {
-      const logical = value.slice(start, end)
-      const wrapped = wrapAnsi(logical, safeWrapWidth, { trim: false, hard: true, wordWrap: true })
-      const wrappedLines = wrapped.split('\n')
-      let cursor = start
-      let lastEnd = start
-      for (const line of wrappedLines) {
-        const lineEnd = cursor + line.length
-        lines.push({ start: cursor, end: lineEnd })
-        cursor = lineEnd
-        lastEnd = lineEnd
-      }
-      if (end === value.length && lastEnd === end && wrappedLines[wrappedLines.length - 1]!.length === safeWrapWidth) {
-        lines.push({ start: end, end })
-      }
-    }
-    start = index + 1
-  }
-
-  return lines.length > 0 ? lines : [{ start: 0, end: 0 }]
-}
-
-export function getVisualLineIndex(lines: VisualLine[], offset: number): number {
-  return visualPositionFromOffset(lines, offset).line
-}
-
-export function getVisibleVisualLineWindow(
-  totalLines: number,
-  cursorLine: number,
-  maxVisibleLines: number,
-): VisualLineWindow {
-  const safeTotal = Math.max(0, Math.floor(totalLines))
-  if (safeTotal === 0) return { start: 0, end: 0 }
-
-  const safeMaxVisible = Math.max(1, Math.floor(maxVisibleLines))
-  if (safeTotal <= safeMaxVisible) return { start: 0, end: safeTotal }
-
-  const safeCursorLine = Math.max(0, Math.min(Math.floor(cursorLine), safeTotal - 1))
-  const half = Math.floor(safeMaxVisible / 2)
-  const start = Math.max(0, Math.min(
-    safeCursorLine - half,
-    safeTotal - safeMaxVisible,
-  ))
-
-  return { start, end: start + safeMaxVisible }
-}
-
-export function moveVerticalVisualCursor(
-  cursor: TextCursor,
-  direction: 1 | -1,
-  wrapWidth: number,
-  preferredColumn?: number,
-): CursorMoveResult {
-  const lines = getVisualLines(cursor.value, wrapWidth)
-  const position = visualPositionFromOffset(lines, cursor.offset)
-  const targetLine = position.line + direction
-  if (targetLine < 0 || targetLine >= lines.length) {
-    return { cursor, moved: false }
-  }
-  const target = lines[targetLine]!
-  const targetColumn = Math.min(preferredColumn ?? position.column, target.end - target.start)
-  const targetOffset = target.start + Math.max(0, targetColumn)
-  return {
-    cursor: normalizeCursor(cursor.value, targetOffset),
-    moved: targetOffset !== cursor.offset,
-  }
-}
-
-export function cursorOnLastLine(value: string, _offset: number): TextCursor {
-  const lines = getLogicalLines(value)
-  const lastLine = Math.max(0, lines.length - 1)
-  return normalizeCursor(value, offsetFromPosition(lines, lastLine, 0))
-}
-
-export function cursorOnLastLineAtColumn(value: string, column: number): TextCursor {
-  const lines = getLogicalLines(value)
-  const lastLine = Math.max(0, lines.length - 1)
-  return normalizeCursor(value, offsetFromPosition(lines, lastLine, column))
-}
-
-export function cursorColumn(value: string, offset: number): number {
-  return positionFromOffset(getLogicalLines(value), clampOffset(value, offset)).column
-}
-
-type LogicalLine = {
-  start: number
-  end: number
-}
-
-function getLogicalLines(value: string): LogicalLine[] {
-  const lines: LogicalLine[] = []
-  let start = 0
-  for (let index = 0; index < value.length; index += 1) {
-    if (value[index] === '\n') {
-      lines.push({ start, end: index })
-      start = index + 1
-    }
-  }
-  lines.push({ start, end: value.length })
-  return lines
-}
-
-function positionFromOffset(lines: LogicalLine[], rawOffset: number): { line: number; column: number } {
-  const offset = Math.max(0, rawOffset)
-  for (let line = 0; line < lines.length; line += 1) {
-    const entry = lines[line]!
-    const next = lines[line + 1]
-    if (!next || offset < next.start) {
-      return {
-        line,
-        column: Math.max(0, Math.min(offset, entry.end) - entry.start),
-      }
-    }
-  }
-  const last = lines[lines.length - 1]!
-  return { line: lines.length - 1, column: last.end - last.start }
-}
-
-function offsetFromPosition(lines: LogicalLine[], line: number, column: number): number {
-  const entry = lines[Math.max(0, Math.min(line, lines.length - 1))]!
-  return entry.start + Math.min(Math.max(0, column), entry.end - entry.start)
-}
-
-function visualPositionFromOffset(lines: VisualLine[], rawOffset: number): { line: number; column: number } {
-  const offset = Math.max(0, rawOffset)
-  for (let line = 0; line < lines.length; line += 1) {
-    const entry = lines[line]!
-    if (entry.start === entry.end && offset === entry.start) {
-      return { line, column: 0 }
-    }
-    if (offset >= entry.start && offset < entry.end) {
-      return { line, column: offset - entry.start }
-    }
-  }
-
-  for (let line = lines.length - 1; line >= 0; line -= 1) {
-    const entry = lines[line]!
-    if (offset === entry.end) {
-      return { line, column: entry.end - entry.start }
-    }
-  }
-
-  const last = lines[lines.length - 1]!
-  return { line: lines.length - 1, column: last.end - last.start }
-}
-
-function clampOffset(value: string, offset: number): number {
-  return Math.max(0, Math.min(value.length, offset))
-}