ethagent 3.3.3 → 4.0.0

package/src/chat/views/RewindView.tsx

@@ -1,412 +0,0 @@
-import React, { useEffect, useState } from 'react'
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import { Box, Text } from 'ink'
-import { Surface } from '../../ui/Surface.js'
-import { Select, type SelectOption } from '../../ui/Select.js'
-import { Spinner } from '../../ui/Spinner.js'
-import { theme } from '../../ui/theme.js'
-import { useAppInput } from '../../app/input/AppInputProvider.js'
-import {
-  groupRewindEntriesByTurn,
-  rewindWorkspaceEditsByEntryIds,
-  type RewindEntry,
-} from '../../storage/rewind.js'
-import { loadSession } from '../../storage/sessions.js'
-import { computeLineDiffStats } from '../../tools/fileDiff.js'
-
-type RestoreAction = 'both' | 'conversation' | 'code' | 'summarize'
-type ConfirmOption = RestoreAction | 'nevermind'
-
-type RewindViewProps = {
-  cwd: string
-  currentSessionId: string
-  onRestoreConversation: (turnId: string, promptText?: string) => void
-  onSummarizeFromTurn: (turnId: string) => void | Promise<unknown>
-  onDone: (message: string, variant?: 'info' | 'error' | 'dim') => void
-  onCancel: () => void
-}
-
-type DiffStats = {
-  files: string[]
-  inserts: number
-  deletes: number
-}
-
-type PromptRow = {
-  turnId: string
-  text: string
-  createdAt: string
-  entries: RewindEntry[]
-  stats: DiffStats
-}
-
-type State =
-  | { kind: 'loading' }
-  | { kind: 'error'; message: string }
-  | { kind: 'picker' }
-  | { kind: 'confirm'; turnId: string; selectedAction: ConfirmOption }
-  | { kind: 'restoring' }
-
-export const RewindView: React.FC<RewindViewProps> = ({
-  cwd,
-  currentSessionId,
-  onRestoreConversation,
-  onSummarizeFromTurn,
-  onDone,
-  onCancel,
-}) => {
-  const [state, setState] = useState<State>({ kind: 'loading' })
-  const [rows, setRows] = useState<PromptRow[]>([])
-
-  useEffect(() => {
-    let cancelled = false
-    void (async () => {
-      try {
-        const [sessionMessages, grouped] = await Promise.all([
-          loadSession(currentSessionId),
-          groupRewindEntriesByTurn(cwd, currentSessionId),
-        ])
-        const prompts: PromptRow[] = []
-        for (const msg of sessionMessages) {
-          if (msg.role !== 'user') continue
-          if (msg.synthetic) continue
-          if (!msg.turnId) continue
-          const entries = grouped.get(msg.turnId) ?? []
-          const stats = await computeDiffStatsForEntries(entries)
-          prompts.push({
-            turnId: msg.turnId,
-            text: msg.content,
-            createdAt: msg.createdAt,
-            entries,
-            stats,
-          })
-        }
-        if (cancelled) return
-        setRows(prompts)
-        setState({ kind: 'picker' })
-      } catch (err: unknown) {
-        if (cancelled) return
-        setState({ kind: 'error', message: (err as Error).message })
-      }
-    })()
-    return () => { cancelled = true }
-  }, [cwd, currentSessionId])
-
-  const escActive =
-    state.kind === 'loading' ||
-    state.kind === 'error' ||
-    (state.kind === 'picker' && rows.length === 0)
-  useAppInput((_input, key) => {
-    if (key.escape) onCancel()
-  }, { isActive: escActive })
-
-  if (state.kind === 'loading') {
-    return (
-      <Surface title="Rewind" subtitle="Loading session history...">
-        <Spinner label="Loading rewind history..." />
-      </Surface>
-    )
-  }
-
-  if (state.kind === 'error') {
-    return (
-      <Surface title="Rewind" tone="muted" footer="Esc closes.">
-        <Text color={theme.dim}>{state.message}</Text>
-      </Surface>
-    )
-  }
-
-  if (state.kind === 'restoring') {
-    return (
-      <Surface title="Rewind" subtitle="Restoring..." footer="Restoring...">
-        <Spinner label="Restoring..." />
-      </Surface>
-    )
-  }
-
-  if (rows.length === 0) {
-    return (
-      <Surface title="Rewind" tone="muted" footer="Esc closes.">
-        <Text color={theme.dim}>Nothing to rewind to yet.</Text>
-      </Surface>
-    )
-  }
-
-  if (state.kind === 'confirm') {
-    const selectedRow = rows.find(row => row.turnId === state.turnId)
-    if (!selectedRow) {
-      setState({ kind: 'picker' })
-      return null
-    }
-    const canRestoreCode = selectedRow.entries.length > 0
-
-    const actionOptions: Array<SelectOption<ConfirmOption>> = [
-      { value: 'both', role: 'section', label: 'Restore' },
-      { value: 'both', prefix: '1.', label: 'Restore code and conversation', disabled: !canRestoreCode },
-      { value: 'conversation', prefix: '2.', label: 'Restore conversation' },
-      { value: 'code', prefix: '3.', label: 'Restore code', disabled: !canRestoreCode },
-      { value: 'summarize', prefix: '4.', label: 'Summarize from here' },
-      { value: 'nevermind', role: 'section', label: 'Navigation' },
-      { value: 'nevermind', prefix: '5.', label: 'Never mind', role: 'utility' },
-    ]
-    const defaultValue: ConfirmOption = canRestoreCode ? 'both' : 'conversation'
-    const initialIndex = actionOptions.findIndex(option => option.value === defaultValue && !option.disabled)
-
-    const runRestore = async (action: RestoreAction) => {
-      if (action === 'summarize') {
-        try {
-          await onSummarizeFromTurn(state.turnId)
-          onDone('Summarizing the conversation from this point...', 'dim')
-        } catch (err: unknown) {
-          onDone(`Summarize failed: ${(err as Error).message}`, 'error')
-        }
-        return
-      }
-      setState({ kind: 'restoring' })
-      const codeIds = selectedRow.entries.map(entry => entry.id)
-      let codeError: Error | null = null
-      let codeFiles: string[] = []
-      let conversationError: Error | null = null
-
-      if (action === 'code' || action === 'both') {
-        try {
-          const result = await rewindWorkspaceEditsByEntryIds(cwd, codeIds)
-          codeFiles = result.files
-          if (result.reverted === 0) {
-            codeError = new Error('No matching rewind entries were found for this prompt.')
-          }
-        } catch (err: unknown) {
-          codeError = err as Error
-        }
-      }
-      if (action === 'conversation' || action === 'both') {
-        try {
-          onRestoreConversation(state.turnId, selectedRow.text)
-        } catch (err: unknown) {
-          conversationError = err as Error
-        }
-      }
-
-      if (codeError && conversationError) {
-        onDone(`Rewind failed: ${codeError.message}; ${conversationError.message}`, 'error')
-        return
-      }
-      if (codeError) {
-        onDone(`Code restore failed: ${codeError.message}`, 'error')
-        return
-      }
-      if (conversationError) {
-        onDone(`Conversation restore failed: ${conversationError.message}`, 'error')
-        return
-      }
-
-      if (action === 'both') {
-        const files = describeFileList(codeFiles, cwd)
-        onDone(`Restored code and conversation to before this prompt.${files ? ` Files: ${files}.` : ''}`, 'dim')
-      } else if (action === 'code') {
-        const files = describeFileList(codeFiles, cwd)
-        onDone(`Restored code to before this prompt.${files ? ` Files: ${files}.` : ''}`, 'dim')
-      } else {
-        onDone('Restored conversation to before this prompt.', 'dim')
-      }
-    }
-
-    return (
-      <Surface
-        title="Rewind"
-        subtitle="Confirm you want to restore to the point before you sent this message."
-        footer="Enter to restore. Esc to go back."
-      >
-        <Box flexDirection="column">
-          <Text color={theme.accentPeriwinkle}>{truncate(selectedRow.text, 280)}</Text>
-          <Text color={theme.dim}>
-            {formatTimestamp(selectedRow.createdAt)}
-            {describeStats(selectedRow.stats, cwd) ? ` · ${describeStats(selectedRow.stats, cwd)}` : ''}
-          </Text>
-        </Box>
-        <Box marginTop={1}>
-          <Select
-            options={actionOptions}
-            initialIndex={initialIndex < 0 ? 1 : initialIndex}
-            onSubmit={value => {
-              if (value === 'nevermind') {
-                setState({ kind: 'picker' })
-                return
-              }
-              void runRestore(value)
-            }}
-            onCancel={() => setState({ kind: 'picker' })}
-            onHighlight={value => {
-              setState(prev => prev.kind === 'confirm'
-                ? { ...prev, selectedAction: value }
-                : prev)
-            }}
-          />
-        </Box>
-        <Box marginTop={1} flexDirection="column">
-          <ConfirmDescription
-            action={state.selectedAction}
-            stats={selectedRow.stats}
-            cwd={cwd}
-            canRestoreCode={canRestoreCode}
-          />
-        </Box>
-      </Surface>
-    )
-  }
-
-  const pickerOptions = buildPickerOptions(rows, cwd)
-  const lastIndex = Math.max(0, rows.length - 1)
-
-  return (
-    <Surface
-      title="Rewind"
-      subtitle="Restore the code and/or conversation to the point before a prior prompt."
-      footer="Enter to continue. Esc to exit."
-    >
-      <Select
-        options={pickerOptions}
-        initialIndex={lastIndex}
-        maxVisible={7}
-        onSubmit={turnId => {
-          const row = rows.find(r => r.turnId === turnId)
-          const canRestoreCode = (row?.entries.length ?? 0) > 0
-          setState({
-            kind: 'confirm',
-            turnId,
-            selectedAction: canRestoreCode ? 'both' : 'conversation',
-          })
-        }}
-        onCancel={onCancel}
-      />
-    </Surface>
-  )
-}
-
-const ConfirmDescription: React.FC<{
-  action: ConfirmOption
-  stats: DiffStats
-  cwd: string
-  canRestoreCode: boolean
-}> = ({ action, stats, cwd, canRestoreCode }) => {
-  if (action === 'nevermind') {
-    return <Text color={theme.textSubtle}>The conversation and code will be unchanged.</Text>
-  }
-  if (action === 'summarize') {
-    return (
-      <Text color={theme.textSubtle}>
-        Messages from this point forward will be summarized into a handoff. The earlier conversation will remain unchanged.
-      </Text>
-    )
-  }
-  const lines: React.ReactNode[] = []
-  if (action === 'both') {
-    lines.push(<Text key="0" color={theme.textSubtle}>The conversation will be forked.</Text>)
-    lines.push(<CodeRestoreLine key="1" stats={stats} cwd={cwd} canRestoreCode={canRestoreCode} />)
-  } else if (action === 'conversation') {
-    lines.push(<Text key="0" color={theme.textSubtle}>The conversation will be forked.</Text>)
-    lines.push(<Text key="1" color={theme.textSubtle}>The code will be unchanged.</Text>)
-  } else {
-    lines.push(<Text key="0" color={theme.textSubtle}>The conversation will be unchanged.</Text>)
-    lines.push(<CodeRestoreLine key="1" stats={stats} cwd={cwd} canRestoreCode={canRestoreCode} />)
-  }
-  if ((action === 'code' || action === 'both') && canRestoreCode) {
-    lines.push(
-      <Text key="footnote" color={theme.dim}>
-        Rewinding does not affect files edited manually or via bash.
-      </Text>,
-    )
-  }
-  return <>{lines}</>
-}
-
-const CodeRestoreLine: React.FC<{ stats: DiffStats; cwd: string; canRestoreCode: boolean }> = ({ stats, cwd, canRestoreCode }) => {
-  if (!canRestoreCode) {
-    return <Text color={theme.textSubtle}>The code has not changed (nothing will be restored).</Text>
-  }
-  if (stats.inserts === 0 && stats.deletes === 0) {
-    return <Text color={theme.textSubtle}>The code will be restored in {describeFiles(stats.files, cwd)}.</Text>
-  }
-  return (
-    <Text color={theme.textSubtle}>
-      The code will be restored{' '}
-      <Text color={theme.diffAdded}>+{stats.inserts} </Text>
-      <Text color={theme.diffRemoved}>-{stats.deletes}</Text>
-      {' '}in {describeFiles(stats.files, cwd)}.
-    </Text>
-  )
-}
-
-function buildPickerOptions(rows: PromptRow[], cwd: string): Array<SelectOption<string>> {
-  return rows.map(row => ({
-    value: row.turnId,
-    label: truncate(row.text, 80),
-    subtext: describeStats(row.stats, cwd) || 'No code changes',
-    hint: formatTimestamp(row.createdAt),
-  }))
-}
-
-async function computeDiffStatsForEntries(entries: RewindEntry[]): Promise<DiffStats> {
-  const files: string[] = []
-  const seen = new Set<string>()
-  let inserts = 0
-  let deletes = 0
-  for (const entry of entries) {
-    if (!seen.has(entry.filePath)) {
-      seen.add(entry.filePath)
-      files.push(entry.filePath)
-    }
-    let currentContent = ''
-    try {
-      currentContent = await fs.readFile(entry.filePath, 'utf8')
-    } catch (err: unknown) {
-      if ((err as NodeJS.ErrnoException).code !== 'ENOENT') throw err
-    }
-    const stats = computeLineDiffStats(entry.previousContent, currentContent)
-    inserts += stats.inserts
-    deletes += stats.deletes
-  }
-  return { files, inserts, deletes }
-}
-
-function describeStats(stats: DiffStats, cwd: string): string {
-  if (stats.files.length === 0) return ''
-  const fileLabel = describeFiles(stats.files, cwd)
-  if (stats.inserts === 0 && stats.deletes === 0) return fileLabel
-  return `${fileLabel} +${stats.inserts} -${stats.deletes}`
-}
-
-function describeFiles(files: string[], cwd: string): string {
-  if (files.length === 0) return ''
-  const formatted = files.map(file => formatRelative(file, cwd))
-  if (formatted.length === 1) return formatted[0]!
-  if (formatted.length === 2) return `${formatted[0]} and ${formatted[1]}`
-  return `${formatted[0]} and ${formatted.length - 1} other files`
-}
-
-function describeFileList(files: string[], cwd: string): string {
-  if (files.length === 0) return ''
-  return files.map(file => formatRelative(file, cwd)).join(', ')
-}
-
-function formatRelative(filePath: string, cwd: string): string {
-  try {
-    const rel = path.relative(cwd, filePath)
-    if (rel && !rel.startsWith('..') && !path.isAbsolute(rel)) return rel
-  } catch {
-    return path.basename(filePath)
-  }
-  return path.basename(filePath)
-}
-
-function formatTimestamp(iso: string): string {
-  const date = new Date(iso)
-  return Number.isNaN(date.getTime()) ? iso : date.toLocaleString()
-}
-
-function truncate(text: string, limit: number): string {
-  const normalized = text.replace(/\s+/g, ' ').trim()
-  if (normalized.length <= limit) return normalized
-  return `${normalized.slice(0, Math.max(0, limit - 3))}...`
-}

