foliko 1.1.93 → 2.0.1

package/plugins/{file-system-plugin.js → io/file-system/index.js}

@@ -3,10 +3,11 @@
  * 提供文件系统操作的常用工具
  */
 
-const { Plugin } = require('../src/core/plugin-base')
+const { Plugin } = require('../../../src/plugin/base')
 const { NodeHtmlMarkdown } = require('node-html-markdown')
 const { Readable } = require('stream')
 const { pipeline } = require('stream/promises')
+
 class FileSystemPlugin extends Plugin {
   constructor(config = {}) {
     super()
@@ -14,7 +15,7 @@ class FileSystemPlugin extends Plugin {
     this.version = '1.0.0'
     this.description = '文件系统工具插件'
     this.priority = 12
-    this.system = true 
+    this.system = true
   }
 
   install(framework) {
@@ -23,17 +24,14 @@ class FileSystemPlugin extends Plugin {
     const path = require('path')
     const { exec } = require('child_process')
 
-    // 路径安全验证：防止路径穿越攻击
     const validatePath = (filePath, allowOutsideCwd = false) => {
       const resolved = path.resolve(filePath)
       const cwd = framework?.getCwd?.() ?? process.cwd()
 
-      // 允许绝对路径且在允许列表中的路径（如果有的话）
       if (allowOutsideCwd) {
         return { valid: true, resolved }
       }
 
-      // 检查是否在 cwd 目录下
       if (!resolved.startsWith(cwd)) {
         return { valid: false, error: `路径不允许访问: ${filePath}` }
       }
@@ -41,7 +39,6 @@ class FileSystemPlugin extends Plugin {
       return { valid: true, resolved }
     }
 
-    // 读取目录
     framework.registerTool({
       name: 'read_directory',
       description: '读取目录内容，列出目录中的文件和子目录',
@@ -84,7 +81,6 @@ class FileSystemPlugin extends Plugin {
       }
     })
 
-    // 创建目录
     framework.registerTool({
       name: 'create_directory',
       description: '创建新目录',
@@ -103,7 +99,6 @@ class FileSystemPlugin extends Plugin {
       }
     })
 
-    // 读取文件
     framework.registerTool({
       name: 'read',
       description: '读取文件内容。path 是必填参数。',
@@ -117,7 +112,6 @@ class FileSystemPlugin extends Plugin {
           return { success: false, error: 'path 是必填参数' }
         }
 
-        // 路径安全验证
         const pathCheck = validatePath(filePath)
         if (!pathCheck.valid) {
           return { success: false, error: pathCheck.error }
@@ -154,7 +148,6 @@ class FileSystemPlugin extends Plugin {
       }
     })
 
-    // 写入文件
     framework.registerTool({
       name: 'write',
       description: `创建或写入文件内容（仅适用于小文件，建议小于10KB）。
@@ -168,7 +161,7 @@ class FileSystemPlugin extends Plugin {
       }),
       execute: async (args, framework) => {
         const { path: filePath, content, mode = 'write' } = args
-        
+
         const pathCheck = validatePath(filePath)
         if (!pathCheck.valid) {
           return { success: false, error: pathCheck.error }
@@ -179,35 +172,33 @@ class FileSystemPlugin extends Plugin {
           if (!fs.existsSync(dir)) {
             fs.mkdirSync(dir, { recursive: true })
           }
-          
+
           const flag = mode === 'append' ? 'a' : 'w'
-          const writeStream = fs.createWriteStream(pathCheck.resolved, { 
+          const writeStream = fs.createWriteStream(pathCheck.resolved, {
             encoding: 'utf8',
             flags: flag,
-            highWaterMark: 256 * 1024 // 256KB 缓冲区
+            highWaterMark: 256 * 1024
           })
-          
-          // 分块写入，避免背压问题
-          const CHUNK_SIZE = 1024 * 1024 // 1MB 块
+
+          const CHUNK_SIZE = 1024 * 1024
           let offset = 0
-          
+
           const writeChunk = async () => {
             while (offset < content.length) {
               const end = Math.min(offset + CHUNK_SIZE, content.length)
               const chunk = content.slice(offset, end)
-              
+
               const canContinue = writeStream.write(chunk)
               offset = end
-              
-              // 如果缓冲区满了，等待 drain 事件
+
               if (!canContinue && offset < content.length) {
                 await new Promise(resolve => writeStream.once('drain', resolve))
               }
             }
           }
-          
+
           await writeChunk()
-          
+
           return new Promise((resolve, reject) => {
             writeStream.end((err) => {
               if (err) reject(err)
@@ -222,22 +213,16 @@ class FileSystemPlugin extends Plugin {
               })
             })
           })
-          
+
         } catch (error) {
           return { success: false, error: error.message }
         }
       }
     })
 
-    // 追加文件内容（用于大文件分段写入）
     framework.registerTool({
       name: 'append_to_file',
-      description: `追加内容到文件末尾。适用于大文件写入，每次最多追加约64KB内容。
-
-使用方式：
-1. 先用 write_file 创建新文件（或清空现有文件）
-2. 多次调用 append_to_file 追加内容，每次 content 不超过 64KB
-3. 追加顺序很重要，content 应该按文件顺序排列`,
+      description: `追加内容到文件末尾。适用于大文件写入，每次最多追加约64KB内容。`,
       inputSchema: z.object({
         path: z.string().describe('文件路径'),
         content: z.string().describe('要追加的内容（建议不超过64KB）')
@@ -251,7 +236,6 @@ class FileSystemPlugin extends Plugin {
         }
 
         try {
-          // 如果文件不存在，返回错误（应该先用 write_file 创建）
           if (!fs.existsSync(pathCheck.resolved)) {
             return { success: false, error: '文件不存在，请先用 write_file 创建文件' }
           }
@@ -271,7 +255,6 @@ class FileSystemPlugin extends Plugin {
       }
     })
 
-    // 删除文件
     framework.registerTool({
       name: 'delete_file',
       description: '删除文件或目录',
@@ -284,7 +267,6 @@ class FileSystemPlugin extends Plugin {
         const targetPath = args.path || args.targetPath
         const recursive = args.recursive || false
 
-        // 路径安全验证
         const pathCheck = validatePath(targetPath)
         if (!pathCheck.valid) {
           return { success: false, error: pathCheck.error }
@@ -311,162 +293,9 @@ class FileSystemPlugin extends Plugin {
       }
     })
 
-    // 修改文件（替换文本）
-        // framework.registerTool({
-        //   name: 'modify_file',
-        //   description: '（已弃用，请使用 edit 替代）修改文件内容（替换文本），支持精确匹配和正则',
-        //   inputSchema: z.object({
-        //     filePath: z.string().describe('文件路径（必须）'),
-        //     find: z.string().min(1).describe('要查找的文本（必填，不能为空）'),
-        //     replace: z.string().describe('替换后的文本'),
-        //     replaceAll: z.boolean().optional().describe('是否替换所有匹配，默认 true'),
-        //     useRegex: z.boolean().optional().describe('是否使用正则表达式匹配，默认 false'),
-        //     backup: z.boolean().default(false).describe('修改前是否创建备份，默认 false')
-        //   }),
-        //   execute: async (args, framework) => {
-        //     const filePath = args.filePath || args.path
-        //     const find = args.find
-        //     const replace = args.replace
-        //     const replaceAll = args.replaceAll !== false // 默认 true
-        //     const useRegex = args.useRegex === true
-        //     const backup = args.backup !== false // 默认 true
-
-        //     // 校验 filePath
-        //     if (!filePath || typeof filePath !== 'string' || filePath.trim() === '') {
-        //       return { success: false, error: 'filePath 是必填参数，不能为空' }
-        //     }
-
-        //     // 校验 find
-        //     if (!find || typeof find !== 'string' || find.trim() === '') {
-        //       return { success: false, error: 'find 是必填参数，不能为空字符串' }
-        //     }
-
-        //     // 路径安全验证
-        //     const pathCheck = validatePath(filePath)
-        //     if (!pathCheck.valid) {
-        //       return { success: false, error: pathCheck.error }
-        //     }
-
-        //     try {
-        //       if (!fs.existsSync(pathCheck.resolved)) {
-        //         return { success: false, error: '文件不存在' }
-        //       }
-
-        //       // 检查是否是二进制文件
-        //       const stats = fs.statSync(pathCheck.resolved)
-        //       if (stats.size > 10 * 1024 * 1024) {
-        //         return { success: false, error: '文件超过 10MB，不支持修改' }
-        //       }
-
-        //       let content = fs.readFileSync(pathCheck.resolved, 'utf8')
-        //       let count = 0
-        //       const matches = []
-
-        //       if (useRegex) {
-        //         // 正则表达式模式
-        //         const flags = replaceAll ? 'g' : ''
-        //         const regex = new RegExp(find, flags)
-
-        //         let match
-        //         while ((match = regex.exec(content)) !== null) {
-        //           matches.push({
-        //             index: match.index,
-        //             length: match[0].length,
-        //             text: match[0]
-        //           })
-        //           if (!replaceAll) break
-        //         }
-
-        //         if (matches.length > 0) {
-        //           count = replaceAll ? matches.length : 1
-        //           content = content.replace(regex, replace)
-        //         }
-        //       } else {
-        //         // 精确字符串匹配
-        //         const escapedFind = find.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-        //         const flags = replaceAll ? 'g' : ''
-        //         const regex = new RegExp(escapedFind, flags)
-
-        //         let match
-        //         while ((match = regex.exec(content)) !== null) {
-        //           matches.push({
-        //             index: match.index,
-        //             length: match[0].length,
-        //             text: match[0]
-        //           })
-        //           if (!replaceAll) break
-        //         }
-
-        //         if (matches.length > 0) {
-        //           count = replaceAll ? matches.length : 1
-        //           content = content.replace(regex, replace)
-        //         }
-        //       }
-
-        //       if (count === 0) {
-        //         return {
-        //           success: false,
-        //           error: `未找到匹配文本: "${find.substring(0, 50)}${find.length > 50 ? '...' : ''}"`,
-        //           filePath
-        //         }
-        //       }
-
-        //       // 创建备份
-        //       if (backup) {
-        //         const backupPath = pathCheck.resolved + '.bak'
-        //         fs.writeFileSync(backupPath, fs.readFileSync(pathCheck.resolved), 'utf8')
-        //       }
-
-        //       // 原子写入：先写临时文件，再 rename
-        //       const tempPath = pathCheck.resolved + '.tmp.' + Date.now()
-        //       fs.writeFileSync(tempPath, content, 'utf8')
-
-        //       // 验证写入内容
-        //       const verifyContent = fs.readFileSync(tempPath, 'utf8')
-        //       if (verifyContent !== content) {
-        //         fs.unlinkSync(tempPath)
-        //         return { success: false, error: '写入验证失败，内容不匹配' }
-        //       }
-
-        //       fs.renameSync(tempPath, pathCheck.resolved)
-
-        //       return {
-        //         success: true,
-        //         message: `文件已修改: ${pathCheck.resolved}`,
-        //         filePath: pathCheck.resolved,
-        //         replacements: count,
-        //         matches: matches.slice(0, 5), // 最多返回5个匹配位置
-        //         backupCreated: backup
-        //       }
-        //     } catch (error) {
-        //       return { success: false, error: error.message }
-        //     }
-        //   }
-        // })
-
-    // ── 精确编辑工具（diff 感知） ────────────────────────────────
-    // 标准名 edit，LLM（尤其 Claude）训练时就使用这个名称
     const editToolDef = {
       name: 'edit',
-      description: `精确编辑文件，支持一个或多个不重叠的文本替换。
-
-注意：modify_file 是旧版工具，请优先使用 edit。
-
-edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldText（原文）和 newText（新文本）指定。
-
-替换逻辑：
-- 先尝试精确匹配 oldText，失败后使用模糊匹配（忽略引号、破折号、空白差异）
-- 所有 edits 匹配原始文件内容，不依赖先后顺序
-- 输出结果包含 unified diff 格式的变更摘要
-
-适用场景：
-1. 修改函数/类中的特定代码块
-2. 同时修改文件中多个不重叠的部分
-3. 重命名变量或导入语句
-
-注意：
-- oldText 必须唯一，不能有多个匹配
-- edits 之间不能重叠，否则会报错`,
+      description: `精确编辑文件，支持一个或多个不重叠的文本替换。`,
       inputSchema: z.object({
         path: z.string().describe('要编辑的文件路径'),
         edits: z.array(z.object({
@@ -476,23 +305,20 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
       }),
       execute: async (args, framework) => {
         const { path: filePath, edits } = args;
-        const editDiff = require('../src/utils/edit-diff');
+        const editDiff = require('../../../src/common/diff');
         const result = await editDiff.applyEditsToFile(filePath, edits, framework?.getCwd?.() ?? process.cwd());
         return result;
       }
     };
 
-    // 注册为 edit（标准名称）
     framework.registerTool(editToolDef);
 
-    // 别名 edit_file（兼容旧调用）
     framework.registerTool({
       ...editToolDef,
       name: 'edit_file',
       description: 'edit 工具的别名，推荐直接使用 edit',
     });
 
-    // 搜索文件
     framework.registerTool({
       name: 'search_file',
       description: '在文件或目录中搜索文本，支持精确匹配和正则表达式',
@@ -529,14 +355,12 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
           let regex
 
           if (useRegex) {
-            // 直接使用正则表达式
             try {
               regex = new RegExp(pattern, caseSensitive ? 'g' : 'gi')
             } catch (e) {
               return { success: false, error: `无效的正则表达式: ${e.message}` }
             }
           } else {
-            // 转义特殊字符作为精确匹配
             const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
             regex = new RegExp(escaped, caseSensitive ? 'g' : 'gi')
           }
@@ -551,10 +375,9 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
             for (let i = 0; i < lines.length; i++) {
               if (fileResultsCount >= maxResultsPerFile) break
               const line = lines[i]
-              regex.lastIndex = 0 // 重置 regex 状态
+              regex.lastIndex = 0
 
               if (regex.test(line)) {
-                // 找到所有匹配的位置
                 const lineMatches = []
                 regex.lastIndex = 0
                 let match
@@ -591,7 +414,6 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
             return matches
           }
 
-          // 搜索单个文件
           if (targetFile) {
             const fullPath = path.resolve(targetFile)
             if (!fs.existsSync(fullPath)) {
@@ -611,7 +433,6 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
               return { success: false, error: `读取文件失败: ${e.message}` }
             }
           } else {
-            // 搜索目录
             const searchDir = (currentPath, depth = 0) => {
               if (depth > 10 || results.length >= maxResults) return
 
@@ -619,7 +440,7 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
               try {
                 entries = fs.readdirSync(currentPath, { withFileTypes: true })
               } catch (e) {
-                return // 跳过无法读取的目录
+                return
               }
 
               for (const entry of entries) {
@@ -628,7 +449,6 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
                 const fullPath = path.join(currentPath, entry.name)
                 const relativePath = path.relative(cwd, fullPath)
 
-                // 检查是否在排除目录中
                 const shouldExclude = excludeDirs.some(exclude =>
                   relativePath.includes(exclude)
                 )
@@ -637,7 +457,6 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
                 if (entry.isDirectory()) {
                   searchDir(fullPath, depth + 1)
                 } else if (entry.isFile()) {
-                  // 文件类型过滤
                   if (fileType && !entry.name.endsWith(fileType)) continue
 
                   const ext = path.extname(entry.name).toLowerCase()
@@ -652,7 +471,6 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
                       results.push(match)
                     }
                   } catch (e) {
-                    // 跳过无法读取的文件
                   }
                 }
               }
@@ -661,7 +479,6 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
             searchDir(dirPath)
           }
 
-          // 计算统计信息
           const filesWithMatches = new Set(results.map(r => r.file)).size
           const totalMatches = results.reduce((sum, r) => sum + (r.matches?.length || 1), 0)
 
@@ -684,7 +501,6 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
       }
     })
 
-    // 执行命令
     framework.registerTool({
       name: 'execute_command',
       description: '执行终端命令',
@@ -698,22 +514,21 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
       execute: async (args, framework) => {
         const command = args.cmd || args.command || args.run
         const cwd = args.cwd || (framework?.getCwd?.() ?? process.cwd())
-        const timeout = Math.min(args.timeout || 30000, 120000) // 最多 2 分钟
+        const timeout = Math.min(args.timeout || 30000, 120000)
 
-        // 验证命令：检查危险的 shell 模式
         const dangerousPatterns = [
-          /;\s*rm\s+/i,           // ; rm -rf
-          /\|\s*rm\s+/i,          // | rm -rf
-          /&&\s*rm\s+/i,          // && rm -rf
-          /;\s*del\s+/i,          // ; del
-          /\|\s*del\s+/i,         // | del
-          /&\s*rm\s+/i,           // & rm -rf
-          /;\s*format\s+/i,       // ; format
-          /&\s*format\s+/i,       // & format
-          /\$\(/i,                // $(command substitution)
-          /`[^`]+`/i,             // `command substitution`
-          />\s*\/dev\//i,         // redirect to /dev/
-          /<\s*\/dev\//i,         // read from /dev/
+          /;\s*rm\s+/i,
+          /\|\s*rm\s+/i,
+          /&&\s*rm\s+/i,
+          /;\s*del\s+/i,
+          /\|\s*del\s+/i,
+          /&\s*rm\s+/i,
+          /;\s*format\s+/i,
+          /&\s*format\s+/i,
+          /\$\(/i,
+          /`[^`]+`/i,
+          />\s*\/dev\//i,
+          /<\s*\/dev\//i,
         ]
 
         for (const pattern of dangerousPatterns) {
@@ -725,7 +540,6 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
           }
         }
 
-        // 验证 cwd 路径
         const resolvedCwd = path.resolve(cwd)
         if (!fs.existsSync(resolvedCwd)) {
           return { success: false, error: `工作目录不存在: ${resolvedCwd}` }
@@ -751,7 +565,6 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
       }
     })
 
-    // 执行 Bash 命令
     framework.registerTool({
       name: 'bash',
       description: '执行 Bash 命令（支持 Linux/macOS/Windows Git Bash）',
@@ -770,7 +583,6 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
           return { success: false, error: 'cmd/command 是必填参数' }
         }
 
-        // 验证命令：检查危险的 shell 模式
         const dangerousPatterns = [
           /;\s*rm\s+-rf/i,
           /\|\s*rm\s+/i,
@@ -791,18 +603,15 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
           }
         }
 
-        // 验证 cwd 路径
         const resolvedCwd = path.resolve(cwd)
         if (!fs.existsSync(resolvedCwd)) {
           return { success: false, error: `工作目录不存在: ${resolvedCwd}` }
         }
 
-        // 确定 bash 路径
         let bashPath = 'bash'
         const isWindows = process.platform === 'win32'
 
         if (isWindows) {
-          // Windows 下尝试查找 Git Bash
           const possiblePaths = [
             'C:\\Program Files\\Git\\bin\\bash.exe',
             'C:\\Program Files (x86)\\Git\\bin\\bash.exe',
@@ -851,7 +660,6 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
       }
     })
 
-    // 获取北京时间
     framework.registerTool({
       name: 'get_time',
       description: '获取当前的时间，需要获取日期和时间的时候需要调用该接口',
@@ -878,7 +686,6 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
       }
     })
 
-    // HTTP 请求
     framework.registerTool({
       name: 'fetch',
       description: '发送 HTTP 请求获取远程数据。HTML 内容会保存到临时文件并返回路径；非 HTML 内容可选择转换为 Markdown。注意：如果访问失败或超时，LLM 应自动使用 proxy: true 重试。',
@@ -920,17 +727,14 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
             data = text
           }
 
-          // 检测是否为 HTML 内容
           const isHtml = typeof data === 'string' && (/<[a-z][\s\S]*>/i.test(data) || data.trim().startsWith('<'))
 
-          // HTML 内容统一保存到临时文件
           if (isHtml) {
             const tmpDir = os.tmpdir()
             const filename = `fetch_${Date.now()}_${Math.random().toString(36).slice(2, 8)}.html`
             const filePath = path.join(tmpDir, filename)
             fs.writeFileSync(filePath, data, 'utf-8')
 
-            // toMarkdown 为 true 时返回 markdown
             if (toMarkdown) {
               try {
                 const markdown = NodeHtmlMarkdown.translate(data)
@@ -945,7 +749,6 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
                   content: markdown
                 }
               } catch (e) {
-                // 转换失败时只返回路径
                 return {
                   success: true,
                   status: response.status,
@@ -969,7 +772,6 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
             }
           }
 
-          // 非 HTML 内容
           if (toMarkdown && typeof data === 'string') {
             try {
               const markdown = NodeHtmlMarkdown.translate(data)
@@ -988,11 +790,9 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
                 truncated: maxLength && markdown.length > maxLength
               }
             } catch (e) {
-              // 转换失败时返回原始 body
             }
           }
 
-          // 返回原始内容
           const truncatedData = maxLength && typeof data === 'string' && data.length > maxLength
             ? data.substring(0, maxLength) + '\n\n...(truncated)'
             : data
@@ -1022,7 +822,6 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
       }
     })
 
-    // 发送通知
     framework.registerTool({
       name: 'notification_send',
       description: '发送系统通知，仅发送给当前聊天会话，通知会显示给用户或在下次对话时呈现',
@@ -1034,7 +833,6 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
       execute: async (args, framework) => {
         const { title, message, source = '系统消息' } = args
         try {
-          // 获取当前执行上下文中的 sessionId，只发送到当前会话
           const ctx = framework.getExecutionContext()
           const sessionId = ctx?.sessionId || null
 
@@ -1056,4 +854,4 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
   }
 }
 
-module.exports = FileSystemPlugin
+module.exports = FileSystemPlugin