ethagent 3.3.4 → 4.0.0

package/src/chat/SessionStatus.tsx

@@ -1,53 +0,0 @@
-import React from 'react'
-import { Box, Text } from 'ink'
-import type { ContextUsage } from '../runtime/compaction.js'
-import { theme } from '../ui/theme.js'
-import { formatModelDisplayName } from '../models/modelDisplay.js'
-import { providerDisplayName } from '../models/providerDisplay.js'
-import type { ProviderId } from '../storage/config.js'
-
-type StatusBarProps = {
-  provider: string
-  model: string
-  turns: number
-  approxTokens: number
-  startedAt: number
-  contextUsage: ContextUsage
-}
-
-const SessionStatusInner: React.FC<StatusBarProps> = ({
-  provider,
-  model,
-  turns,
-  approxTokens,
-  startedAt,
-  contextUsage,
-}) => {
-  const displayModel = formatModelDisplayName(provider, model, { maxLength: 24 })
-  return (
-    <Box flexDirection="row">
-      <Text color={theme.dim}>
-        {providerDisplayName(provider as ProviderId)} · {displayModel} · {turns} {turns === 1 ? 'turn' : 'turns'} · ~{formatTokens(approxTokens)} tokens · Context {contextUsage.percent}% (~{formatTokens(contextUsage.usedTokens)} / {formatTokens(contextUsage.windowTokens)}) · {formatElapsed(Date.now() - startedAt)}
-      </Text>
-    </Box>
-  )
-}
-
-export const SessionStatus = React.memo(SessionStatusInner)
-
-export function formatTokens(count: number): string {
-  if (count < 1000) return String(count)
-  if (count < 10_000) return `${(count / 1000).toFixed(1)}k`
-  return `${Math.round(count / 1000)}k`
-}
-
-export function formatElapsed(ms: number): string {
-  const seconds = Math.max(0, Math.floor(ms / 1000))
-  if (seconds < 60) return `${seconds}s`
-  const minutes = Math.floor(seconds / 60)
-  const rem = seconds % 60
-  if (minutes < 60) return `${minutes}m${rem.toString().padStart(2, '0')}s`
-  const hours = Math.floor(minutes / 60)
-  const minRem = minutes % 60
-  return `${hours}h${minRem.toString().padStart(2, '0')}m`
-}

package/src/chat/chatEnvironment.ts

@@ -1,16 +0,0 @@
-import os from 'node:os'
-import path from 'node:path'
-import type { EthagentConfig } from '../storage/config.js'
-import { ensureLlamaCppRunnerReady } from '../models/llamacppPreflight.js'
-
-export function compressHome(cwd: string): string {
-  const home = os.homedir()
-  if (cwd === home) return '~'
-  if (cwd.startsWith(home + path.sep)) return '~' + cwd.slice(home.length).replace(/\\/g, '/')
-  return cwd.replace(/\\/g, '/')
-}
-
-export async function ensureLocalProviderReady(config: EthagentConfig): Promise<{ ok: true } | { ok: false; message: string }> {
-  if (config.provider === 'llamacpp') return ensureLlamaCppRunnerReady(config)
-  return { ok: true }
-}

package/src/chat/chatScreenUtils.ts

