foliko 1.0.0

package/plugins/file-system-plugin.js

@@ -0,0 +1,344 @@
+/**
+ * FileSystem 插件
+ * 提供文件系统操作的常用工具
+ */
+
+const { Plugin } = require('../src/core/plugin-base')
+
+class FileSystemPlugin extends Plugin {
+  constructor(config = {}) {
+    super()
+    this.name = 'file-system'
+    this.version = '1.0.0'
+    this.description = '文件系统工具插件'
+    this.priority = 5
+  }
+
+  install(framework) {
+    const { z } = require('zod')
+    const fs = require('fs')
+    const path = require('path')
+    const { exec } = require('child_process')
+
+    // 读取目录
+    framework.registerTool({
+      name: 'read_directory',
+      description: '读取目录内容，列出目录中的文件和子目录',
+      inputSchema: z.object({
+        path: z.string().optional().describe('目录路径'),
+        dirPath: z.string().optional().describe('目录路径(同path)'),
+        recursive: z.boolean().optional().describe('是否递归')
+      }),
+      execute: async (args, framework) => {
+        const dirPath = args.path || args.dirPath || '.'
+        const recursive = args.recursive || false
+        try {
+          const items = []
+          const readDir = (currentPath, depth = 0) => {
+            if (depth > 3 && recursive) return
+            const entries = fs.readdirSync(currentPath, { withFileTypes: true })
+            for (const entry of entries) {
+              const fullPath = path.join(currentPath, entry.name)
+              const relativePath = path.relative(process.cwd(), fullPath)
+              if (relativePath.includes('node_modules') || relativePath.includes('.git')) {
+                continue
+              }
+              items.push({
+                name: entry.name,
+                path: relativePath,
+                type: entry.isDirectory() ? 'directory' : 'file',
+                size: entry.isFile() ? fs.statSync(fullPath).size : null
+              })
+              if (entry.isDirectory() && recursive && depth < 3) {
+                readDir(fullPath, depth + 1)
+              }
+            }
+          }
+          readDir(dirPath)
+          return { success: true, dirPath, items: items.slice(0, 100), total: items.length }
+        } catch (error) {
+          return { success: false, error: error.message }
+        }
+      }
+    })
+
+    // 创建目录
+    framework.registerTool({
+      name: 'create_directory',
+      description: '创建新目录',
+      inputSchema: z.object({
+        path: z.string().optional().describe('目录路径'),
+        dirPath: z.string().optional().describe('目录路径(同path)')
+      }),
+      execute: async (args, framework) => {
+        const dirPath = args.path || args.dirPath
+        try {
+          fs.mkdirSync(dirPath, { recursive: true })
+          return { success: true, message: `目录已创建: ${dirPath}` }
+        } catch (error) {
+          return { success: false, error: error.message }
+        }
+      }
+    })
+
+    // 读取文件
+    framework.registerTool({
+      name: 'read_file',
+      description: '读取文件内容',
+      inputSchema: z.object({
+        path: z.string().optional().describe('文件路径'),
+        filePath: z.string().optional().describe('文件路径(同path)'),
+        encoding: z.enum(['utf8', 'base64', 'binary']).optional().describe('文件编码，默认 utf8'),
+        lines: z.number().optional().describe('只读取前 N 行')
+      }),
+      execute: async (args, framework) => {
+        const filePath = args.path || args.filePath
+        const encoding = args.encoding || 'utf8'
+        const lines = args.lines
+        try {
+          if (!fs.existsSync(filePath)) {
+            return { success: false, error: '文件不存在' }
+          }
+          const stat = fs.statSync(filePath)
+          if (stat.size > 1024 * 1024) {
+            return { success: false, error: '文件太大，超过 1MB' }
+          }
+          let content
+          if (lines) {
+            const fileContent = fs.readFileSync(filePath, 'utf8')
+            const allLines = fileContent.split('\n')
+            content = allLines.slice(0, lines).join('\n')
+          } else {
+            content = fs.readFileSync(filePath, encoding)
+          }
+          return {
+            success: true,
+            filePath,
+            content,
+            size: stat.size,
+            lines: lines ? null : content.split('\n').length
+          }
+        } catch (error) {
+          return { success: false, error: error.message }
+        }
+      }
+    })
+
+    // 写入文件
+    framework.registerTool({
+      name: 'write_file',
+      description: '创建或写入文件内容',
+      inputSchema: z.object({
+        path: z.string().optional().describe('文件路径'),
+        filePath: z.string().optional().describe('文件路径(同path)'),
+        content: z.string().describe('文件内容')
+      }),
+      execute: async (args, framework) => {
+        const filePath = args.path || args.filePath
+        const content = args.content
+        const encoding = args.encoding || 'utf8'
+        try {
+          const dir = path.dirname(filePath)
+          if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true })
+          }
+          fs.writeFileSync(filePath, content, encoding)
+          return { success: true, message: `文件已写入: ${filePath}`, filePath, size: content.length }
+        } catch (error) {
+          return { success: false, error: error.message }
+        }
+      }
+    })
+
+    // 删除文件
+    framework.registerTool({
+      name: 'delete_file',
+      description: '删除文件或目录',
+      inputSchema: z.object({
+        path: z.string().optional().describe('文件或目录路径'),
+        targetPath: z.string().optional().describe('文件或目录路径(同path)'),
+        recursive: z.boolean().optional().describe('递归删除目录')
+      }),
+      execute: async (args, framework) => {
+        const targetPath = args.path || args.targetPath
+        const recursive = args.recursive || false
+        try {
+          if (!fs.existsSync(targetPath)) {
+            return { success: false, error: '目标不存在' }
+          }
+          const stat = fs.statSync(targetPath)
+          if (stat.isDirectory()) {
+            if (recursive) {
+              fs.rmSync(targetPath, { recursive: true, force: true })
+            } else {
+              fs.rmdirSync(targetPath)
+            }
+          } else {
+            fs.unlinkSync(targetPath)
+          }
+          return { success: true, message: `已删除: ${targetPath}` }
+        } catch (error) {
+          return { success: false, error: error.message }
+        }
+      }
+    })
+
+    // 修改文件（替换文本）
+    framework.registerTool({
+      name: 'modify_file',
+      description: '修改文件内容（替换文本）',
+      inputSchema: z.object({
+        path: z.string().optional().describe('文件路径'),
+        filePath: z.string().optional().describe('文件路径(同path)'),
+        find: z.string().describe('要查找的文本'),
+        replace: z.string().describe('替换后的文本'),
+        replaceAll: z.boolean().optional().describe('替换所有匹配')
+      }),
+      execute: async (args, framework) => {
+        const filePath = args.path || args.filePath
+        const find = args.find
+        const replace = args.replace
+        const replaceAll = args.replaceAll || false
+        try {
+          if (!fs.existsSync(filePath)) {
+            return { success: false, error: '文件不存在' }
+          }
+          let content = fs.readFileSync(filePath, 'utf8')
+          if (replaceAll) {
+            content = content.split(find).join(replace)
+          } else {
+            content = content.replace(find, replace)
+          }
+          fs.writeFileSync(filePath, content, 'utf8')
+          return { success: true, message: `文件已修改: ${filePath}`, filePath }
+        } catch (error) {
+          return { success: false, error: error.message }
+        }
+      }
+    })
+
+    // 搜索文件
+    framework.registerTool({
+      name: 'search_file',
+      description: '在文件中搜索文本',
+      inputSchema: z.object({
+        query: z.string().optional().describe('搜索关键词'),
+        pattern: z.string().optional().describe('搜索模式'),
+        searchText: z.string().optional().describe('搜索文本'),
+        path: z.string().optional().describe('搜索目录'),
+        dirPath: z.string().optional().describe('搜索目录(同path)'),
+        fileType: z.string().optional().describe('文件类型过滤'),
+        maxResults: z.number().optional().describe('最大结果数')
+      }),
+      execute: async (args, framework) => {
+        const pattern = args.query || args.pattern || args.searchText || ''
+        const dirPath = args.path || args.dirPath || '.'
+        const fileType = args.fileType
+        const maxResults = args.maxResults || 50
+        try {
+          const results = []
+          const regex = new RegExp(pattern, 'gi')
+          const searchDir = (currentPath, depth = 0) => {
+            if (depth > 5 || results.length >= maxResults) return
+            const entries = fs.readdirSync(currentPath, { withFileTypes: true })
+            for (const entry of entries) {
+              if (results.length >= maxResults) break
+              const fullPath = path.join(currentPath, entry.name)
+              const relativePath = path.relative(process.cwd(), fullPath)
+              if (relativePath.includes('node_modules') || relativePath.includes('.git') ||
+                  relativePath.includes('dist') || relativePath.includes('build')) {
+                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)
+                if (['.jpg', '.png', '.gif', '.exe', '.dll', '.zip'].includes(ext)) continue
+                try {
+                  const content = fs.readFileSync(fullPath, 'utf8')
+                  const lines = content.split('\n')
+                  for (let i = 0; i < lines.length; i++) {
+                    if (regex.test(lines[i])) {
+                      results.push({ file: relativePath, line: i + 1, content: lines[i].substring(0, 100) })
+                      if (results.length >= maxResults) break
+                    }
+                  }
+                  regex.lastIndex = 0
+                } catch (e) { }
+              }
+            }
+          }
+          searchDir(dirPath)
+          return { success: true, pattern, results: results.slice(0, maxResults), total: results.length }
+        } catch (error) {
+          return { success: false, error: error.message }
+        }
+      }
+    })
+
+    // 执行命令
+    framework.registerTool({
+      name: 'execute_command',
+      description: '执行终端命令',
+      inputSchema: z.object({
+        cmd: z.string().optional().describe('要执行的命令'),
+        command: z.string().optional().describe('要执行的命令(同cmd)'),
+        run: z.string().optional().describe('要执行的命令(同cmd)'),
+        cwd: z.string().optional().describe('工作目录'),
+        timeout: z.number().optional().describe('超时时间(ms)')
+      }),
+      execute: async (args, framework) => {
+        const command = args.cmd || args.command || args.run
+        const cwd = args.cwd || process.cwd()
+        const timeout = args.timeout || 30000
+        return new Promise((resolve) => {
+          const startTime = Date.now()
+          exec(command, { cwd, timeout }, (error, stdout, stderr) => {
+            const duration = Date.now() - startTime
+            if (error) {
+              resolve({ success: false, command, error: error.message, stderr, duration })
+            } else {
+              resolve({
+                success: true,
+                command,
+                stdout: stdout.substring(0, 10000),
+                stderr: stderr.substring(0, 1000),
+                duration
+              })
+            }
+          })
+        })
+      }
+    })
+
+    // 获取北京时间
+    framework.registerTool({
+      name: 'get_time',
+      description: '获取当前的时间，需要获取日期和时间的时候需要调用该接口',
+      inputSchema: z.object({}),
+      execute: async (args, framework) => {
+        const now = new Date()
+        const beijingTime = new Date(now.getTime() + (8 * 60 * 60 * 1000))
+        return {
+          success: true,
+          beijingTime: beijingTime.toISOString().replace('T', ' ').substring(0, 19),
+          timestamp: now.getTime(),
+          timezone: 'Asia/Shanghai (UTC+8)',
+          formatted: {
+            year: beijingTime.getUTCFullYear(),
+            month: String(beijingTime.getUTCMonth() + 1).padStart(2, '0'),
+            day: String(beijingTime.getUTCDate()).padStart(2, '0'),
+            hour: String(beijingTime.getUTCHours()).padStart(2, '0'),
+            minute: String(beijingTime.getUTCMinutes()).padStart(2, '0'),
+            second: String(beijingTime.getUTCSeconds()).padStart(2, '0')
+          }
+        }
+      }
+    })
+
+    return this
+  }
+}
+
+module.exports = { FileSystemPlugin }

