ethagent 3.3.4 → 4.0.0

package/src/tools/readSkillTool.ts

@@ -1,107 +0,0 @@
-import path from 'node:path'
-import { z } from 'zod'
-import {
-  continuityVaultRef,
-} from '../identity/continuity/storage.js'
-import {
-  readSkill,
-  readSkillFile,
-} from '../identity/continuity/skills/loadSkills.js'
-import type { Tool } from './contracts.js'
-
-const schema = z.object({
-  name: z.string().min(1),
-  file: z.string().min(1).optional(),
-})
-
-export const readSkillTool: Tool<typeof schema> = {
-  name: 'read_private_skill',
-  kind: 'private-continuity-read',
-  readOnly: true,
-  description: [
-    'Read a file from the owner-authored private skill folder for the active identity.',
-    'Pass the skill folder name as `name` (e.g. "writing-obit"). Without `file`, returns the SKILL.md entry point.',
-    'With `file`, returns a supporting file from the same folder (e.g. file: "references/api.md"). Supporting-file responses include an absolute filesystem `path=` attribute; run executable scripts via run_bash using that absolute path.',
-    'List available supporting files with list_private_skill_files. Bodies are markdown and may include private instructions; treat them like SOUL.md guidance.',
-  ].join(' '),
-  inputSchema: schema,
-  inputSchemaJson: {
-    type: 'object',
-    properties: {
-      name: { type: 'string', description: 'Skill folder name from the private skills index, e.g. "writing-obit".' },
-      file: { type: 'string', description: 'Optional supporting file path inside the skill folder. Defaults to SKILL.md.' },
-    },
-    required: ['name'],
-    additionalProperties: false,
-  },
-  parse(input) {
-    return schema.parse(input)
-  },
-  async buildPermissionRequest(input, context) {
-    const identity = context.config?.identity
-    if (!identity) throw new Error('No active identity; create or load an identity before reading a private skill')
-    const ref = continuityVaultRef(identity)
-    const folder = input.name.replace(/^.*:/, '')
-    const file = input.file ?? 'SKILL.md'
-    const skillPath = path.join(ref.skillsDir, folder, file)
-    const display = input.file ? `${folder}/${input.file}` : `${folder}/SKILL.md`
-    return {
-      kind: 'private-skill-read',
-      path: skillPath,
-      relativePath: `identity-vault/skills/${display}`,
-      directoryPath: path.dirname(skillPath),
-      title: 'Allow private skill read?',
-      subtitle: `Load ${display}`,
-      skillName: input.name,
-      mode: 'read',
-    }
-  },
-  async execute(input, context) {
-    const identity = context.config?.identity
-    if (!identity) {
-      return { ok: false, summary: 'no active identity', content: 'No active identity; cannot read private skill.' }
-    }
-    try {
-      const folder = input.name.replace(/^.*:/, '')
-      if (input.file && input.file !== 'SKILL.md') {
-        const result = await readSkillFile(identity, folder, input.file)
-        return {
-          ok: true,
-          summary: `read ${result.relativePath}`,
-          content: [
-            `<private_skill_file name="${folder}" file="${input.file}" path="${result.absolutePath}">`,
-            result.content,
-            '</private_skill_file>',
-          ].join('\n'),
-        }
-      }
-      const skill = await readSkill(identity, folder)
-      const meta: string[] = []
-      meta.push(`name: ${skill.displayName ?? skill.name}`)
-      if (skill.whenToUse) meta.push(`when_to_use: ${skill.whenToUse}`)
-      if (skill.argumentHint) meta.push(`argument_hint: ${skill.argumentHint}`)
-      if (skill.version) meta.push(`version: ${skill.version}`)
-      if (skill.tags && skill.tags.length > 0) meta.push(`tags: ${skill.tags.join(', ')}`)
-      meta.push(`visibility: ${skill.visibility}`)
-      const content = [
-        `<private_skill name="${skill.name}" visibility="${skill.visibility}">`,
-        ...meta,
-        '',
-        skill.body,
-        '</private_skill>',
-      ].join('\n')
-      return {
-        ok: true,
-        summary: `read private skill ${skill.name}`,
-        content,
-      }
-    } catch (err: unknown) {
-      const message = (err as Error).message
-      return {
-        ok: false,
-        summary: 'read failed',
-        content: message,
-      }
-    }
-  },
-}

