ethagent 3.3.4 → 4.0.0

package/src/tools/editTool.ts

@@ -1,165 +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 { applyRequestedEdit } from './editUtils.js'
-import { formatFileChangeResult, renderUnifiedFileDiff } from './fileDiff.js'
-import { resolveWorkspacePath } from './readTool.js'
-
-const schema = z.object({
-  path: z.string().min(1),
-  oldText: z.string().optional(),
-  newText: z.string(),
-  replaceAll: z.boolean().optional(),
-  replaceWholeFile: z.boolean().optional(),
-})
-
-export const editTool: Tool<typeof schema> = {
-  name: 'edit_file',
-  kind: 'edit',
-  description: 'Edit a workspace text file. Provide oldText and newText for targeted replacement, or just newText only for ordinary whole-file workspace edits. Do not use for private SOUL.md or MEMORY.md when an identity is linked; use propose_private_continuity_edit instead.',
-  inputSchema: schema,
-  inputSchemaJson: {
-    type: 'object',
-    properties: {
-      path: { type: 'string', description: 'Path to the file to edit.' },
-      oldText: { type: 'string', description: 'Exact text to find and replace. Prefer this for existing files. Omit only for ordinary whole-file workspace edits.' },
-      newText: { type: 'string', description: 'Replacement text, or entire file contents if oldText is omitted.' },
-      replaceAll: { type: 'boolean', description: 'Replace every exact oldText match. Prefer false unless you are certain.' },
-    },
-    required: ['path', 'newText'],
-  },
-  parse(input) {
-    return schema.parse(input)
-  },
-  async buildPermissionRequest(input, context) {
-    const { fullPath, relativePath, applied } = await prepareEdit(input, context)
-    return {
-      kind: 'edit',
-      path: fullPath,
-      relativePath,
-      directoryPath: path.dirname(fullPath),
-      title: 'Allow file edit?',
-      subtitle: fullPath,
-      before: applied.previewBefore,
-      after: applied.previewAfter,
-      diff: renderUnifiedFileDiff({ filePath: relativePath, before: applied.before, after: applied.after }),
-      changeSummary: applied.summary,
-    }
-  },
-  async execute(input, context) {
-    const { fullPath, relativePath, applied, existedBefore, before } = await prepareEdit(input, context)
-    const rewindWarning = await tryRecordRewindSnapshot({
-      workspaceRoot: context.workspaceRoot,
-      filePath: fullPath,
-      relativePath,
-      existedBefore,
-      previousContent: before,
-      changeSummary: applied.summary,
-      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(fullPath), { recursive: true })
-    await fs.writeFile(fullPath, applied.after, 'utf8')
-    return {
-      ok: true,
-      summary: applied.summary,
-      content: formatFileChangeResult(
-        rewindWarning
-          ? `updated ${fullPath}\nwarning: ${rewindWarning}`
-          : `updated ${fullPath}`,
-        renderUnifiedFileDiff({ filePath: relativePath, before: applied.before, after: applied.after }),
-      ),
-    }
-  },
-}
-
-async function tryRecordRewindSnapshot(
-  snapshot: Parameters<typeof recordRewindSnapshot>[0],
-): Promise<string | undefined> {
-  try {
-    await recordRewindSnapshot(snapshot)
-    return undefined
-  } catch (error: unknown) {
-    const message = (error as Error).message || 'rewind checkpoint could not be recorded'
-    return `rewind checkpoint was not recorded (${message})`
-  }
-}
-
-async function prepareEdit(input: z.infer<typeof schema>, context: { workspaceRoot: string; config?: EthagentConfig }) {
-  assertSafeEditPath(input.path)
-  assertNotPrivateContinuityWorkspacePath(input.path, context.config, 'edit_file')
-  const fullPath = resolveWorkspacePath(context.workspaceRoot, input.path)
-  await assertEditableFileTarget(fullPath)
-  const { content: before, existed } = await readOptionalTextFile(fullPath)
-  const applied = applyRequestedEdit(
-    input.path,
-    before,
-    input.oldText,
-    input.newText,
-    input.replaceAll ?? false,
-    input.replaceWholeFile ?? false,
-  )
-  return {
-    fullPath,
-    relativePath: path.relative(context.workspaceRoot, fullPath) || path.basename(fullPath),
-    existedBefore: existed,
-    before,
-    applied,
-  }
-}
-
-async function assertEditableFileTarget(fullPath: string): Promise<void> {
-  try {
-    const stats = await fs.stat(fullPath)
-    if (stats.isDirectory()) {
-      throw new Error('Tool edit_file path points to a directory; provide a file path')
-    }
-  } catch (error: unknown) {
-    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return
-    throw error
-  }
-}
-
-function assertSafeEditPath(requestedPath: string): void {
-  const trimmed = requestedPath.trim()
-  if (trimmed !== requestedPath || trimmed.length === 0) {
-    throw new Error('Tool edit_file path must be a clean workspace-relative file path')
-  }
-
-  if (/[|;&<>`]/.test(trimmed)) {
-    throw new Error('Tool edit_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 edit_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`,
-  )
-}
-
-async function readOptionalTextFile(fullPath: string): Promise<{ content: string; existed: boolean }> {
-  try {
-    return { content: await fs.readFile(fullPath, 'utf8'), existed: true }
-  } catch (error: unknown) {
-    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return { content: '', existed: false }
-    throw error
-  }
-}

package/src/tools/editUtils.ts

@@ -1,170 +0,0 @@
-const LEFT_SINGLE_CURLY_QUOTE = '\u2018'
-const RIGHT_SINGLE_CURLY_QUOTE = '\u2019'
-const LEFT_DOUBLE_CURLY_QUOTE = '\u201c'
-const RIGHT_DOUBLE_CURLY_QUOTE = '\u201d'
-
-export type AppliedEdit = {
-  before: string
-  after: string
-  summary: string
-  previewBefore: string
-  previewAfter: string
-}
-
-export function applyRequestedEdit(
-  filePath: string,
-  before: string,
-  oldText: string | undefined,
-  newText: string,
-  replaceAll = false,
-  _replaceWholeFile = false,
-): AppliedEdit {
-  if (!oldText) {
-    if (newText.length === 0) {
-      throw new Error('Field newText is empty; empty whole-file writes are not valid unless replacing a specific oldText range')
-    }
-    return {
-      before,
-      after: newText,
-      summary: before.length === 0 ? `create ${filePath}` : `replace entire ${filePath}`,
-      previewBefore: previewText(before),
-      previewAfter: previewText(newText),
-    }
-  }
-
-  if (replaceAll) {
-    const matchCount = countOccurrences(before, oldText)
-    if (matchCount === 0) throw new Error('Field oldText was not found in the file')
-    return {
-      before,
-      after: before.replaceAll(oldText, () => newText),
-      summary: `replace ${matchCount} match${matchCount === 1 ? '' : 'es'} in ${filePath}`,
-      previewBefore: previewText(oldText),
-      previewAfter: previewText(newText),
-    }
-  }
-
-  const actualOldText = findUniqueEditableMatch(before, oldText)
-  if (!actualOldText) throw new Error('Field oldText was not found in the file')
-  if (countOccurrences(before, actualOldText) > 1) {
-    throw new Error('Field oldText matched multiple locations; provide more context or use replaceAll')
-  }
-
-  const adjustedNewText = preserveQuoteStyle(oldText, actualOldText, newText)
-  return {
-    before,
-    after: replaceSingleOccurrence(before, actualOldText, adjustedNewText),
-    summary: `edit ${filePath}`,
-    previewBefore: previewText(actualOldText),
-    previewAfter: previewText(adjustedNewText),
-  }
-}
-
-function replaceSingleOccurrence(content: string, search: string, replace: string): string {
-  const index = content.indexOf(search)
-  if (index === -1) throw new Error('Field oldText was not found in the file')
-  return `${content.slice(0, index)}${replace}${content.slice(index + search.length)}`
-}
-
-function findUniqueEditableMatch(fileContent: string, searchText: string): string | null {
-  const exactCount = countOccurrences(fileContent, searchText)
-  if (exactCount === 1) return searchText
-  if (exactCount > 1) return searchText
-
-  const normalizedSearch = normalizeQuotes(searchText)
-  const normalizedFile = normalizeQuotes(fileContent)
-  const firstIndex = normalizedFile.indexOf(normalizedSearch)
-  if (firstIndex === -1) return null
-
-  const secondIndex = normalizedFile.indexOf(normalizedSearch, firstIndex + normalizedSearch.length)
-  if (secondIndex !== -1) return null
-
-  return fileContent.slice(firstIndex, firstIndex + searchText.length)
-}
-
-function countOccurrences(content: string, search: string): number {
-  if (!search) return 0
-  let count = 0
-  let offset = 0
-  while (true) {
-    const index = content.indexOf(search, offset)
-    if (index === -1) return count
-    count += 1
-    offset = index + search.length
-  }
-}
-
-function normalizeQuotes(text: string): string {
-  return text
-    .replaceAll(LEFT_SINGLE_CURLY_QUOTE, "'")
-    .replaceAll(RIGHT_SINGLE_CURLY_QUOTE, "'")
-    .replaceAll(LEFT_DOUBLE_CURLY_QUOTE, '"')
-    .replaceAll(RIGHT_DOUBLE_CURLY_QUOTE, '"')
-}
-
-function preserveQuoteStyle(oldText: string, actualOldText: string, newText: string): string {
-  if (oldText === actualOldText) return newText
-
-  let result = newText
-  if (containsCurlyDoubleQuotes(actualOldText)) result = applyCurlyDoubleQuotes(result)
-  if (containsCurlySingleQuotes(actualOldText)) result = applyCurlySingleQuotes(result)
-  return result
-}
-
-function containsCurlyDoubleQuotes(text: string): boolean {
-  return text.includes(LEFT_DOUBLE_CURLY_QUOTE) || text.includes(RIGHT_DOUBLE_CURLY_QUOTE)
-}
-
-function containsCurlySingleQuotes(text: string): boolean {
-  return text.includes(LEFT_SINGLE_CURLY_QUOTE) || text.includes(RIGHT_SINGLE_CURLY_QUOTE)
-}
-
-function applyCurlyDoubleQuotes(text: string): string {
-  const chars = [...text]
-  const out: string[] = []
-
-  for (let index = 0; index < chars.length; index += 1) {
-    const char = chars[index]
-    if (char !== '"') {
-      out.push(char!)
-      continue
-    }
-    out.push(isOpeningContext(chars, index) ? LEFT_DOUBLE_CURLY_QUOTE : RIGHT_DOUBLE_CURLY_QUOTE)
-  }
-
-  return out.join('')
-}
-
-function applyCurlySingleQuotes(text: string): string {
-  const chars = [...text]
-  const out: string[] = []
-
-  for (let index = 0; index < chars.length; index += 1) {
-    const char = chars[index]
-    if (char !== "'") {
-      out.push(char!)
-      continue
-    }
-
-    const prev = index > 0 ? chars[index - 1] : undefined
-    const next = index < chars.length - 1 ? chars[index + 1] : undefined
-    if (prev && next && /\p{L}/u.test(prev) && /\p{L}/u.test(next)) {
-      out.push(RIGHT_SINGLE_CURLY_QUOTE)
-      continue
-    }
-
-    out.push(isOpeningContext(chars, index) ? LEFT_SINGLE_CURLY_QUOTE : RIGHT_SINGLE_CURLY_QUOTE)
-  }
-
-  return out.join('')
-}
-
-function isOpeningContext(chars: string[], index: number): boolean {
-  if (index === 0) return true
-  return [' ', '\t', '\n', '\r', '(', '[', '{'].includes(chars[index - 1] ?? '')
-}
-
-function previewText(text: string, max = 700): string {
-  if (text.length <= max) return text
-  return `${text.slice(0, max - 3)}...`
-}

package/src/tools/fileDiff.ts

@@ -1,261 +0,0 @@
-export const DEFAULT_DIFF_CONTEXT_LINES = 3
-export const DEFAULT_DIFF_MAX_CHARS = 2400
-export const FILE_DIFF_RESULT_MARKER = '\n\n<!-- ethagent:file-diff:v1 -->\n'
-
-type DiffOp =
-  | { type: 'equal'; line: string }
-  | { type: 'delete'; line: string }
-  | { type: 'insert'; line: string }
-
-type HunkRange = {
-  start: number
-  end: number
-}
-
-type RenderUnifiedFileDiffInput = {
-  filePath: string
-  before: string
-  after: string
-  contextLines?: number
-  maxChars?: number
-}
-
-const LARGE_DIFF_MATRIX_LIMIT = 500_000
-
-export function renderUnifiedFileDiff(input: RenderUnifiedFileDiffInput): string {
-  const contextLines = input.contextLines ?? DEFAULT_DIFF_CONTEXT_LINES
-  const maxChars = input.maxChars ?? DEFAULT_DIFF_MAX_CHARS
-  const header = [`--- ${input.filePath}`, `+++ ${input.filePath}`]
-
-  if (input.before === input.after) {
-    return header.concat('(no changes)').join('\n')
-  }
-
-  const beforeLines = normalizedLines(input.before)
-  const afterLines = normalizedLines(input.after)
-  const ops = buildLineDiff(beforeLines, afterLines)
-  const hunks = buildHunkRanges(ops, contextLines)
-
-  if (hunks.length === 0) {
-    return header.concat('(only line ending changes)').join('\n')
-  }
-
-  const lines = [...header]
-  for (const hunk of hunks) {
-    const oldStart = countOldLines(ops, 0, hunk.start) + 1
-    const newStart = countNewLines(ops, 0, hunk.start) + 1
-    const oldCount = countOldLines(ops, hunk.start, hunk.end)
-    const newCount = countNewLines(ops, hunk.start, hunk.end)
-    lines.push(`@@ -${formatRange(oldStart, oldCount)} +${formatRange(newStart, newCount)} @@`)
-    for (const op of ops.slice(hunk.start, hunk.end)) {
-      if (op.type === 'equal') lines.push(` ${op.line}`)
-      else if (op.type === 'delete') lines.push(`-${op.line}`)
-      else lines.push(`+${op.line}`)
-    }
-  }
-
-  return truncateDiff(lines, maxChars)
-}
-
-export function formatFileChangeResult(content: string, diff: string): string {
-  return `${content}${FILE_DIFF_RESULT_MARKER}${diff}`
-}
-
-export function splitFileChangeResult(content: string): { content: string; diff?: string } {
-  const markerIndex = content.indexOf(FILE_DIFF_RESULT_MARKER)
-  if (markerIndex === -1) return { content }
-  const diff = content.slice(markerIndex + FILE_DIFF_RESULT_MARKER.length).trimEnd()
-  return {
-    content: content.slice(0, markerIndex).trimEnd(),
-    diff: diff.length > 0 ? diff : undefined,
-  }
-}
-
-export function stripFileChangeResultDiff(content: string): string {
-  return splitFileChangeResult(content).content
-}
-
-export function computeLineDiffStats(before: string, after: string): { inserts: number; deletes: number } {
-  if (before === after) return { inserts: 0, deletes: 0 }
-  const beforeLines = normalizedLines(before)
-  const afterLines = normalizedLines(after)
-  const ops = buildLineDiff(beforeLines, afterLines)
-  let inserts = 0
-  let deletes = 0
-  for (const op of ops) {
-    if (op.type === 'insert') inserts += 1
-    else if (op.type === 'delete') deletes += 1
-  }
-  return { inserts, deletes }
-}
-
-function buildLineDiff(beforeLines: string[], afterLines: string[]): DiffOp[] {
-  if (beforeLines.length * afterLines.length > LARGE_DIFF_MATRIX_LIMIT) {
-    return buildPrefixSuffixDiff(beforeLines, afterLines)
-  }
-
-  const lengths = lcsLengths(beforeLines, afterLines)
-  const ops: DiffOp[] = []
-  let beforeIndex = 0
-  let afterIndex = 0
-
-  while (beforeIndex < beforeLines.length && afterIndex < afterLines.length) {
-    const beforeLine = beforeLines[beforeIndex]!
-    const afterLine = afterLines[afterIndex]!
-    if (beforeLine === afterLine) {
-      ops.push({ type: 'equal', line: beforeLine })
-      beforeIndex += 1
-      afterIndex += 1
-      continue
-    }
-
-    const deleteScore = lengths[beforeIndex + 1]![afterIndex]!
-    const insertScore = lengths[beforeIndex]![afterIndex + 1]!
-    const deleteRevealsMatch = beforeLines[beforeIndex + 1] === afterLine
-    const insertRevealsMatch = beforeLine === afterLines[afterIndex + 1]
-
-    if (insertRevealsMatch && insertScore >= deleteScore) {
-      ops.push({ type: 'insert', line: afterLine })
-      afterIndex += 1
-    } else if (deleteRevealsMatch && deleteScore >= insertScore) {
-      ops.push({ type: 'delete', line: beforeLine })
-      beforeIndex += 1
-    } else if (deleteScore >= insertScore) {
-      ops.push({ type: 'delete', line: beforeLine })
-      beforeIndex += 1
-    } else {
-      ops.push({ type: 'insert', line: afterLine })
-      afterIndex += 1
-    }
-  }
-
-  while (beforeIndex < beforeLines.length) {
-    ops.push({ type: 'delete', line: beforeLines[beforeIndex]! })
-    beforeIndex += 1
-  }
-  while (afterIndex < afterLines.length) {
-    ops.push({ type: 'insert', line: afterLines[afterIndex]! })
-    afterIndex += 1
-  }
-
-  return ops
-}
-
-function buildPrefixSuffixDiff(beforeLines: string[], afterLines: string[]): DiffOp[] {
-  let prefixLength = 0
-  while (
-    prefixLength < beforeLines.length &&
-    prefixLength < afterLines.length &&
-    beforeLines[prefixLength] === afterLines[prefixLength]
-  ) {
-    prefixLength += 1
-  }
-
-  let beforeEnd = beforeLines.length
-  let afterEnd = afterLines.length
-  while (
-    beforeEnd > prefixLength &&
-    afterEnd > prefixLength &&
-    beforeLines[beforeEnd - 1] === afterLines[afterEnd - 1]
-  ) {
-    beforeEnd -= 1
-    afterEnd -= 1
-  }
-
-  const ops: DiffOp[] = []
-  for (let index = 0; index < prefixLength; index += 1) {
-    ops.push({ type: 'equal', line: beforeLines[index]! })
-  }
-  for (let index = prefixLength; index < beforeEnd; index += 1) {
-    ops.push({ type: 'delete', line: beforeLines[index]! })
-  }
-  for (let index = prefixLength; index < afterEnd; index += 1) {
-    ops.push({ type: 'insert', line: afterLines[index]! })
-  }
-  for (let index = beforeEnd; index < beforeLines.length; index += 1) {
-    ops.push({ type: 'equal', line: beforeLines[index]! })
-  }
-  return ops
-}
-
-function lcsLengths(beforeLines: string[], afterLines: string[]): number[][] {
-  const lengths = Array.from(
-    { length: beforeLines.length + 1 },
-    () => Array<number>(afterLines.length + 1).fill(0),
-  )
-
-  for (let beforeIndex = beforeLines.length - 1; beforeIndex >= 0; beforeIndex -= 1) {
-    for (let afterIndex = afterLines.length - 1; afterIndex >= 0; afterIndex -= 1) {
-      lengths[beforeIndex]![afterIndex] = beforeLines[beforeIndex] === afterLines[afterIndex]
-        ? lengths[beforeIndex + 1]![afterIndex + 1]! + 1
-        : Math.max(lengths[beforeIndex + 1]![afterIndex]!, lengths[beforeIndex]![afterIndex + 1]!)
-    }
-  }
-
-  return lengths
-}
-
-function buildHunkRanges(ops: DiffOp[], contextLines: number): HunkRange[] {
-  const ranges: HunkRange[] = []
-  const context = Math.max(0, contextLines)
-
-  for (let index = 0; index < ops.length; index += 1) {
-    if (ops[index]?.type === 'equal') continue
-    const start = Math.max(0, index - context)
-    const end = Math.min(ops.length, index + context + 1)
-    const previous = ranges[ranges.length - 1]
-    if (previous && start <= previous.end) {
-      previous.end = Math.max(previous.end, end)
-    } else {
-      ranges.push({ start, end })
-    }
-  }
-
-  return ranges
-}
-
-function countOldLines(ops: DiffOp[], start: number, end: number): number {
-  let count = 0
-  for (let index = start; index < end; index += 1) {
-    const type = ops[index]?.type
-    if (type === 'equal' || type === 'delete') count += 1
-  }
-  return count
-}
-
-function countNewLines(ops: DiffOp[], start: number, end: number): number {
-  let count = 0
-  for (let index = start; index < end; index += 1) {
-    const type = ops[index]?.type
-    if (type === 'equal' || type === 'insert') count += 1
-  }
-  return count
-}
-
-function formatRange(start: number, count: number): string {
-  if (count === 0) return `${Math.max(0, start - 1)},0`
-  if (count === 1) return String(start)
-  return `${start},${count}`
-}
-
-function normalizedLines(value: string): string[] {
-  if (value.length === 0) return []
-  const lines = value.replace(/\r\n?/g, '\n').split('\n')
-  if (lines[lines.length - 1] === '') lines.pop()
-  return lines
-}
-
-function truncateDiff(lines: string[], maxChars: number): string {
-  const diff = lines.join('\n')
-  if (diff.length <= maxChars) return diff
-
-  const out: string[] = []
-  let length = 0
-  for (const line of lines) {
-    const nextLength = length + (out.length > 0 ? 1 : 0) + line.length
-    if (nextLength > maxChars) break
-    out.push(line)
-    length = nextLength
-  }
-  return out.join('\n')
-}

package/src/tools/listDirectoryTool.ts

@@ -1,55 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import { z } from 'zod'
-import type { Tool } from './contracts.js'
-import { resolveWorkspacePath } from './readTool.js'
-
-const schema = z.object({
-  path: z.string().optional(),
-})
-
-export const listDirectoryTool: Tool<typeof schema> = {
-  name: 'list_directory',
-  kind: 'read',
-  description: 'List files and folders in the current workspace. Use this first when you need to discover existing files before reading or editing them.',
-  inputSchema: schema,
-  inputSchemaJson: {
-    type: 'object',
-    properties: {
-      path: { type: 'string', description: 'Optional directory path relative to the current workspace.' },
-    },
-    required: [],
-  },
-  parse(input) {
-    return schema.parse(input)
-  },
-  async buildPermissionRequest(input, context) {
-    const fullPath = resolveWorkspacePath(context.workspaceRoot, input.path ?? '.')
-    const relativePath = path.relative(context.workspaceRoot, fullPath) || '.'
-    return {
-      kind: 'read',
-      path: fullPath,
-      relativePath,
-      directoryPath: fullPath,
-      title: 'Allow directory listing?',
-      subtitle: fullPath,
-    }
-  },
-  async execute(input, context) {
-    const fullPath = resolveWorkspacePath(context.workspaceRoot, input.path ?? '.')
-    const entries = await fs.readdir(fullPath, { withFileTypes: true })
-    const lines = entries
-      .sort((left, right) => {
-        if (left.isDirectory() && !right.isDirectory()) return -1
-        if (!left.isDirectory() && right.isDirectory()) return 1
-        return left.name.localeCompare(right.name)
-      })
-      .map(entry => `${entry.isDirectory() ? '[dir]' : '     '} ${entry.name}`)
-    const relativePath = path.relative(context.workspaceRoot, fullPath) || '.'
-    return {
-      ok: true,
-      summary: `listed ${relativePath}`,
-      content: lines.length > 0 ? lines.join('\n') : '(empty directory)',
-    }
-  },
-}