package/plugins/install-plugin.js

@@ -0,0 +1,93 @@
+/**
+ * InstallPlugin - npm 包安装工具
+ * 自动安装缺少的 node 模块到 .agent 目录
+ */
+
+const { execSync } = require('child_process')
+const fs = require('fs')
+const path = require('path')
+const { Plugin } = require('../src/core/plugin-base')
+const { z } = require('zod')
+
+class InstallPlugin extends Plugin {
+  constructor(config = {}) {
+    super()
+    this.name = 'install'
+    this.version = '1.0.0'
+    this.description = '自动安装 npm 包到 .agent 目录'
+
+    this._agentDir = config.agentDir || '.agent'
+    this._nodeModulesDir = null
+  }
+
+  install(framework) {
+    this._framework = framework
+    return this
+  }
+
+  start(framework) {
+    // 确保 node_modules 目录存在
+    this._nodeModulesDir = path.join(this._agentDir, 'node_modules')
+    if (!fs.existsSync(this._nodeModulesDir)) {
+      fs.mkdirSync(this._nodeModulesDir, { recursive: true })
+    }
+
+    // 注册 install 工具
+    framework.registerTool({
+      name: 'install',
+      description: '安装 npm 包到 .agent 目录，用于解决插件依赖缺失问题',
+      inputSchema: z.object({
+        package: z.string().describe('包名，如 lodash 或 lodash@4.17.21')
+      }),
+      execute: async (args) => {
+        const { package: packageName } = args
+        return this._installPackage(packageName)
+      }
+    })
+
+    return this
+  }
+
+  _installPackage(packageName) {
+    try {
+      console.log(`[InstallPlugin] Installing ${packageName} to ${this._nodeModulesDir}...`)
+
+      // 使用 npm install 安装到指定目录
+      // --prefix 确保安装到 .agent/node_modules
+      execSync(`npm install ${packageName} --prefix "${this._agentDir}"`, {
+        stdio: 'inherit',
+        cwd: this._agentDir
+      })
+
+      console.log(`[InstallPlugin] Successfully installed ${packageName}`)
+
+      return {
+        success: true,
+        message: `Successfully installed ${packageName}`
+      }
+    } catch (err) {
+      return {
+        success: false,
+        error: `Failed to install ${packageName}: ${err.message}`
+      }
+    }
+  }
+
+  /**
+   * 获取 node_modules 路径，供其他插件使用
+   */
+  getNodeModulesDir() {
+    return this._nodeModulesDir
+  }
+
+  /**
+   * 添加到 module.paths（让 require 能找到）
+   */
+  addToModulePaths() {
+    if (this._nodeModulesDir && !module.paths.includes(this._nodeModulesDir)) {
+      module.paths.unshift(this._nodeModulesDir)
+    }
+  }
+}
+
+module.exports = { InstallPlugin }