package/src/tools/readTool.ts

@@ -1,85 +0,0 @@
-import fs from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-import { z } from 'zod'
-import type { EthagentConfig } from '../storage/config.js'
-import type { Tool } from './contracts.js'
-
-const schema = z.object({
-  path: z.string().min(1),
-  startLine: z.number().int().positive().optional(),
-  endLine: z.number().int().positive().optional(),
-})
-
-export const readTool: Tool<typeof schema> = {
-  name: 'read_file',
-  kind: 'read',
-  description: 'Read a text file from the current workspace. Use startLine and endLine to limit the range when the file is large.',
-  inputSchema: schema,
-  inputSchemaJson: {
-    type: 'object',
-    properties: {
-      path: { type: 'string', description: 'Path to the file to read.' },
-      startLine: { type: 'number', description: 'Optional 1-based starting line.' },
-      endLine: { type: 'number', description: 'Optional 1-based ending line.' },
-    },
-    required: ['path'],
-  },
-  parse(input) {
-    return schema.parse(input)
-  },
-  async buildPermissionRequest(input, context) {
-    assertNotPrivateContinuityWorkspacePath(input.path, context.config)
-    const fullPath = resolveWorkspacePath(context.workspaceRoot, input.path)
-    const relativePath = path.relative(context.workspaceRoot, fullPath) || path.basename(fullPath)
-    return {
-      kind: 'read',
-      path: fullPath,
-      relativePath,
-      directoryPath: path.dirname(fullPath),
-      title: 'Allow file read?',
-      subtitle: input.startLine || input.endLine
-        ? `${fullPath} · lines ${input.startLine ?? 1}-${input.endLine ?? 'end'}`
-        : fullPath,
-    }
-  },
-  async execute(input, context) {
-    assertNotPrivateContinuityWorkspacePath(input.path, context.config)
-    const fullPath = resolveWorkspacePath(context.workspaceRoot, input.path)
-    const raw = await fs.readFile(fullPath, 'utf8')
-    const lines = raw.replace(/\r\n/g, '\n').split('\n')
-    const start = Math.max(1, input.startLine ?? 1)
-    const end = Math.max(start, input.endLine ?? lines.length)
-    const slice = lines.slice(start - 1, end)
-    const numbered = slice.map((line, i) => `${start + i}: ${line}`).join('\n')
-    return {
-      ok: true,
-      summary: `read ${path.relative(context.workspaceRoot, fullPath) || path.basename(fullPath)}`,
-      content: numbered,
-    }
-  },
-}
-
-function assertNotPrivateContinuityWorkspacePath(
-  requestedPath: string,
-  config: EthagentConfig | undefined,
-): void {
-  if (!config?.identity) return
-  const basename = path.basename(requestedPath.replaceAll('\\', '/')).toUpperCase()
-  if (basename !== 'SOUL.MD' && basename !== 'MEMORY.MD') return
-  throw new Error(
-    `read_file must not read ${basename} from the workspace; use read_private_continuity_file with file "${basename === 'SOUL.MD' ? 'SOUL.md' : 'MEMORY.md'}"`,
-  )
-}
-
-export function resolveWorkspacePath(workspaceRoot: string, requestedPath: string): string {
-  const expandedPath = requestedPath.startsWith('~')
-    ? path.join(os.homedir(), requestedPath.slice(1))
-    : requestedPath
-  const fullPath = path.resolve(workspaceRoot, expandedPath)
-  const rel = path.relative(workspaceRoot, fullPath)
-  if (rel.startsWith('..') || path.isAbsolute(rel)) {
-    throw new Error(`path escapes workspace: ${requestedPath}`)
-  }
-  return fullPath
-}

package/src/tools/registry.ts