@@ -1,194 +0,0 @@
-import { systemMessage } from '../utils/messages.js'
-import { buildSystemPrompt } from '../runtime/systemPrompt.js'
-import type { Message } from '../providers/contracts.js'
-import { isLocalProvider } from '../providers/registry.js'
-import type { SessionMode } from '../runtime/sessionMode.js'
-import type { EthagentConfig } from '../storage/config.js'
-import {
-  latestUserMessageCorrectsToolState,
-  sessionMessagesToProviderMessages,
-  TOOL_CORRECTION_CONTEXT_MESSAGE,
-  type SessionMessage,
-} from '../storage/sessions.js'
-import type { MessageRow } from './MessageList.js'
-import { hidesSuccessfulToolResultContent, toolResultDiffContent, toolResultTextContent } from './display/toolResultDisplay.js'
-
-export type TurnCheckpoint = {
-  sessionId: string
-  turnId: string
-  messageRole: 'user'
-  promptSnippet: string
-  checkpointLabel: string
-}
-
-export function buildBaseMessages(
-  sessionMessages: SessionMessage[],
-  config: EthagentConfig,
-  hasTools: boolean,
-  cwd: string,
-  mode: SessionMode = 'chat',
-  options: { preserveTurnId?: string; compactToolHistory?: boolean } = {},
-): Message[] {
-  const compactToolHistory = options.compactToolHistory ?? isLocalProvider(config.provider)
-  const correctionContext = latestUserMessageCorrectsToolState(sessionMessages)
-    ? [systemMessage(TOOL_CORRECTION_CONTEXT_MESSAGE)]
-    : []
-  return [
-    systemMessage(buildSystemPrompt({
-      cwd,
-      model: config.model,
-      provider: config.provider,
-      hasTools,
-      hasIdentity: Boolean(config.identity),
-      mode,
-    })),
-    ...correctionContext,
-    ...sessionMessagesToProviderMessages(sessionMessages, {
-      compactToolHistory,
-      preserveTurnId: options.preserveTurnId,
-    }),
-  ]
-}
-
-export function sessionMessagesToRows(messages: SessionMessage[], nextRowId: () => string): MessageRow[] {
-  const restored: MessageRow[] = []
-  const toolCallByUseId = new Map<string, Extract<MessageRow, { role: 'tool_call' }>>()
-  for (const msg of messages) {
-    if (msg.role === 'user') restored.push({ role: 'user', id: nextRowId(), content: msg.content })
-    else if (msg.role === 'assistant') restored.push({ role: 'assistant', id: nextRowId(), content: msg.content })
-    else if (msg.role === 'tool_use') {
-      const row: Extract<MessageRow, { role: 'tool_call' }> = {
-        role: 'tool_call',
-        id: nextRowId(),
-        name: msg.name,
-        summary: msg.name,
-        input: msg.input,
-      }
-      restored.push(row)
-      toolCallByUseId.set(msg.toolUseId, row)
-    } else if (msg.role === 'tool_result') {
-      const isError = Boolean(msg.isError)
-      const summary = isError ? `${msg.name} failed` : `${msg.name} completed`
-      const content = toolResultContentForRow(msg.name, msg.content, msg.isError)
-      const diff = toolResultDiffForRow(msg.content, msg.isError)
-      const existing = toolCallByUseId.get(msg.toolUseId)
-      if (existing) {
-        existing.result = diff ? { content, summary, isError, diff } : { content, summary, isError }
-        existing.name = msg.name
-      } else {
-        restored.push({
-          role: 'tool_call',
-          id: nextRowId(),
-          name: msg.name,
-          summary: msg.name,
-          result: diff ? { content, summary, isError, diff } : { content, summary, isError },
-        })
-      }
-    }
-  }
-  return restored
-}
-
-export function truncateForRow(text: string, max = 1200): string {
-  if (text.length <= max) return text
-  return `${text.slice(0, max - 3)}...`
-}
-
-export function toolResultContentForRow(name: string, content: string, isError?: boolean): string {
-  const textContent = toolResultTextContent(content)
-  return hidesSuccessfulToolResultContent(name, isError) ? '' : truncateForRow(textContent)
-}
-
-export function toolResultDiffForRow(content: string, isError?: boolean): string | undefined {
-  return toolResultDiffContent(content, isError)
-}
-
-export function splitStreamingContent(text: string): { committed: string; liveTail: string } {
-  if (!text) return { committed: '', liveTail: '' }
-  const boundary = findStableBoundary(text)
-  if (boundary <= 0 || boundary >= text.length) {
-    return { committed: boundary >= text.length ? text : '', liveTail: boundary >= text.length ? '' : text }
-  }
-  return { committed: text.slice(0, boundary), liveTail: text.slice(boundary) }
-}
-
-export function findStableBoundary(text: string): number {
-  let lastStructural = 0
-  let lastSentence = 0
-  let inFence = false
-  let offset = 0
-  const lines = text.match(/[^\n]*\n?|$/g)?.filter(Boolean) ?? []
-
-  for (const lineWithEnding of lines) {
-    const line = lineWithEnding.endsWith('\n') ? lineWithEnding.slice(0, -1) : lineWithEnding
-    const trimmed = line.trim()
-    const nextOffset = offset + lineWithEnding.length
-
-    if (/^```/.test(trimmed)) {
-      inFence = !inFence
-      if (!inFence) lastStructural = nextOffset
-      offset = nextOffset
-      continue
-    }
-
-    if (!inFence) {
-      if (!trimmed) {
-        lastStructural = nextOffset
-      } else if (/^(#{1,3}\s|>\s?|[-*+]\s|\d+\.\s)/.test(trimmed)) {
-        lastStructural = nextOffset
-      }
-
-      let match: RegExpExecArray | null
-      const sentencePattern = /[.!?]["')\]]?(?=\s|$)/g
-      while ((match = sentencePattern.exec(line)) !== null) {
-        lastSentence = offset + match.index + match[0].length
-      }
-    }
-
-    offset = nextOffset
-  }
-
-  if (inFence) return lastStructural
-  if (lastStructural > 0) return lastStructural
-  if (text.length > 220 && lastSentence > 0) return lastSentence
-  if (text.length > 320) {
-    const fallbackSpace = text.lastIndexOf(' ', Math.max(160, text.length - 80))
-    if (fallbackSpace > 80) return fallbackSpace + 1
-  }
-  return 0
-}
-
-export function formatBytes(bytes: number): string {
-  if (bytes <= 0) return '0B'
-  const gb = bytes / (1024 * 1024 * 1024)
-  if (gb >= 1) return `${gb.toFixed(2)}GB`
-  const mb = bytes / (1024 * 1024)
-  if (mb >= 1) return `${mb.toFixed(0)}MB`
-  const kb = bytes / 1024
-  return `${kb.toFixed(0)}KB`
-}
-
-export function createTurnCheckpoint(sessionId: string, userText: string): TurnCheckpoint {
-  const promptSnippet = summarizePrompt(userText)
-  return {
-    sessionId,
-    turnId: `turn-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-    messageRole: 'user',
-    promptSnippet,
-    checkpointLabel: promptSnippet || 'Untitled checkpoint',
-  }
-}
-
-export function summarizePrompt(text: string): string {
-  const normalized = text.replace(/\s+/g, ' ').trim()
-  if (!normalized) return ''
-  return normalized.length <= 96 ? normalized : `${normalized.slice(0, 93)}...`
-}
-
-export function buildDeleteCommand(targetPath: string): string {
-  const escaped = targetPath.replace(/"/g, '""')
-  if (process.platform === 'win32') {
-    return `del /f /q "${escaped}"`
-  }
-  return `rm -f -- "${targetPath.replace(/"/g, '\\"')}"`
-}

package/src/chat/chatSessionState.ts

@@ -1,146 +0,0 @@
-import { localProviderBaseUrlFor, type EthagentConfig } from '../storage/config.js'
-import type { SessionMetadata, SessionMessage } from '../storage/sessions.js'
-import type { SessionMode } from '../runtime/sessionMode.js'
-import type { MessageRow } from './MessageList.js'
-import type { ModelPickerSelection } from '../models/ModelPicker.js'
-import { sessionMessagesToRows } from './chatScreenUtils.js'
-import { formatModelDisplayName } from '../models/modelDisplay.js'
-import { providerDisplayName } from '../models/modelPickerOptions.js'
-
-export type ModelSelectionResolution =
-  | { kind: 'noop' }
-  | {
-      kind: 'switch'
-      config: EthagentConfig
-      notice: string
-      tone: 'info' | 'dim'
-    }
-
-export type ResumedSessionState = {
-  cwd: string
-  mode: SessionMode
-  rows: MessageRow[]
-  promptHistory: string[]
-  statusStartedAt: number
-}
-
-const MAX_PROMPT_HISTORY = 500
-
-export function resolveModelSelection(
-  selection: ModelPickerSelection,
-  currentConfig: EthagentConfig,
-): ModelSelectionResolution {
-  if (selection.kind === 'llamacpp') {
-    const baseUrl = localProviderBaseUrlFor(
-      'llamacpp',
-      currentConfig.provider === 'llamacpp' ? currentConfig.baseUrl : undefined,
-    )
-    if (
-      selection.model === currentConfig.model
-      && currentConfig.provider === 'llamacpp'
-      && currentConfig.baseUrl === baseUrl
-      && currentConfig.localMmprojPath === selection.mmprojPath
-    ) {
-      return { kind: 'noop' }
-    }
-    return {
-      kind: 'switch',
-      config: {
-        ...currentConfig,
-        provider: 'llamacpp',
-        model: selection.model,
-        baseUrl,
-        localMmprojPath: selection.mmprojPath,
-      },
-      notice: `llama.cpp ready. Now using ${formatModelDisplayName('llamacpp', selection.model, { maxLength: 64 })}${selection.mmprojPath ? ' · vision' : ''}.`,
-      tone: 'info',
-    }
-  }
-
-  const nextProvider = selection.provider
-  const nextBaseUrl =
-    nextProvider === 'openai' && currentConfig.provider === 'openai'
-      ? currentConfig.baseUrl
-      : undefined
-  const nextConfig: EthagentConfig = {
-    ...currentConfig,
-    provider: nextProvider,
-    model: selection.model,
-    baseUrl: nextBaseUrl,
-    localMmprojPath: undefined,
-  }
-
-  return {
-    kind: 'switch',
-    config: nextConfig,
-    notice: `${selection.keyJustSet ? `${providerDisplayName(selection.provider)} key saved.` : `${providerDisplayName(selection.provider)} ready.`} Now using ${providerDisplayName(nextConfig.provider)} · ${formatModelDisplayName(nextConfig.provider, nextConfig.model, { maxLength: 64 })}.`,
-    tone: 'dim',
-  }
-}
-
-export function buildResumedSessionState(args: {
-  messages: SessionMessage[]
-  metadata: SessionMetadata | null
-  fallbackCwd: string
-  nextRowId: () => string
-}): ResumedSessionState {
-  const cwd = args.metadata?.lastCwd ?? args.metadata?.workspaceRoot ?? args.fallbackCwd
-  return {
-    cwd,
-    mode: args.metadata?.mode ?? 'chat',
-    rows: [
-      ...sessionMessagesToRows(args.messages, args.nextRowId),
-      {
-        role: 'note',
-        id: args.nextRowId(),
-        kind: 'dim',
-        content: formatResumeNote(args.metadata),
-      },
-    ],
-    promptHistory: promptHistoryFromSessionMessages(args.messages),
-    statusStartedAt: Date.now(),
-  }
-}
-
-function formatResumeNote(metadata: SessionMetadata | null): string {
-  const id = metadata?.id?.slice(0, 8) ?? ''
-  const source = metadata?.compactedFromSessionId ? ` summarized from ${metadata.compactedFromSessionId.slice(0, 8)}` : ''
-  return `Resumed from session ${id}.${source}`.trim()
-}
-
-export function restoreConversationState(
-  messages: SessionMessage[],
-  turnId: string,
-  nextRowId: () => string,
-): {
-  messages: SessionMessage[]
-  rows: MessageRow[]
-  promptHistory: string[]
-  truncated: boolean
-} {
-  const firstIndex = messages.findIndex(message => message.turnId === turnId)
-  const nextMessages =
-    firstIndex >= 0
-      ? messages.slice(0, firstIndex)
-      : messages.filter(message => message.turnId !== turnId)
-
-  return {
-    messages: nextMessages,
-    rows: sessionMessagesToRows(nextMessages, nextRowId),
-    promptHistory: promptHistoryFromSessionMessages(nextMessages),
-    truncated: firstIndex >= 0,
-  }
-}
-
-export function promptHistoryFromSessionMessages(messages: SessionMessage[]): string[] {
-  const prompts: string[] = []
-  for (const message of messages) {
-    if (message.role !== 'user') continue
-    if (message.synthetic) continue
-    const prompt = message.content.trim()
-    if (!prompt) continue
-    if (prompts[prompts.length - 1] === prompt) continue
-    prompts.push(prompt)
-  }
-  return prompts.slice(-MAX_PROMPT_HISTORY)
-}

package/src/chat/chatTurnContext.ts

@@ -1,50 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import type { Message } from '../providers/contracts.js'
-
-export async function buildFileMentionContextMessages(
-  userText: string,
-  cwd: string,
-): Promise<Message[]> {
-  const mentions = extractFileMentions(userText)
-  if (mentions.length === 0) return []
-
-  const lines: string[] = []
-  for (const mention of mentions) {
-    const resolved = path.resolve(cwd, mention)
-    const rel = path.relative(cwd, resolved)
-    if (rel.startsWith('..') || path.isAbsolute(rel)) {
-      lines.push(
-        `@${mention} -> outside current workspace; do not use unless the user changes directory or names an allowed path.`,
-      )
-      continue
-    }
-    try {
-      const stats = await fs.stat(resolved)
-      lines.push(`@${mention} -> ${mention} (${stats.isDirectory() ? 'directory' : 'file'})`)
-    } catch {
-      lines.push(`@${mention} -> unresolved`)
-    }
-  }
-
-  return [
-    {
-      role: 'user',
-      content: [
-        'Resolved file mentions for this request:',
-        ...lines,
-        'Treat these mentions as authoritative filenames from the user request. Read referenced context files when needed, and edit only the file requested by the user or the target file you have inspected.',
-      ].join('\n'),
-    },
-  ]
-}
-
-function extractFileMentions(text: string): string[] {
-  const mentions = new Set<string>()
-  for (const match of text.matchAll(/@([^\s]+)/g)) {
-    const raw = match[1]?.replace(/[),.;:!?]+$/g, '')
-    if (!raw || raw.length === 0) continue
-    mentions.add(raw.replace(/\\/g, '/'))
-  }
-  return [...mentions]
-}