内置工具全景

// tools/BashTool/commandClassification.ts — 简化版

// 命令分类常量
export const BASH_SEARCH_COMMANDS = new Set([
  'grep', 'rg', 'find', 'fd', 'ag', 'ack',
  'locate', 'which', 'whereis', 'type',
])

export const BASH_READ_COMMANDS = new Set([
  'cat', 'head', 'tail', 'less', 'more',
  'wc', 'file', 'stat', 'md5sum', 'sha256sum',
])

export const BASH_LIST_COMMANDS = new Set([
  'ls', 'tree', 'du', 'df', 'find', 'exa',
])

export const BASH_SILENT_COMMANDS = new Set([
  'cd', 'pwd', 'echo', 'printf', 'true', 'false',
  'test', '[', '[[',
])

// treeSitterAnalysis.ts — AST 分析
import Parser from 'tree-sitter'
import Bash from 'tree-sitter-bash'

export function analyzeCommand(command: string): CommandAnalysis {
  const parser = new Parser()
  parser.setLanguage(Bash)
  const tree = parser.parse(command)

  const analysis: CommandAnalysis = {
    commands: [],       // 所有命令名
    hasRedirection: false,
    hasPipe: false,
    hasCommandSubstitution: false,
    hasDestructiveOp: false,
    isReadOnly: true,
  }

  // 遍历 AST 节点
  function visit(node: Parser.SyntaxNode) {
    switch (node.type) {
      case 'command':
        const cmdName = node.firstChild?.text ?? ''
        analysis.commands.push(cmdName)
        if (!isReadOnlyCommand(cmdName)) {
          analysis.isReadOnly = false
        }
        break

      case 'redirected_statement':
      case 'file_redirect':
        analysis.hasRedirection = true
        analysis.isReadOnly = false // 重定向意味着写操作
        break

      case 'pipeline':
        analysis.hasPipe = true
        break

      case 'command_substitution':
        analysis.hasCommandSubstitution = true
        break
    }

    for (const child of node.children) {
      visit(child)
    }
  }

  visit(tree.rootNode)
  return analysis
}

function isReadOnlyCommand(cmd: string): boolean {
  return BASH_SEARCH_COMMANDS.has(cmd)
    || BASH_READ_COMMANDS.has(cmd)
    || BASH_LIST_COMMANDS.has(cmd)
    || BASH_SILENT_COMMANDS.has(cmd)
}

// tools/FileEditTool.ts — 简化版
import { z } from 'zod'
import { readFile, writeFile } from 'fs/promises'
import { createPatch } from 'diff'

export class FileEditTool implements Tool {
  name = 'Edit'

  inputSchema = z.object({
    file_path: z.string().describe('要编辑的文件绝对路径'),
    old_string: z.string().describe('要替换的文本'),
    new_string: z.string().describe('替换后的新文本'),
    replace_all: z.boolean().optional().default(false)
      .describe('是否替换所有匹配项'),
  })

  async call(
    input: z.infer<typeof this.inputSchema>,
    context: ToolUseContext
  ): Promise<ToolResult> {
    const { file_path, old_string, new_string, replace_all } = input

    // 读取文件
    const content = await readFile(file_path, 'utf-8')

    // 唯一性检测
    if (!replace_all) {
      const matchCount = countOccurrences(content, old_string)

      if (matchCount === 0) {
        return {
          data: '错误: old_string 在文件中未找到。\n' +
            '请确认要替换的文本与文件内容完全匹配（包括缩进和空白）。',
        }
      }

      if (matchCount > 1) {
        // 非唯一匹配：提示用户提供更多上下文
        const locations = findMatchLocations(content, old_string)
        return {
          data: '错误: old_string 在文件中匹配到 ' + matchCount + ' 处。\n' +
            '匹配位置: 行 ' + locations.join(', ') + '\n' +
            '请提供更多上下文使 old_string 唯一，或使用 replace_all=true。',
        }
      }
    }

    // 执行替换
    const newContent = replace_all
      ? content.replaceAll(old_string, new_string)
      : content.replace(old_string, new_string)

    // 计算 diff（用于 UI 展示）
    const diff = createPatch(file_path, content, newContent)

    // 记录文件历史
    context.readFileState.recordEdit(file_path, content)

    // 写入文件
    await writeFile(file_path, newContent, 'utf-8')

    return {
      data: '文件已更新: ' + file_path + '\n\n' + diff,
    }
  }

  isReadOnly() { return false }
  isConcurrencySafe() { return false }
  isDestructive() { return false }
}

function countOccurrences(text: string, search: string): number {
  let count = 0
  let pos = 0
  while ((pos = text.indexOf(search, pos)) !== -1) {
    count++
    pos += search.length
  }
  return count
}

// tools/FileReadTool.ts — 简化版
import { readFile, stat } from 'fs/promises'
import { extname } from 'path'
import sharp from 'sharp'

const IMAGE_EXTENSIONS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp'])
const MAX_LINES = 2000
const MAX_IMAGE_DIMENSION = 2048

export class FileReadTool implements Tool {
  name = 'Read'

  async call(
    input: { file_path: string; offset?: number; limit?: number; pages?: string },
    context: ToolUseContext
  ): Promise<ToolResult> {
    const ext = extname(input.file_path).toLowerCase()

    // 图片处理管线
    if (IMAGE_EXTENSIONS.has(ext)) {
      return this.readImage(input.file_path)
    }

    // PDF 处理
    if (ext === '.pdf') {
      return this.readPDF(input.file_path, input.pages)
    }

    // Jupyter Notebook 处理
    if (ext === '.ipynb') {
      return this.readNotebook(input.file_path)
    }

    // 文本文件：带行号输出
    return this.readText(input.file_path, input.offset, input.limit)
  }

  private async readText(
    filePath: string,
    offset = 0,
    limit = MAX_LINES
  ): Promise<ToolResult> {
    const content = await readFile(filePath, 'utf-8')
    const lines = content.split('\n')

    const selectedLines = lines.slice(offset, offset + limit)
    const numbered = selectedLines.map(
      (line, i) => (offset + i + 1).toString().padStart(6) + '\t' + line
    )

    let result = numbered.join('\n')
    if (offset + limit < lines.length) {
      result += '\n\n... (文件共 ' + lines.length + ' 行，' +
        '已显示 ' + (offset + 1) + '-' + (offset + limit) + ' 行)'
    }

    return { data: result }
  }

  private async readImage(filePath: string): Promise<ToolResult> {
    // 1. 读取元数据
    const metadata = await sharp(filePath).metadata()
    const { width = 0, height = 0 } = metadata

    // 2. Resize 决策
    let image = sharp(filePath)
    if (width > MAX_IMAGE_DIMENSION || height > MAX_IMAGE_DIMENSION) {
      image = image.resize(MAX_IMAGE_DIMENSION, MAX_IMAGE_DIMENSION, {
        fit: 'inside',          // 保持比例
        withoutEnlargement: true, // 不放大
      })
    }

    // 3. 转为 base64
    const buffer = await image.toBuffer()
    const base64 = buffer.toString('base64')

    return {
      data: base64,
      // 作为 image content block 传给 Claude
    }
  }

  isReadOnly() { return true }
  isConcurrencySafe() { return true }
}