@@ -1,103 +0,0 @@
-import type { AnthropicToolDefinition } from '../providers/anthropic.js'
-import type { GeminiToolDefinition } from '../providers/gemini.js'
-import type { OpenAIToolDefinition } from '../providers/openai-chat.js'
-import type { Tool } from './contracts.js'
-import { modePolicy, type SessionMode } from '../runtime/sessionMode.js'
-import { bashTool } from './bashTool.js'
-import { changeDirectoryTool } from './changeDirectoryTool.js'
-import { deleteFileTool } from './deleteFileTool.js'
-import { editTool } from './editTool.js'
-import { listDirectoryTool } from './listDirectoryTool.js'
-import { listSkillsTool } from './listSkillsTool.js'
-import { listSkillFilesTool } from './listSkillFilesTool.js'
-import { privateContinuityEditTool } from './privateContinuityEditTool.js'
-import { privateContinuityReadTool } from './privateContinuityReadTool.js'
-import { readSkillTool } from './readSkillTool.js'
-import { readTool } from './readTool.js'
-import { listMcpResourcesTool, readMcpResourceTool } from './mcpResourceTools.js'
-import { writeFileTool } from './writeFileTool.js'
-
-export const BUILTIN_TOOLS: Tool[] = [
-  changeDirectoryTool,
-  listDirectoryTool,
-  readTool,
-  privateContinuityReadTool,
-  listSkillsTool,
-  listSkillFilesTool,
-  readSkillTool,
-  listMcpResourcesTool,
-  readMcpResourceTool,
-  writeFileTool,
-  editTool,
-  privateContinuityEditTool,
-  deleteFileTool,
-  bashTool,
-]
-
-export type ToolAvailabilityContext = {
-  hasIdentity?: boolean
-  dynamicTools?: Tool[]
-}
-
-export function getTool(name: string, context: ToolAvailabilityContext = {}): Tool | undefined {
-  return [...(context.dynamicTools ?? []), ...BUILTIN_TOOLS].find(tool => tool.name === name)
-}
-
-export function toolsForMode(mode: SessionMode = 'chat', context: ToolAvailabilityContext = {}): Tool[] {
-  const policy = modePolicy(mode)
-  const allTools = [...BUILTIN_TOOLS, ...(context.dynamicTools ?? [])]
-  return allTools.filter(tool => {
-    if (mode === 'plan' && tool.kind === 'mcp' && tool.readOnly !== true) return false
-    if (!policy.exposesToolKind(tool.kind)) return false
-    if ((tool.kind === 'private-continuity-read' || tool.kind === 'private-continuity-edit') && !context.hasIdentity) return false
-    return true
-  })
-}
-
-export function anthropicTools(mode: SessionMode = 'chat', context: ToolAvailabilityContext = {}): AnthropicToolDefinition[] {
-  return toolsForMode(mode, context).map(tool => ({
-    name: tool.name,
-    description: tool.description,
-    input_schema: tool.inputSchemaJson,
-  }))
-}
-
-export function openAITools(mode: SessionMode = 'chat', context: ToolAvailabilityContext = {}): OpenAIToolDefinition[] {
-  return toolsForMode(mode, context).map(tool => ({
-    type: 'function',
-    function: {
-      name: tool.name,
-      description: tool.description,
-      parameters: tool.inputSchemaJson,
-    },
-  }))
-}
-
-const GEMINI_DROP_KEYS = new Set([
-  'additionalProperties',
-  '$schema',
-  '$ref',
-  '$defs',
-  'definitions',
-])
-
-function sanitizeForGemini(schema: unknown): unknown {
-  if (Array.isArray(schema)) return schema.map(sanitizeForGemini)
-  if (schema && typeof schema === 'object') {
-    const out: Record<string, unknown> = {}
-    for (const [k, v] of Object.entries(schema as Record<string, unknown>)) {
-      if (GEMINI_DROP_KEYS.has(k)) continue
-      out[k] = sanitizeForGemini(v)
-    }
-    return out
-  }
-  return schema
-}
-
-export function geminiTools(mode: SessionMode = 'chat', context: ToolAvailabilityContext = {}): GeminiToolDefinition[] {
-  return toolsForMode(mode, context).map(tool => ({
-    name: tool.name,
-    description: tool.description,
-    parameters: sanitizeForGemini(tool.inputSchemaJson) as GeminiToolDefinition['parameters'],
-  }))
-}

package/src/tools/writeFileTool.ts

