foliko 2.0.21 → 2.0.23

package/plugins/io/file-system/index.js

@@ -19,14 +19,18 @@ class FileSystemPlugin extends Plugin {
   }
 
   install(framework) {
+    // ★ 必须先调 super.install(framework)，否则 this._framework 未设置，
+    //   this.tool.register() 会静默失败（Plugin base class 的 tool 访问器检查 this._framework）
+    super.install(framework);
     const { z } = require('zod')
     const fs = require('fs')
     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()
+      // ★ 相对路径基于 framework 的 cwd 解析（不是 process.cwd()）
+      const resolved = path.isAbsolute(filePath) ? path.resolve(filePath) : path.resolve(cwd, filePath)
 
       if (allowOutsideCwd) {
         return { valid: true, resolved }
@@ -39,6 +43,52 @@ class FileSystemPlugin extends Plugin {
       return { valid: true, resolved }
     }
 
+    this.tool.register({
+      name: 'chat',
+      description: '与 AI 进行对话（通过临时子 Agent）。返回 LLM 的 message 文本。',
+      inputSchema: z.object({
+        message: z.string().describe('要发送的消息'),
+        systemPrompt: z.string().optional().describe('系统提示语'),
+        sessionId: z.string().optional().describe('隔离的会话 ID（默认自动生成，避免污染主对话）'),
+      }),
+      execute: async (args, framework) => {
+        try {
+          const { message, systemPrompt, sessionId } = args;
+          // ★ 跟随主 agent 的 LLM 配置
+          const aiPlugin = framework.pluginManager?.get('ai');
+          const llmConfig = aiPlugin?.getConfig?.() || {};
+
+          // ★ 唯一名字：避免与同名 sub-agent 冲突
+          const uniqueName = `${this.name}-chat-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+
+          const agent = framework.createSubAgent({
+            name: uniqueName,
+            systemPrompt: systemPrompt || `你是一个文件系统操作助手，提供文件和目录的读取、写入、编辑、搜索等功能。请根据用户的请求执行相应的操作，并返回结果。`,
+            model: llmConfig.model,
+            provider: llmConfig.provider,
+            apiKey: llmConfig.apiKey,
+            baseURL: llmConfig.baseURL,
+            hidden: true,
+          });
+
+          // ★ 隔离 sessionId：chat 走独立 session，不污染主对话历史
+          const response = await agent.chat(message, {
+            sessionId: sessionId || `chat-${Date.now()}`,
+            maxTokens: 2000,
+          });
+
+          // ★ 只返回 message 文本（不是整个对象含 messages 数组）
+          return {
+            success: true,
+            data: response?.message || '',
+            metadata: { steps: response?.steps || 0, agent: uniqueName },
+          };
+        } catch (err) {
+          return { success: false, error: err.message };
+        }
+      }
+    })
+
     framework.registerTool({
       name: 'read_directory',
       description: '读取目录内容，列出目录中的文件和子目录',
@@ -293,22 +343,146 @@ class FileSystemPlugin extends Plugin {
       }
     })
 
+    // ★ 用 @frsource/frs-replace 重写：基于 String.prototype.replace 的纯文本替换
+    //   支持字面量匹配和正则匹配（useRegex=true），保持原 API 兼容
+    //   注意：丢失了原 editDiff 的"智能模糊匹配"能力（Unicode 引号、破折号容错）
+    //   如果 oldText 找不到，直接报错（不像 String.replace 静默不生效）
+    let frsReplacePromise = null;
+    const getFrsReplace = () => {
+      if (!frsReplacePromise) {
+        // frs-replace 是 ESM 包（package.json type: module），用 dynamic import
+        frsReplacePromise = import('@frsource/frs-replace');
+      }
+      return frsReplacePromise;
+    };
+
     const editToolDef = {
       name: 'edit',
-      description: `精确编辑文件，支持一个或多个不重叠的文本替换。`,
+      description: '编辑文件：用 frs-replace 替换文本。支持字面量匹配和正则匹配（useRegex=true），支持多个不重叠的连续替换。',
       inputSchema: z.object({
         path: z.string().describe('要编辑的文件路径'),
         edits: z.array(z.object({
-          oldText: z.string().min(1).describe('要替换的原文，必须能在文件中精确匹配到'),
-          newText: z.string().describe('替换后的新文本')
-        })).min(1).describe('替换操作数组，支持多个不重叠编辑')
+          oldText: z.string().min(1).describe('要替换的原文（字面量或正则模式）'),
+          newText: z.string().describe('替换后的新文本'),
+          useRegex: z.boolean().optional().describe('是否将 oldText 视为正则（默认 false）'),
+          allOccurrences: z.boolean().optional().describe('是否替换所有出现位置（默认 true），false 时只替换第一个'),
+        })).min(1).describe('替换操作数组，按顺序应用'),
       }),
       execute: async (args, framework) => {
         const { path: filePath, edits } = args;
-        const editDiff = require('../../../src/common/diff');
-        const result = await editDiff.applyEditsToFile(filePath, edits, framework?.getCwd?.() ?? process.cwd());
-        return result;
-      }
+        if (!filePath) return { success: false, error: 'path 是必填参数' };
+        if (!Array.isArray(edits) || edits.length === 0) {
+          return { success: false, error: 'edits 必须是非空数组' };
+        }
+
+        // 解析路径（相对路径基于 framework.getCwd()）
+        const pathCheck = validatePath(filePath);
+        if (!pathCheck.valid) {
+          return { success: false, error: pathCheck.error };
+        }
+        const resolvedPath = pathCheck.resolved;
+
+        // 1. 读文件
+        let content;
+        try {
+          content = await fs.promises.readFile(resolvedPath, 'utf8');
+        } catch (e) {
+          return { success: false, error: `读取文件失败: ${e.message}` };
+        }
+
+        // 2. 动态加载 frs-replace
+        let sync;
+        try {
+          const mod = await getFrsReplace();
+          sync = mod.sync;
+        } catch (e) {
+          return { success: false, error: `frs-replace 加载失败: ${e.message}` };
+        }
+
+        // 3. 逐个应用 edit（按顺序）
+        const originalContent = content;
+        const appliedEdits = [];
+        for (let i = 0; i < edits.length; i++) {
+          const edit = edits[i];
+          const { oldText, newText, useRegex = false, allOccurrences = true } = edit;
+
+          if (typeof oldText !== 'string' || oldText.length === 0) {
+            return { success: false, error: `edits[${i}].oldText 不能为空字符串` };
+          }
+
+          // 构造 needle：统一用 RegExp（用 allOccurrences 控 g 标志）
+          //   - 字面量：转义正则元字符 + 加 g 标志
+          //   - 正则：用户写的 + 加 g 标志（如果 allOccurrences）
+          // 这样 allOccurrences 在两种模式下都生效
+          let needle;
+          try {
+            if (useRegex) {
+              needle = allOccurrences
+                ? new RegExp(oldText, 'g')
+                : new RegExp(oldText);  // 不带 g 标志 → 只替换第一个
+            } else {
+              // 字面量：转义所有正则元字符
+              const escaped = oldText.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+              needle = allOccurrences
+                ? new RegExp(escaped, 'g')
+                : new RegExp(escaped);
+            }
+          } catch (e) {
+            return { success: false, error: `edits[${i}] 无效的正则: ${e.message}` };
+          }
+
+          // 用 frs-replace 在内存中替换
+          let result;
+          try {
+            result = sync({
+              content,
+              needle,
+              replacement: newText,
+            });
+          } catch (e) {
+            return { success: false, error: `edits[${i}] 替换失败: ${e.message}` };
+          }
+
+          // frs-replace content 模式返回 [["", newContent]]（[path, content]）
+          // 当 needle 是字面量且找不到时，String.replace 不报错，返回原 content
+          const newContent = result?.[0]?.[1];
+          if (typeof newContent !== 'string') {
+            return { success: false, error: `edits[${i}] 替换返回无效结果` };
+          }
+          if (newContent === content) {
+            // ★ 关键改进：原 editDiff 会模糊匹配；frs-replace 静默不生效
+            //   现在主动检测并报错，避免 LLM 误以为成功
+            return {
+              success: false,
+              error: `edits[${i}] 替换未生效：在文件中找不到 "${oldText.slice(0, 80)}${oldText.length > 80 ? '...' : ''}"${useRegex ? '（作为正则）' : '（字面量）'}`,
+            };
+          }
+          content = newContent;
+          appliedEdits.push({ index: i, applied: true });
+        }
+
+        // 4. 写回（原子操作：先写 .tmp 再 rename）
+        const tmpPath = resolvedPath + '.tmp';
+        try {
+          await fs.promises.writeFile(tmpPath, content, 'utf8');
+          await fs.promises.rename(tmpPath, resolvedPath);
+        } catch (e) {
+          // 清理 .tmp
+          try { await fs.promises.unlink(tmpPath); } catch { /* ignore */ }
+          return { success: false, error: `写入文件失败: ${e.message}` };
+        }
+
+        return {
+          success: true,
+          data: {
+            path: resolvedPath,
+            appliedEdits: appliedEdits.length,
+            totalEdits: edits.length,
+            contentChanged: content !== originalContent,
+            contentLength: { before: originalContent.length, after: content.length },
+          },
+        };
+      },
     };
 
     framework.registerTool(editToolDef);
@@ -320,186 +494,236 @@ class FileSystemPlugin extends Plugin {
     });
 
     framework.registerTool({
-      name: 'search_file',
-      description: '在文件或目录中搜索文本，支持精确匹配和正则表达式',
+      name: 'search',
+      description: '在文件或目录中搜索文本。支持 glob 模式、.gitignore 感知、异步 IO、大小写敏感、正则、大文件保护。',
       inputSchema: z.object({
         pattern: z.string().describe('搜索模式（关键词或正则表达式）'),
-        path: z.string().optional().describe('搜索目录路径'),
-        file: z.string().optional().describe('搜索指定文件（与 path 二选一）'),
-        fileType: z.string().optional().describe('文件类型过滤，如 .js、.py'),
+        // ★ 新增：glob 模式
+        glob: z.string().optional().describe('文件 glob 模式，如 "**/*.js"、"src/**/test*"；默认 "**" 匹配所有文件'),
+        path: z.string().optional().describe('搜索目录路径（默认 cwd）'),
+        file: z.string().optional().describe('搜索指定文件（与 path/glob 二选一）'),
+        fileType: z.string().optional().describe('文件扩展名过滤，如 ".js"、".py"（已废弃，建议用 glob）'),
         maxResults: z.number().optional().describe('最大结果数，默认 100'),
         maxResultsPerFile: z.number().optional().describe('每个文件最大结果数，默认 50'),
         contextLines: z.number().optional().describe('匹配行的上下文行数，默认 0'),
         caseSensitive: z.boolean().optional().describe('是否大小写敏感，默认 false'),
         useRegex: z.boolean().optional().describe('是否使用正则表达式，默认 false'),
-        excludeDirs: z.array(z.string()).optional().describe('排除的目录名，默认 ["node_modules", ".git", "dist", "build"]')
+        excludeDirs: z.array(z.string()).optional().describe('额外排除的 glob 模式（叠加在 .gitignore 之上）'),
+        maxFileSizeKB: z.number().optional().describe('单文件最大 KB（跳过超大文件），默认 1024'),
+        gitignore: z.boolean().optional().describe('是否尊重 .gitignore（默认 true）'),
+        followSymlinks: z.boolean().optional().describe('是否跟随符号链接，默认 false'),
       }),
       execute: async (args, framework) => {
-        const pattern = args.pattern
-        const dirPath = args.path || (framework?.getCwd?.() ?? process.cwd())
-        const targetFile = args.file
-        const fileType = args.fileType
-        const maxResults = args.maxResults || 100
-        const maxResultsPerFile = args.maxResultsPerFile || 50
-        const contextLines = args.contextLines || 0
-        const caseSensitive = args.caseSensitive === true
-        const useRegex = args.useRegex === true
-        const excludeDirs = args.excludeDirs || ['node_modules', '.git', 'dist', 'build', '.claude']
-
+        const cwd = framework?.getCwd?.() ?? process.cwd();
+        const pattern = args.pattern;
         if (!pattern || typeof pattern !== 'string' || pattern.trim() === '') {
-          return { success: false, error: 'pattern 是必填参数，不能为空' }
+          return { success: false, error: 'pattern 是必填参数，不能为空' };
         }
 
-        try {
-          const results = []
-          let regex
+        const maxResults = args.maxResults || 100;
+        const maxResultsPerFile = args.maxResultsPerFile || 50;
+        const maxFileSize = (args.maxFileSizeKB || 1024) * 1024;
+        const contextLines = args.contextLines || 0;
+        const caseSensitive = args.caseSensitive === true;
+        const useRegex = args.useRegex === true;
+        const fileType = args.fileType;
 
-          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')
-          }
-
-          const binaryExtensions = ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.ico', '.exe', '.dll', '.so', '.zip', '.tar', '.gz', '.rar', '.7z', '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx', '.mp3', '.mp4', '.avi', '.mkv', '.wav', '.flac']
-
-          const searchInContent = (content, filePath) => {
-            const matches = []
-            const lines = content.split('\n')
-            let fileResultsCount = 0
-
-            for (let i = 0; i < lines.length; i++) {
-              if (fileResultsCount >= maxResultsPerFile) break
-              const line = lines[i]
-              regex.lastIndex = 0
-
-              if (regex.test(line)) {
-                const lineMatches = []
-                regex.lastIndex = 0
-                let match
-                while ((match = regex.exec(line)) !== null) {
-                  lineMatches.push({
-                    column: match.index,
-                    length: match[0].length,
-                    text: match[0]
-                  })
-                  if (!regex.global) break
-                }
-
-                const matchInfo = {
-                  file: filePath,
-                  line: i + 1,
-                  content: line.substring(0, 300),
-                  matches: lineMatches
-                }
+        // 1. 构造正则
+        let regex;
+        try {
+          const flags = caseSensitive ? 'g' : 'gi';
+          const source = useRegex
+            ? pattern
+            : pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+          regex = new RegExp(source, flags);
+        } catch (e) {
+          return { success: false, error: `无效的正则表达式: ${e.message}` };
+        }
 
-                if (contextLines > 0) {
-                  const start = Math.max(0, i - contextLines)
-                  const end = Math.min(lines.length, i + contextLines + 1)
-                  matchInfo.context = lines.slice(start, end).map((l, idx) => ({
-                    line: start + idx + 1,
-                    content: l
-                  }))
-                }
+        // 2. 二进制扩展名过滤
+        const binaryExtensions = new Set([
+          '.jpg', '.jpeg', '.png', '.gif', '.bmp', '.ico',
+          '.exe', '.dll', '.so', '.zip', '.tar', '.gz', '.rar', '.7z',
+          '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',
+          '.mp3', '.mp4', '.avi', '.mkv', '.wav', '.flac', '.ico', '.so'
+        ]);
+
+        // 3. 内容搜索（保留原逻辑）
+        const searchInContent = (content, filePath) => {
+          const matches = [];
+          const lines = content.split('\n');
+          let fileResultsCount = 0;
+
+          for (let i = 0; i < lines.length; i++) {
+            if (fileResultsCount >= maxResultsPerFile) break;
+            const line = lines[i];
+            regex.lastIndex = 0;
+
+            if (regex.test(line)) {
+              const lineMatches = [];
+              regex.lastIndex = 0;
+              let match;
+              while ((match = regex.exec(line)) !== null) {
+                lineMatches.push({ column: match.index, length: match[0].length, text: match[0] });
+                if (!regex.global) break;
+              }
 
-                matches.push(matchInfo)
-                fileResultsCount++
+              const matchInfo = {
+                file: filePath,
+                line: i + 1,
+                content: line.substring(0, 300),
+                matches: lineMatches,
+              };
+
+              if (contextLines > 0) {
+                const start = Math.max(0, i - contextLines);
+                const end = Math.min(lines.length, i + contextLines + 1);
+                matchInfo.context = lines.slice(start, end).map((l, idx) => ({
+                  line: start + idx + 1,
+                  content: l,
+                }));
               }
-            }
 
-            return matches
+              matches.push(matchInfo);
+              fileResultsCount++;
+            }
           }
+          return matches;
+        };
 
-          if (targetFile) {
-            const fullPath = path.resolve(targetFile)
+        // 4. 收集文件列表
+        let fileList;
+        try {
+          if (args.file) {
+            // 单文件模式
+            const fullPath = path.isAbsolute(args.file) ? args.file : path.resolve(cwd, args.file);
             if (!fs.existsSync(fullPath)) {
-              return { success: false, error: `文件不存在: ${targetFile}` }
-            }
-
-            const ext = path.extname(fullPath).toLowerCase()
-            if (binaryExtensions.includes(ext)) {
-              return { success: false, error: `不支持搜索二进制文件: ${ext}` }
+              return { success: false, error: `文件不存在: ${args.file}` };
             }
-
-            try {
-              const content = fs.readFileSync(fullPath, 'utf8')
-              const fileMatches = searchInContent(content, targetFile)
-              results.push(...fileMatches)
-            } catch (e) {
-              return { success: false, error: `读取文件失败: ${e.message}` }
+            if (!fs.statSync(fullPath).isFile()) {
+              return { success: false, error: `不是文件: ${args.file}` };
             }
+            fileList = [path.relative(cwd, fullPath)];
           } else {
-            const searchDir = (currentPath, depth = 0) => {
-              if (depth > 10 || results.length >= maxResults) return
-
-              let entries
-              try {
-                entries = fs.readdirSync(currentPath, { withFileTypes: true })
-              } catch (e) {
-                return
-              }
-
-              for (const entry of entries) {
-                if (results.length >= maxResults) break
-
-                const fullPath = path.join(currentPath, entry.name)
-                const relativePath = path.relative(cwd, fullPath)
-
-                const shouldExclude = excludeDirs.some(exclude =>
-                  relativePath.includes(exclude)
-                )
-                if (shouldExclude) continue
-
-                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()
-                  if (binaryExtensions.includes(ext)) continue
-
-                  try {
-                    const content = fs.readFileSync(fullPath, 'utf8')
-                    const fileMatches = searchInContent(content, relativePath)
-
-                    for (const match of fileMatches) {
-                      if (results.length >= maxResults) break
-                      results.push(match)
+            // ★ tinyglobby 替代手写递归
+            const { glob } = require('tinyglobby');
+            const searchDir = args.path ? path.resolve(cwd, args.path) : cwd;
+
+            // 构造 ignore 列表
+            const ignorePatterns = [
+              ...(args.excludeDirs || []),
+              // 默认忽略这些
+              '**/.git/**',
+              '**/node_modules/**',
+              '**/dist/**',
+              '**/build/**',
+              '**/.foliko/**',
+              '**/.claude/**',
+              '**/coverage/**',
+            ];
+
+            // ★ 读 .gitignore（如果启用）
+            if (args.gitignore !== false) {
+              const giPath = path.join(searchDir, '.gitignore');
+              if (fs.existsSync(giPath)) {
+                try {
+                  const giContent = fs.readFileSync(giPath, 'utf8');
+                  for (const line of giContent.split('\n')) {
+                    const trimmed = line.trim();
+                    if (!trimmed || trimmed.startsWith('#')) continue;
+                    // gitignore pattern → glob pattern 转换
+                    let pattern = trimmed;
+                    // 末尾的 / 表示目录
+                    if (pattern.endsWith('/')) pattern = `**/${pattern}**`;
+                    // ! 表示取反，跳过
+                    if (pattern.startsWith('!')) continue;
+                    // ** 等直接用，glob 兼容
+                    if (!pattern.includes('*') && !pattern.includes('?')) {
+                      // 简单文件名/目录名 → 加 ** 通配
+                      pattern = pattern.includes('/')
+                        ? `**/${pattern}`
+                        : `**/${pattern}/**`;
                     }
-                  } catch (e) {
+                    ignorePatterns.push(pattern);
                   }
+                } catch (e) {
+                  // 忽略 .gitignore 读取错误
                 }
               }
             }
 
-            searchDir(dirPath)
-          }
+            // fileType 兼容旧 API
+            let globPattern = args.glob || '**';
+            if (!args.glob && fileType) {
+              globPattern = `**/*.${fileType.replace(/^\./, '')}`;
+            }
 
-          const filesWithMatches = new Set(results.map(r => r.file)).size
-          const totalMatches = results.reduce((sum, r) => sum + (r.matches?.length || 1), 0)
+            fileList = await glob(globPattern, {
+              cwd: searchDir,
+              absolute: false,
+              onlyFiles: true,
+              dot: false,
+              followSymbolicLinks: args.followSymlinks === true,
+              ignore: ignorePatterns,
+            });
+          }
+        } catch (e) {
+          return { success: false, error: `文件枚举失败: ${e.message}` };
+        }
 
+        if (!fileList || fileList.length === 0) {
           return {
             success: true,
-            data: results.slice(0, maxResults),
-            metadata: {
-              pattern,
-              total: results.length,
-              stats: {
-                filesWithMatches,
-                totalMatches,
-                searchPath: targetFile || dirPath
-              }
+            data: [],
+            metadata: { pattern, filesScanned: 0, filesWithMatches: 0, totalMatches: 0, searchPath: args.file || (args.path || cwd) },
+          };
+        }
+
+        // 5. 异步读取并搜索（带大小保护）
+        const results = [];
+        let filesWithMatches = 0;
+        let filesScanned = 0;
+
+        for (const file of fileList) {
+          if (results.length >= maxResults) break;
+          const fullPath = path.isAbsolute(file) ? file : path.join(cwd, file);
+          const ext = path.extname(fullPath).toLowerCase();
+          if (binaryExtensions.has(ext)) continue;
+
+          let stat;
+          try { stat = await fs.promises.stat(fullPath); } catch { continue; }
+          if (stat.size > maxFileSize) continue;
+          filesScanned++;
+
+          let content;
+          try { content = await fs.promises.readFile(fullPath, 'utf8'); } catch { continue; }
+
+          const fileMatches = searchInContent(content, file);
+          if (fileMatches.length > 0) {
+            filesWithMatches++;
+            for (const m of fileMatches) {
+              if (results.length >= maxResults) break;
+              results.push(m);
             }
           }
-        } catch (error) {
-          return { success: false, error: error.message }
         }
-      }
-    })
+
+        const totalMatches = results.reduce((sum, r) => sum + (r.matches?.length || 1), 0);
+
+        return {
+          success: true,
+          data: results,
+          metadata: {
+            pattern,
+            filesScanned,
+            filesWithMatches,
+            totalMatches,
+            searchPath: args.file || (args.path || cwd),
+            glob: args.glob,
+          },
+        };
+      },
+    });
 
     framework.registerTool({
       name: 'execute_command',