foliko 1.0.1 → 1.0.2

package/plugins/python-plugin-loader.js

@@ -0,0 +1,478 @@
+/**
+ * PythonPluginLoader - Python 插件加载器
+ * 通过 python_execute 工具执行 Python 插件
+ */
+
+const fs = require('fs')
+const path = require('path')
+const { Plugin } = require('../src/core/plugin-base')
+const { z } = require('zod')
+
+// 将 JSON Schema 转换为 Zod Schema
+function jsonSchemaToZod(jsonSchema) {
+  if (!jsonSchema || jsonSchema.type !== 'object') {
+    return z.object({})
+  }
+
+  const properties = jsonSchema.properties || {}
+  const required = jsonSchema.required || []
+
+  const shape = {}
+  for (const [key, prop] of Object.entries(properties)) {
+    let zodType
+    switch (prop.type) {
+      case 'string':
+        zodType = z.string()
+        break
+      case 'number':
+        zodType = z.number()
+        break
+      case 'boolean':
+        zodType = z.boolean()
+        break
+      case 'array':
+        zodType = z.array(z.any())
+        break
+      case 'object':
+        zodType = jsonSchemaToZod(prop)
+        break
+      default:
+        zodType = z.any()
+    }
+    // 如果不是 required 字段，则标记为 optional
+    if (!required.includes(key)) {
+      zodType = zodType.optional()
+    }
+    shape[key] = zodType
+  }
+
+  return z.object(shape)
+}
+
+class PythonPluginLoader extends Plugin {
+  constructor(config = {}) {
+    super()
+    this.name = 'python-plugin-loader'
+    this.version = '1.0.0'
+    this.description = 'Python 插件加载器'
+
+    this._agentDir = config.agentDir || '.agent'
+    this._pythonPlugins = new Map()
+    this._framework = null
+  }
+
+  install(framework) {
+    this._framework = framework
+    return this
+  }
+
+  start(framework) {
+    // 先设置 framework 引用（供 _loadPythonPlugins 使用）
+    this._framework = framework
+
+    // 加载所有 Python 插件（会注册工具）
+    this._loadPythonPlugins()
+
+    // 注册 python_plugin 工具
+    framework.registerTool({
+      name: 'python_plugin',
+      description: '执行 Python 插件工具（当工具未注册时使用）',
+      inputSchema: z.object({
+        plugin: z.string().describe('插件名称（不含 .py）'),
+        tool: z.string().describe('工具名称'),
+        params: z.record(z.any()).describe('工具参数')
+      }),
+      execute: async (args) => {
+        const { plugin, tool, params } = args
+        return this._executePythonTool(plugin, tool, params)
+      }
+    })
+
+    // 监听 agent 创建事件，附加 Python 插件信息到系统提示词
+    framework.on('agent:created', (agent) => {
+      this._refreshAgentPythonPluginsPrompt(agent)
+    })
+
+    // 等待框架就绪后，刷新所有已有 agent 的 Python 插件提示词
+    if (framework._ready) {
+      this._refreshAllAgentsPythonPluginsPrompt(framework)
+    } else {
+      framework.once('framework:ready', () => {
+        this._refreshAllAgentsPythonPluginsPrompt(framework)
+      })
+    }
+
+    return this
+  }
+
+  /**
+   * 构建 Python 插件描述
+   */
+  _buildPythonPluginsDescription() {
+    if (this._pythonPlugins.size === 0) {
+      return ''
+    }
+
+    let desc = '【Python 插件工具】\n'
+    desc += '可以直接调用以下 Python 插件工具：\n\n'
+
+    for (const [name, plugin] of this._pythonPlugins) {
+      desc += `[${plugin.info.name}] ${plugin.info.description || ''}\n`
+      if (plugin.info.tools && Array.isArray(plugin.info.tools)) {
+        for (const tool of plugin.info.tools) {
+          const paramsStr = Object.keys(tool.params || {}).join(', ') || '无参数'
+          desc += `  - ${tool.name}(${paramsStr}): ${tool.description || '无描述'}\n`
+        }
+      }
+      desc += '\n'
+    }
+
+    desc += '调用格式：python_plugin({ plugin: "插件名", tool: "工具名", params: {...} })\n'
+    return desc.trim()
+  }
+
+  /**
+   * 刷新单个 agent 的 Python 插件提示词
+   */
+  _refreshAgentPythonPluginsPrompt(agent) {
+    const existingPrompt = agent._originalPrompt || ''
+    if (existingPrompt.includes('[Python 插件工具]')) {
+      return
+    }
+
+    const pyDesc = this._buildPythonPluginsDescription()
+    if (!pyDesc) return
+
+    // 将 Python 插件描述追加到系统提示词
+    agent.setSystemPrompt(existingPrompt + '\n\n' + pyDesc)
+  }
+
+  /**
+   * 刷新所有 agent 的 Python 插件提示词
+   */
+  _refreshAllAgentsPythonPluginsPrompt(framework) {
+    const visited = new Set()
+
+    const traverse = (agent) => {
+      if (!agent || visited.has(agent)) return
+      visited.add(agent)
+      this._refreshAgentPythonPluginsPrompt(agent)
+
+      // 递归处理子 agent
+      const subAgents = agent.getSubAgents?.() || agent._subAgents || new Map()
+      for (const [name, subAgentInfo] of subAgents) {
+        traverse(subAgentInfo.agent)
+      }
+    }
+
+    const agents = framework._agents || []
+    for (const agent of agents) {
+      traverse(agent)
+    }
+  }
+
+  /**
+   * 加载所有 Python 插件
+   */
+  _loadPythonPlugins() {
+    const pluginsDir = path.join(this._agentDir, 'plugins')
+    if (!fs.existsSync(pluginsDir)) {
+      return
+    }
+
+    const files = fs.readdirSync(pluginsDir).filter(f => f.endsWith('.py'))
+
+    for (const file of files) {
+      try {
+        const pluginPath = path.join(pluginsDir, file)
+        const pluginName = file.replace('.py', '')
+
+        const pluginInfo = this._loadPythonPluginMeta(pluginPath)
+        if (pluginInfo) {
+          this._pythonPlugins.set(pluginName, {
+            name: pluginName,
+            path: pluginPath,
+            info: pluginInfo,
+            code: fs.readFileSync(pluginPath, 'utf-8')
+          })
+          console.log(`[PythonPluginLoader] Loaded: ${pluginName}`)
+
+          // 注册插件的每个工具
+          if (pluginInfo.tools && Array.isArray(pluginInfo.tools)) {
+            for (const tool of pluginInfo.tools) {
+              this._registerPythonTool(pluginName, tool)
+            }
+          }
+        }
+      } catch (err) {
+        console.error(`[PythonPluginLoader] Failed to load ${file}:`, err.message)
+      }
+    }
+
+    console.log(`[PythonPluginLoader] Total Python plugins: ${this._pythonPlugins.size}`)
+  }
+
+  /**
+   * 注册 Python 插件的工具到框架
+   */
+  _registerPythonTool(pluginName, tool) {
+    if (!tool.name) return
+
+    try {
+      this._framework.registerTool({
+        name: tool.name,
+        description: tool.description || `${tool.name} (from ${pluginName})`,
+        inputSchema: this._parseToolParams(tool.params || {}),
+        execute: async (args) => {
+          return this._executePythonTool(pluginName, tool.name, args)
+        }
+      })
+      console.log(`[PythonPluginLoader] Registered tool: ${tool.name}`)
+    } catch (err) {
+      console.error(`[PythonPluginLoader] Failed to register tool ${tool.name}:`, err.message)
+    }
+  }
+
+  /**
+   * 解析工具参数 schema
+   */
+  _parseToolParams(params) {
+    // 构建 JSON Schema 格式
+    const properties = {}
+    const required = []
+
+    for (const [key, value] of Object.entries(params)) {
+      let type = 'string'
+      if (typeof value === 'boolean') type = 'boolean'
+      else if (typeof value === 'number') type = 'number'
+      else if (Array.isArray(value)) type = 'array'
+      else if (typeof value === 'object') type = 'object'
+
+      properties[key] = {
+        type,
+        description: ''
+      }
+      required.push(key)
+    }
+
+    const jsonSchema = {
+      type: 'object',
+      properties,
+      required
+    }
+
+    // 转换为 Zod Schema 以兼容 AI SDK
+    return jsonSchemaToZod(jsonSchema)
+  }
+
+  /**
+   * 加载单个 Python 插件的元信息
+   */
+  _loadPythonPluginMeta(pluginPath) {
+    const code = fs.readFileSync(pluginPath, 'utf-8')
+
+    // 找到 plugin_info = {
+    const startIdx = code.indexOf('plugin_info')
+    if (startIdx === -1) {
+      console.warn(`[PythonPluginLoader] ${path.basename(pluginPath)}: no plugin_info found`)
+      return null
+    }
+
+    // 从 plugin_info 后开始，找到第一个 { 的位置
+    const braceStart = code.indexOf('{', startIdx)
+    if (braceStart === -1) return null
+
+    // 使用栈匹配找到对应的 }
+    let braceCount = 0
+    let endIdx = -1
+    for (let i = braceStart; i < code.length; i++) {
+      if (code[i] === '{') braceCount++
+      else if (code[i] === '}') {
+        braceCount--
+        if (braceCount === 0) {
+          endIdx = i
+          break
+        }
+      }
+    }
+
+    if (endIdx === -1) {
+      console.warn(`[PythonPluginLoader] ${path.basename(pluginPath)}: unclosed brace`)
+      return null
+    }
+
+    try {
+      // 提取并清理 plugin_info 内容
+      let infoStr = code.substring(braceStart, endIdx + 1)
+
+      // 移除 Python 注释
+      infoStr = infoStr.replace(/#.*$/gm, '')
+
+      // 转换为 JS 兼容的格式
+      infoStr = infoStr
+        .replace(/True/g, 'true')
+        .replace(/False/g, 'false')
+        .replace(/None/g, 'null')
+        .replace(/'/g, '"')
+
+      const info = JSON.parse(infoStr)
+      return info
+    } catch (err) {
+      console.warn(`[PythonPluginLoader] Failed to parse ${path.basename(pluginPath)}:`, err.message)
+      return null
+    }
+  }
+
+  /**
+   * 解析单个值
+   */
+  _parseValue(str) {
+    str = str.trim()
+    if (!str) return null
+
+    // 字典
+    if (str.startsWith('{')) {
+      return this._parseDict(str)
+    }
+
+    // 字符串
+    if (str.startsWith('"') || str.startsWith("'")) {
+      return str.slice(1, -1)
+    }
+
+    // 布尔值
+    if (str === 'True') return true
+    if (str === 'False') return false
+    if (str === 'None') return null
+
+    // 数字
+    if (!isNaN(str)) return Number(str)
+
+    return str
+  }
+
+  /**
+   * 简单解析 Python 字典为 JS 对象
+   */
+  _parseDict(str) {
+    // 移除注释并清理
+    str = str.replace(/#.*$/gm, '').trim()
+    if (!str) return {}
+
+    const result = {}
+    let i = 0
+    let currentKey = null
+    let currentValue = ''
+    let inString = false
+    let stringChar = null
+
+    while (i < str.length) {
+      const char = str[i]
+
+      // 处理字符串
+      if ((char === '"' || char === "'") && str[i-1] !== '\\') {
+        if (!inString) {
+          inString = true
+          stringChar = char
+        } else if (char === stringChar) {
+          inString = false
+          stringChar = null
+        }
+      }
+
+      // 如果不在字符串内
+      if (!inString) {
+        // 找到键
+        if (currentKey === null && char === ':') {
+          currentKey = currentValue.trim().replace(/^["']|["']$/g, '')
+          currentValue = ''
+        }
+        // 找到值的结尾（逗号或右括号）
+        else if (char === ',' || char === '}') {
+          if (currentKey !== null) {
+            const value = currentValue.trim().replace(/,$/, '')
+            result[currentKey] = this._parseValue(value)
+          }
+          currentKey = null
+          currentValue = ''
+        } else {
+          currentValue += char
+        }
+      } else {
+        currentValue += char
+      }
+
+      i++
+    }
+
+    return result
+  }
+
+  /**
+   * 执行 Python 插件工具
+   */
+  async _executePythonTool(pluginName, toolName, params) {
+    const plugin = this._pythonPlugins.get(pluginName)
+    if (!plugin) {
+      return { success: false, error: `Plugin '${pluginName}' not found` }
+    }
+
+    // 构建执行代码 - 使用 base64 避免转义问题
+    const pluginDir = path.dirname(plugin.path)
+    const codeBase64 = Buffer.from(plugin.code, 'utf-8').toString('base64')
+
+    const execCode = `
+import sys
+import base64
+sys.path.insert(0, r'${pluginDir}')
+
+# 加载插件代码
+plugin_code = base64.b64decode('${codeBase64}').decode('utf-8')
+exec(compile(plugin_code, '${pluginName}.py', 'exec'))
+
+# 执行工具
+result = execute_tool('${toolName}', ${JSON.stringify(params)})
+print(result)
+`
+
+    try {
+      // 通过 python-execute 工具执行
+      const pythonExe = this._framework.toolRegistry._tools.get('python-execute')
+      if (!pythonExe) {
+        return { success: false, error: 'python-execute tool not found. Please install python-executor-plugin.' }
+      }
+
+      const pythonResult = await pythonExe.execute({ code: execCode })
+
+      if (pythonResult.success) {
+        try {
+          // 尝试解析 JSON 结果
+          const parsed = JSON.parse(pythonResult.output)
+          return parsed
+        } catch {
+          return { success: true, output: pythonResult.output }
+        }
+      } else {
+        return { success: false, error: pythonResult.error }
+      }
+    } catch (err) {
+      return { success: false, error: err.message }
+    }
+  }
+
+  /**
+   * 获取所有已加载的 Python 插件
+   */
+  getPythonPlugins() {
+    return Array.from(this._pythonPlugins.values())
+  }
+
+  /**
+   * 获取 Python 插件信息
+   */
+  getPythonPlugin(name) {
+    return this._pythonPlugins.get(name)
+  }
+}
+
+module.exports = { PythonPluginLoader }