@@ -1,167 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-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({
-  path: z.string().min(1),
-  content: z.string(),
-  overwrite: z.boolean().optional(),
-})
-
-export const writeFileTool: Tool<typeof schema> = {
-  name: 'write_file',
-  kind: 'write',
-  description: 'Create a new text file, or replace an entire existing file only when overwrite is true. Prefer edit_file for targeted changes to existing files.',
-  inputSchema: schema,
-  inputSchemaJson: {
-    type: 'object',
-    properties: {
-      path: { type: 'string', description: 'Workspace-relative file path to write.' },
-      content: { type: 'string', description: 'Complete file contents to write.' },
-      overwrite: { type: 'boolean', description: 'Set true only when intentionally replacing an existing file.' },
-    },
-    required: ['path', 'content'],
-  },
-  parse(input) {
-    return schema.parse(normalizeWriteFileInput(input))
-  },
-  async buildPermissionRequest(input, context) {
-    const prepared = await prepareWrite(input, context)
-    return {
-      kind: 'write',
-      path: prepared.fullPath,
-      relativePath: prepared.relativePath,
-      directoryPath: path.dirname(prepared.fullPath),
-      title: prepared.existedBefore ? 'Allow file rewrite?' : 'Allow file creation?',
-      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}`,
-    }
-  },
-  async execute(input, context) {
-    const prepared = await prepareWrite(input, context)
-    const rewindWarning = await tryRecordRewindSnapshot({
-      workspaceRoot: context.workspaceRoot,
-      filePath: prepared.fullPath,
-      relativePath: prepared.relativePath,
-      existedBefore: prepared.existedBefore,
-      previousContent: prepared.before,
-      changeSummary: prepared.existedBefore ? `replace entire ${prepared.relativePath}` : `create ${prepared.relativePath}`,
-      createdAt: new Date().toISOString(),
-      sessionId: context.checkpoint?.sessionId,
-      turnId: context.checkpoint?.turnId,
-      messageRole: context.checkpoint?.messageRole,
-      promptSnippet: context.checkpoint?.promptSnippet,
-      checkpointLabel: context.checkpoint?.checkpointLabel,
-    })
-    await fs.mkdir(path.dirname(prepared.fullPath), { recursive: true })
-    await fs.writeFile(prepared.fullPath, input.content, 'utf8')
-    return {
-      ok: true,
-      summary: prepared.existedBefore ? `replace entire ${prepared.relativePath}` : `create ${prepared.relativePath}`,
-      content: formatFileChangeResult(
-        rewindWarning
-          ? `updated ${prepared.fullPath}\nwarning: ${rewindWarning}`
-          : `updated ${prepared.fullPath}`,
-        renderUnifiedFileDiff({ filePath: prepared.relativePath, before: prepared.before, after: input.content }),
-      ),
-    }
-  },
-}
-
-function normalizeWriteFileInput(input: unknown): unknown {
-  let value: unknown = input
-  if (typeof value === 'string') {
-    const trimmed = value.trim()
-    if (trimmed.startsWith('{')) {
-      try {
-        value = JSON.parse(trimmed)
-      } catch {
-        return input
-      }
-    }
-  }
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return value
-  const normalized: Record<string, unknown> = { ...(value as Record<string, unknown>) }
-  if (typeof normalized.path === 'string' && normalized.path.trim() === '') {
-    normalized.path = undefined
-  }
-  return normalized
-}
-
-async function prepareWrite(
-  input: z.infer<typeof schema>,
-  context: { workspaceRoot: string; config?: EthagentConfig },
-) {
-  assertSafeWritePath(input.path)
-  assertNotPrivateContinuityWorkspacePath(input.path, context.config, 'write_file')
-  if (input.content.length === 0) {
-    throw new Error('Tool write_file content is empty; provide non-empty file contents')
-  }
-
-  const fullPath = resolveWorkspacePath(context.workspaceRoot, input.path)
-  const relativePath = path.relative(context.workspaceRoot, fullPath) || path.basename(fullPath)
-  const { before, existedBefore } = await readExistingFile(fullPath)
-
-  return { fullPath, relativePath, before, existedBefore }
-}
-
-async function readExistingFile(fullPath: string): Promise<{ before: string; existedBefore: boolean }> {
-  try {
-    const stats = await fs.stat(fullPath)
-    if (stats.isDirectory()) throw new Error('Tool write_file path points to a directory; provide a file path')
-    return { before: await fs.readFile(fullPath, 'utf8'), existedBefore: true }
-  } catch (error: unknown) {
-    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return { before: '', existedBefore: false }
-    throw error
-  }
-}
-
-async function tryRecordRewindSnapshot(
-  snapshot: Parameters<typeof recordRewindSnapshot>[0],
-): Promise<string | undefined> {
-  try {
-    await recordRewindSnapshot(snapshot)
-    return undefined
-  } catch (error: unknown) {
-    return `rewind checkpoint was not recorded (${(error as Error).message || 'unknown error'})`
-  }
-}
-
-function assertSafeWritePath(requestedPath: string): void {
-  const trimmed = requestedPath.trim()
-  if (trimmed !== requestedPath || trimmed.length === 0) {
-    throw new Error('Tool write_file path must be a clean workspace-relative file path')
-  }
-  if (/[|;&<>`]/.test(trimmed)) {
-    throw new Error('Tool write_file path must not contain shell operators')
-  }
-  if (/^(?:rm|del|erase|rmdir|remove-item|mkdir|type|cat|echo|copy|move|mv|cp)\b/i.test(trimmed)) {
-    throw new Error('Tool write_file path looks like a shell command; pass only the file path')
-  }
-}
-
-function assertNotPrivateContinuityWorkspacePath(
-  requestedPath: string,
-  config: EthagentConfig | undefined,
-  toolName: string,
-): void {
-  if (!config?.identity) return
-  const basename = path.basename(requestedPath.replaceAll('\\', '/')).toUpperCase()
-  if (basename !== 'SOUL.MD' && basename !== 'MEMORY.MD') return
-  throw new Error(
-    `${toolName} must not create or overwrite ${basename}; use propose_private_continuity_edit to patch the existing identity-vault scaffold`,
-  )
-}
-
-function previewText(text: string, max = 700): string {
-  if (text.length <= max) return text
-  return `${text.slice(0, max - 3)}...`
-}