package/src/cli/preview.tsx

@@ -1,14 +0,0 @@
-import React from 'react'
-import { Box, render } from 'ink'
-import { BrandSplash } from '../ui/BrandSplash.js'
-
-export async function runPreviewCommand(): Promise<number> {
-  const instance = render(
-    <Box flexDirection="column" marginY={1}>
-      <BrandSplash />
-    </Box>,
-  )
-  await new Promise<void>(resolve => setTimeout(resolve, 50))
-  instance.unmount()
-  return 0
-}

package/src/cli/updateNotice.ts

@@ -1,54 +0,0 @@
-type RegistryResponse = {
-  ok?: boolean
-  json: () => Promise<unknown>
-}
-
-type RegistryFetch = (url: string, init: { signal: AbortSignal }) => Promise<RegistryResponse>
-
-const REGISTRY_LATEST_URL = 'https://registry.npmjs.org/ethagent/latest'
-
-export function compareVersions(left: string, right: string): number {
-  const a = parseVersion(left)
-  const b = parseVersion(right)
-  if (!a || !b) return 0
-  for (let i = 0; i < 3; i++) {
-    const av = a[i as 0 | 1 | 2]
-    const bv = b[i as 0 | 1 | 2]
-    if (av > bv) return 1
-    if (av < bv) return -1
-  }
-  return 0
-}
-
-export function isNewerVersion(candidate: string, current: string): boolean {
-  return compareVersions(candidate, current) > 0
-}
-
-export function formatUpdateNotice(currentVersion: string, latestVersion: string): string | null {
-  if (!isNewerVersion(latestVersion, currentVersion)) return null
-  return `✨ update available: ethagent ${currentVersion} -> ${latestVersion} · run npm i -g ethagent@latest`
-}
-
-export async function checkForUpdates(
-  currentVersion: string,
-  options: { fetchImpl?: RegistryFetch; timeoutMs?: number } = {},
-): Promise<string | null> {
-  const fetchImpl = options.fetchImpl ?? fetch
-  const timeoutMs = options.timeoutMs ?? 1200
-  try {
-    const res = await fetchImpl(REGISTRY_LATEST_URL, { signal: AbortSignal.timeout(timeoutMs) })
-    if (res.ok === false) return null
-    const body = await res.json()
-    if (!body || typeof body !== 'object') return null
-    const latest = (body as { version?: unknown }).version
-    return typeof latest === 'string' ? formatUpdateNotice(currentVersion, latest) : null
-  } catch {
-    return null
-  }
-}
-
-function parseVersion(value: string): [number, number, number] | null {
-  const match = /^v?(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(value.trim())
-  if (!match) return null
-  return [Number(match[1]), Number(match[2]), Number(match[3])]
-}

package/src/identity/continuity/privateEdit/apply.ts

@@ -1,170 +0,0 @@
-import type { EthagentIdentity } from '../../../storage/config.js'
-import { applyRequestedEdit } from '../../../tools/editUtils.js'
-import { defaultContinuityFiles, type PrivateContinuityFile } from '../storage.js'
-import type { PrivateContinuityEditInput } from './types.js'
-
-export function applyPrivateContinuityEdit(input: PrivateContinuityEditInput, before: string, identity: EthagentIdentity) {
-  if (input.replaceWholeFile) {
-    throw new Error('Private continuity files must be edited in place; whole-file replacement is disabled')
-  }
-  if (input.appendToSection || input.appendText) {
-    if (!input.appendToSection?.trim()) throw new Error('Field appendToSection is required for append edits')
-    if (!input.appendText?.trim()) throw new Error('Field appendText is required for append edits')
-    if (input.oldText || input.newText !== undefined) {
-      throw new Error('Use either appendToSection+appendText or oldText+newText, not both')
-    }
-    return appendToMarkdownSection(identity, input.file, before, input.appendToSection, input.appendText)
-  }
-  if (!input.oldText?.trim()) {
-    throw new Error('Field oldText is required; private continuity edits must patch existing scaffold text')
-  }
-  if (input.newText === undefined) {
-    throw new Error('Field newText is required for targeted private continuity edits')
-  }
-  return applyRequestedEdit(
-    input.file,
-    before,
-    input.oldText,
-    input.newText,
-    input.replaceAll ?? false,
-    false,
-  )
-}
-
-function appendToMarkdownSection(
-  identity: EthagentIdentity,
-  file: PrivateContinuityFile,
-  before: string,
-  section: string,
-  appendText: string,
-) {
-  const heading = normalizeSectionHeading(section)
-  let working = before
-  let repairedMissingSection = false
-  let lines = working.split(/\r?\n/)
-  let bounds = findMarkdownSectionBounds(lines, heading)
-  if (!bounds) {
-    const repaired = insertDefaultScaffoldSection(identity, file, before, heading)
-    if (!repaired) {
-      throw new Error(`section "${section}" was not found in ${file}; target an existing scaffold section`)
-    }
-    working = repaired
-    repairedMissingSection = true
-    lines = working.split(/\r?\n/)
-    bounds = findMarkdownSectionBounds(lines, heading)
-  }
-  if (!bounds) {
-    throw new Error(`section "${section}" was not found in ${file}; target an existing scaffold section`)
-  }
-  const { start, end: insertAt } = bounds
-  const prefix = lines.slice(0, insertAt).join('\n').replace(/\s+$/g, '')
-  const suffix = insertAt >= lines.length ? '' : lines.slice(insertAt).join('\n').replace(/^\s+/g, '')
-  const normalizedAppend = ensureTrailingNewline(appendText.trim())
-  const after = ensureTrailingNewline(suffix
-    ? `${prefix}\n${normalizedAppend}\n${suffix}`
-    : `${prefix}\n${normalizedAppend}`)
-  const afterLines = after.split(/\r?\n/)
-  const afterBounds = findMarkdownSectionBounds(afterLines, heading)
-  return {
-    before,
-    after,
-    summary: repairedMissingSection
-      ? `repair ${heading} section and append to ${heading} in ${file}`
-      : `append to ${heading} in ${file}`,
-    previewBefore: repairedMissingSection
-      ? `section "${heading}" was missing in ${file}; approval will add the scaffold section before appending.`
-      : previewText(sectionPreview(lines, start, insertAt)),
-    previewAfter: previewText(afterBounds
-      ? sectionPreview(afterLines, afterBounds.start, afterBounds.end)
-      : normalizedAppend),
-  }
-}
-
-function insertDefaultScaffoldSection(
-  identity: EthagentIdentity,
-  file: PrivateContinuityFile,
-  before: string,
-  heading: string,
-): string | null {
-  const defaults = defaultContinuityFiles(identity)[file]
-  const defaultSection = extractMarkdownSection(defaults, heading)
-  if (!defaultSection) return null
-
-  const defaultHeadings = markdownSectionHeadings(defaults)
-  const targetIndex = defaultHeadings.indexOf(heading)
-  if (targetIndex === -1) return null
-
-  const lines = before.split(/\r?\n/)
-  const followingHeadings = new Set(defaultHeadings.slice(targetIndex + 1))
-  const followingIndex = lines.findIndex(line => followingHeadings.has(normalizeSectionHeading(line)))
-  if (followingIndex !== -1) {
-    return insertSectionAtLine(before, followingIndex, defaultSection)
-  }
-
-  const previousHeadings = new Set(defaultHeadings.slice(0, targetIndex))
-  let insertAfterPrevious: number | null = null
-  for (let index = 0; index < lines.length; index += 1) {
-    if (!previousHeadings.has(normalizeSectionHeading(lines[index] ?? ''))) continue
-    const bounds = findMarkdownSectionBounds(lines, normalizeSectionHeading(lines[index] ?? ''))
-    if (bounds && bounds.end > (insertAfterPrevious ?? -1)) insertAfterPrevious = bounds.end
-  }
-  if (insertAfterPrevious !== null) {
-    return insertSectionAtLine(before, insertAfterPrevious, defaultSection)
-  }
-
-  const firstHeading = lines.findIndex(line => /^#\s+/.test(line.trim()))
-  return insertSectionAtLine(before, firstHeading === -1 ? 0 : firstHeading + 1, defaultSection)
-}
-
-function insertSectionAtLine(markdown: string, lineIndex: number, section: string): string {
-  const lines = markdown.split(/\r?\n/)
-  const before = lines.slice(0, lineIndex).join('\n').replace(/\s+$/g, '')
-  const after = lines.slice(lineIndex).join('\n').replace(/^\s+/g, '')
-  const block = section.trim()
-  if (!before) return ensureTrailingNewline(after ? `${block}\n\n${after}` : block)
-  return ensureTrailingNewline(after ? `${before}\n\n${block}\n\n${after}` : `${before}\n\n${block}`)
-}
-
-function extractMarkdownSection(markdown: string, heading: string): string | null {
-  const lines = markdown.split(/\r?\n/)
-  const bounds = findMarkdownSectionBounds(lines, heading)
-  if (!bounds) return null
-  return lines.slice(bounds.start, bounds.end).join('\n').trim()
-}
-
-function markdownSectionHeadings(markdown: string): string[] {
-  return markdown
-    .split(/\r?\n/)
-    .filter(line => /^##\s+/.test(line.trim()))
-    .map(normalizeSectionHeading)
-}
-
-function findMarkdownSectionBounds(lines: string[], heading: string): { start: number; end: number } | null {
-  const start = lines.findIndex(line => normalizeSectionHeading(line) === heading && /^#{1,6}\s+/.test(line.trim()))
-  if (start === -1) return null
-  const nextSection = lines.findIndex((line, index) => index > start && /^##\s+/.test(line.trim()))
-  return { start, end: nextSection === -1 ? lines.length : nextSection }
-}
-
-function normalizeSectionHeading(value: string): string {
-  return value.trim().replace(/^#+\s*/, '').trim()
-}
-
-function sectionPreview(lines: string[], start: number, end: number): string {
-  return lines.slice(start, Math.min(end, start + 8)).join('\n')
-}
-
-function markdownLines(value: string): string[] {
-  const lines = value.split(/\r?\n/)
-  if (lines[lines.length - 1] === '') lines.pop()
-  return lines
-}
-
-function ensureTrailingNewline(value: string): string {
-  return value.endsWith('\n') ? value : `${value}\n`
-}
-
-function previewText(text: string, max = 700): string {
-  if (text.length <= max) return text
-  return `${text.slice(0, max - 3)}...`
-}

package/src/identity/continuity/privateEdit/diff.ts

@@ -1,6 +0,0 @@
-import type { PrivateContinuityFile } from '../storage.js'
-import { renderUnifiedFileDiff } from '../../../tools/fileDiff.js'
-
-export function renderPrivateContinuityDiff(file: PrivateContinuityFile, before: string, after: string): string {
-  return renderUnifiedFileDiff({ filePath: file, before, after })
-}

package/src/identity/continuity/privateEdit/files.ts

@@ -1,23 +0,0 @@
-import fs from 'node:fs/promises'
-import { type EthagentIdentity } from '../../../storage/config.js'
-import { continuityVaultRef, defaultContinuityFiles, type PrivateContinuityFile } from '../storage.js'
-
-export function privateContinuityPath(identity: EthagentIdentity, file: PrivateContinuityFile): string {
-  const ref = continuityVaultRef(identity)
-  return file === 'SOUL.md' ? ref.soulPath : ref.memoryPath
-}
-
-export async function readPrivateContinuityFile(
-  identity: EthagentIdentity,
-  file: PrivateContinuityFile,
-  fullPath: string,
-): Promise<{ content: string; existedBefore: boolean }> {
-  try {
-    return { content: await fs.readFile(fullPath, 'utf8'), existedBefore: true }
-  } catch (err: unknown) {
-    if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
-      return { content: defaultContinuityFiles(identity)[file], existedBefore: false }
-    }
-    throw err
-  }
-}