package/src/ui/BrandSplash.tsx

@@ -1,133 +0,0 @@
-import React, { useEffect, useState } from 'react'
-import { Text, Box } from 'ink'
-import { theme, gradientColor } from './theme.js'
-
-const glyphs = {
-  ethagent: `░░░░░░░╗░░░░░░░░╗░░╗  ░░╗ █████╗  ██████╗ ███████╗███╗   ██╗████████╗
-░░╔════╝╚══░░╔══╝░░║  ░░║██╔══██╗██╔════╝ ██╔════╝████╗  ██║╚══██╔══╝
-░░░░░╗     ░░║   ░░░░░░░║███████║██║  ███╗█████╗  ██╔██╗ ██║   ██║
-░░╔══╝     ░░║   ░░╔══░░║██╔══██║██║   ██║██╔══╝  ██║╚██╗██║   ██║
-░░░░░░░╗   ░░║   ░░║  ░░║██║  ██║╚██████╔╝███████╗██║ ╚████║   ██║
-╚══════╝   ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═══╝   ╚═╝   `,
-  eyes: `
-                                         -+:
-                   :=-                    -%@@@%.
-             *@@@@@#-                           *@@-
-          +@@.                                     +@
-        @@=                               -#=-+++=+:
-      #%        .:===-:                   -@* +@@@@%
-           *@-+@@@@@:                    %@@+  @@@=#@
-          *@=   @@@@@@@-                .@.@@@@@@@ :
-        @@+=@@@@@@@@@@@@:               .% *@@@@@*-=
-       #:-@ -@@@@@@@@@-+%                @  -@@@- #
-       :  #+  @@@@@@@- -%                 =#     =
-           -@:        *@                      .+%%
-              :%#: --
-              .-:
-                                                           `,
-  tagline: ' privacy-first AI agent with a portable Ethereum identity ',
-  ellipsis: '…',
-  frame: {
-    topLeft: '╔═',
-    topRight: '╗',
-    side: '║',
-    bottomLeft: '╚═',
-    bottomRight: '╝',
-    horizontal: '═',
-  },
-} as const
-
-const Eyes = () => {
-  const lines = glyphs.eyes.split('\n')
-  const maxWidth = Math.max(1, ...lines.map(l => l.length))
-  return (
-    <Box flexDirection="column">
-      {lines.map((line, li) => (
-        <Text key={li}>
-          {[...line].map((ch, ci) => (
-            <Text key={ci} color={gradientColor(maxWidth <= 1 ? 0 : ci / (maxWidth - 1))}>{ch}</Text>
-          ))}
-        </Text>
-      ))}
-    </Box>
-  )
-}
-
-type SplashProps = {
-  contextLine?: string
-  tipLine?: string
-  updateNotice?: string | null
-  compact?: boolean
-}
-
-export const BrandSplash: React.FC<SplashProps> = ({ contextLine, tipLine, updateNotice, compact }) => {
-  const [width, setWidth] = useState<number>(() => process.stdout.columns ?? 80)
-
-  useEffect(() => {
-    const stdout = process.stdout
-    const handleResize = () => setWidth(stdout.columns ?? 80)
-    stdout.on('resize', handleResize)
-    return () => {
-      stdout.off('resize', handleResize)
-    }
-  }, [])
-
-  const renderCompact = compact ?? width < 72
-
-  if (renderCompact) {
-    return (
-      <Box flexDirection="column" alignSelf="flex-start" padding={1}>
-        <Eyes />
-        <Text bold color={theme.accentWhite}>ethagent</Text>
-        {contextLine ? <Text color={theme.dim}>{contextLine}</Text> : null}
-        {tipLine ? <Text color={theme.dim}>{tipLine}</Text> : null}
-        {updateNotice ? <Text color={theme.dim}>{updateNotice}</Text> : null}
-      </Box>
-    )
-  }
-
-  const w = 69
-  const logoLines = glyphs.ethagent.split('\n').map(line => line.padEnd(w, ' '))
-
-  const bottomInline = contextLine ? ` ${truncateToFit(contextLine, w - 4)} ` : ''
-  const bottomPad = Math.max(0, w - bottomInline.length - 1)
-
-  return (
-    <Box flexDirection="column" alignSelf="flex-start" padding={1}>
-      <Eyes />
-      <Text>
-        <Text color={theme.dim}>{glyphs.frame.topLeft}</Text>
-        <Text color={theme.dim}>{glyphs.tagline}</Text>
-        <Text color={theme.dim}>{glyphs.frame.horizontal.repeat(Math.max(0, w - glyphs.tagline.length - 1))}{glyphs.frame.topRight}</Text>
-      </Text>
-      {logoLines.map((line, i) => (
-        <Box key={i}>
-          <Text color={theme.dim}>{glyphs.frame.side}</Text>
-          <Text color={theme.dim}>{line}</Text>
-          <Text color={theme.dim}>{glyphs.frame.side}</Text>
-        </Box>
-      ))}
-      {bottomInline ? (
-        <Text>
-          <Text color={theme.dim}>{glyphs.frame.bottomLeft}</Text>
-          <Text color={theme.dim}>{bottomInline}</Text>
-          <Text color={theme.dim}>{glyphs.frame.horizontal.repeat(bottomPad)}{glyphs.frame.bottomRight}</Text>
-        </Text>
-      ) : (
-        <Text color={theme.dim}>{glyphs.frame.bottomLeft.slice(0, 1) + glyphs.frame.horizontal.repeat(w) + glyphs.frame.bottomRight}</Text>
-      )}
-      {tipLine || updateNotice ? (
-        <Box marginTop={1} flexDirection="column">
-          {tipLine ? <Text color={theme.dim}>{tipLine}</Text> : null}
-          {updateNotice ? <Text color={theme.dim}>{updateNotice}</Text> : null}
-        </Box>
-      ) : null}
-    </Box>
-  )
-}
-
-function truncateToFit(text: string, max: number): string {
-  if (text.length <= max) return text
-  if (max <= 1) return text.slice(0, Math.max(0, max))
-  return text.slice(0, max - 1) + glyphs.ellipsis
-}

package/src/ui/terminalTitle.ts

@@ -1,30 +0,0 @@
-export const TITLE_STATIC = 'ethagent'
-export const TITLE_ANIMATION_FRAMES = [
-  'ethagent ⠋',
-  'ethagent ⠙',
-  'ethagent ⠹',
-  'ethagent ⠸',
-  'ethagent ⠼',
-  'ethagent ⠴',
-  'ethagent ⠦',
-  'ethagent ⠧',
-  'ethagent ⠇',
-  'ethagent ⠏',
-] as const
-export const TITLE_ANIMATION_INTERVAL_MS = 80
-
-export function setTerminalTitle(title: string): void {
-  const clean = title.replace(/[\x00-\x1f]/g, '')
-  if (process.platform === 'win32') {
-    process.title = clean
-  }
-  if (process.stdout.isTTY) {
-    process.stdout.write(`\x1b]0;${clean}\x07`)
-  }
-}
-
-export function clearTerminalTitle(): void {
-  if (process.stdout.isTTY) {
-    process.stdout.write('\x1b]0;\x07')
-  }
-}