foliko 1.0.0

package/src/core/plugin-manager.js

@@ -0,0 +1,392 @@
+/**
+ * PluginManager 插件管理器
+ * 负责插件的加载、卸载、重载
+ */
+
+const { Plugin } = require('./plugin-base')
+
+class PluginManager {
+  /**
+   * @param {Framework} framework - 框架实例
+   */
+  constructor(framework) {
+    this.framework = framework
+    this._plugins = new Map()
+    this._loading = false
+  }
+
+  /**
+   * 注册插件（不加载）
+   * @param {Plugin|Object} plugin - 插件实例或定义
+   */
+  register(plugin) {
+    if (!plugin.name) {
+      throw new Error('Plugin must have a name')
+    }
+
+    let pluginInstance = plugin
+    if (!(plugin instanceof Plugin)) {
+      // 从对象创建插件实例
+      pluginInstance = this._createFromObject(plugin)
+    }
+
+    this._plugins.set(pluginInstance.name, {
+      instance: pluginInstance,
+      status: 'registered'
+    })
+
+    this.framework.emit('plugin:registered', pluginInstance)
+    return this
+  }
+
+  /**
+   * 加载插件
+   * @param {Plugin|Object} plugin - 插件实例或定义
+   */
+  async load(plugin) {
+    if (this._loading) {
+      throw new Error('Cannot load plugin during another load operation')
+    }
+
+    this._loading = true
+    try {
+      let pluginInstance = plugin
+
+      if (!(plugin instanceof Plugin)) {
+        pluginInstance = this._createFromObject(plugin)
+      }
+
+      // 如果已注册，使用已注册的实例
+      const existing = this._plugins.get(pluginInstance.name)
+      if (existing) {
+        pluginInstance = existing.instance
+
+        // 如果已加载且已启动，直接返回
+        if (existing.status === 'loaded' && pluginInstance._started) {
+          console.warn(`[PluginManager] Plugin '${pluginInstance.name}' already loaded`)
+          return pluginInstance
+        }
+
+        // 如果已加载但未启动（重载场景），直接启动
+        if (existing.status === 'loaded' && !pluginInstance._started) {
+          try {
+            if (typeof pluginInstance.start === 'function') {
+              await pluginInstance.start(this.framework)
+              pluginInstance._started = true
+            }
+          } catch (err) {
+            console.error(`[PluginManager] Start failed for '${pluginInstance.name}':`, err.message)
+          }
+          this.framework.emit('plugin:loaded', pluginInstance)
+          return pluginInstance
+        }
+      } else {
+        // 未注册，先注册
+        this.register(pluginInstance)
+      }
+
+      const entry = this._plugins.get(pluginInstance.name)
+
+      // 调用 install
+      try {
+        await entry.instance.install(this.framework)
+      } catch (err) {
+        console.error(`[PluginManager] Install failed for '${pluginInstance.name}':`, err.message)
+        throw err
+      }
+
+      entry.status = 'loaded'
+
+      // 如果处于 bootstrap 模式，由外部统一调用 startAll()
+      // 否则直接启动
+      if (this._bootstrapping) {
+        // bootstrap 模式下不启动，由 bootstrapDefaults 统一启动
+      } else {
+        // 非 bootstrap 模式下直接启动
+        try {
+          if (typeof pluginInstance.start === 'function') {
+            await pluginInstance.start(this.framework)
+            pluginInstance._started = true
+          }
+        } catch (err) {
+          console.error(`[PluginManager] Start failed for '${pluginInstance.name}':`, err.message)
+        }
+      }
+
+      this.framework.emit('plugin:loaded', pluginInstance)
+      return pluginInstance
+    } finally {
+      this._loading = false
+    }
+  }
+
+  /**
+   * 设置 bootstrap 模式
+   */
+  setBootstrapping(value) {
+    this._bootstrapping = value
+  }
+
+  /**
+   * 卸载插件
+   * @param {string} name - 插件名称
+   */
+  async unload(name) {
+    const entry = this._plugins.get(name)
+    if (!entry) {
+      return false
+    }
+
+    const { instance } = entry
+
+    // 调用 uninstall
+    try {
+      await instance.uninstall(this.framework)
+    } catch (err) {
+      console.error(`[PluginManager] Uninstall error for '${name}':`, err.message)
+    }
+
+    entry.status = 'unloaded'
+    this.framework.emit('plugin:unloaded', instance)
+    return true
+  }
+
+  /**
+   * 重载插件
+   * @param {string} name - 插件名称
+   */
+  async reload(name) {
+    const entry = this._plugins.get(name)
+    if (!entry) {
+      throw new Error(`Plugin '${name}' not found`)
+    }
+
+    const { instance } = entry
+
+    // 调用 reload
+    try {
+      await instance.reload(this.framework)
+      this.framework.emit('plugin:reloaded', instance)
+    } catch (err) {
+      console.error(`[PluginManager] Reload error for '${name}':`, err.message)
+      throw err
+    }
+
+    return instance
+  }
+
+  /**
+   * 重载所有插件
+   */
+  async reloadAll() {
+    // 1. 重置所有插件的启动标志
+    for (const entry of this._plugins.values()) {
+      entry.instance._started = false
+    }
+
+    // 2. 扫描 .agent/plugins 目录，加载新插件
+    await this._discoverCustomPlugins()
+
+    // 3. 启动所有未启动的插件
+    await this.startAll()
+  }
+
+  /**
+   * 发现并加载自定义插件
+   * @private
+   */
+  async _discoverCustomPlugins() {
+    const fs = require('fs')
+    const path = require('path')
+
+    const pluginsDir = path.resolve(process.cwd(), '.agent', 'plugins')
+    if (!fs.existsSync(pluginsDir)) {
+      return
+    }
+
+    const files = fs.readdirSync(pluginsDir).filter(f => f.endsWith('.js'))
+
+    // 从 pluginsDir 推导 agentDir（pluginsDir = <agentDir>/plugins）
+    const agentDir = path.dirname(pluginsDir)
+    const agentNodeModules = path.join(agentDir, 'node_modules')
+
+    for (const file of files) {
+      try {
+        const pluginPath = path.join(pluginsDir, file)
+
+        // 添加模块路径到搜索路径（优先级从高到低）
+        const modulePathsToAdd = [
+          agentNodeModules,                           // .agent/node_modules（项目本地安装的包）
+          path.join(__dirname, '..', '..', 'node_modules')  // 全局安装的包
+        ]
+        for (const mp of modulePathsToAdd) {
+          if (fs.existsSync(mp) && !module.paths.includes(mp)) {
+            module.paths.unshift(mp)
+          }
+        }
+
+        // 清除缓存
+        delete require.cache[require.resolve(pluginPath)]
+        const pluginModule = require(pluginPath)
+
+        let plugin
+        if (typeof pluginModule === 'function') {
+          plugin = pluginModule
+        } else if (pluginModule.default) {
+          plugin = pluginModule.default
+        } else {
+          plugin = pluginModule
+        }
+
+        // 获取插件名称
+        let pluginName
+        try {
+          const tempPlugin = plugin.prototype instanceof require('./plugin-base')
+            ? new plugin() : (typeof plugin === 'function' ? plugin() : plugin)
+          pluginName = tempPlugin.name || file.replace('.js', '')
+        } catch {
+          pluginName = file.replace('.js', '')
+        }
+
+        // 如果插件已加载且已启动，跳过
+        if (this.has(pluginName) && this.get(pluginName)?._started) {
+          continue
+        }
+
+        console.log(`[PluginManager] Loading new plugin: ${file}`)
+        await this.load(plugin)
+      } catch (err) {
+        console.error(`[PluginManager] Failed to load plugin ${file}:`, err.message)
+      }
+    }
+  }
+
+  /**
+   * 获取插件
+   * @param {string} name - 插件名称
+   */
+  get(name) {
+    return this._plugins.get(name)?.instance
+  }
+
+  /**
+   * 获取所有已加载插件
+   */
+  getAll() {
+    return Array.from(this._plugins.values())
+      .filter(e => e.status === 'loaded')
+      .map(e => ({ name: e.instance.name, instance: e.instance }))
+  }
+
+  /**
+   * 检查插件是否存在
+   * @param {string} name - 插件名称
+   */
+  has(name) {
+    return this._plugins.has(name)
+  }
+
+  /**
+   * 检查插件是否已加载
+   * @param {string} name - 插件名称
+   */
+  isLoaded(name) {
+    return this._plugins.get(name)?.status === 'loaded'
+  }
+
+  /**
+   * 启动所有已加载但未启动的插件（按优先级排序）
+   */
+  async startAll() {
+    const entries = Array.from(this._plugins.values())
+      .filter(e => e.status === 'loaded')
+      .sort((a, b) => (a.instance.priority || 100) - (b.instance.priority || 100))
+
+    for (const entry of entries) {
+      const instance = entry.instance
+      // 跳过已经启动过的插件
+      if (instance._started) {
+        continue
+      }
+      try {
+        if (typeof instance.start === 'function') {
+          await instance.start(this.framework)
+          instance._started = true
+        }
+      } catch (err) {
+        console.error(`[PluginManager] Start failed for '${instance.name}':`, err.message)
+      }
+    }
+  }
+
+  /**
+   * 启动所有已加载插件
+   * @private
+   */
+  async _startAll() {
+    const loaded = this.getAll()
+      .sort((a, b) => (a.instance.priority || 100) - (b.instance.priority || 100))
+
+    for (const { instance } of loaded) {
+      try {
+        if (typeof instance.start === 'function') {
+          await instance.start(this.framework)
+        }
+      } catch (err) {
+        console.error(`[PluginManager] Start failed for '${instance.name}':`, err.message)
+      }
+    }
+  }
+
+  /**
+   * 从对象创建插件实例
+   * @private
+   */
+  _createFromObject(obj) {
+    const { Plugin } = require('./plugin-base')
+
+    // 如果是类（构造函数），直接实例化
+    if (typeof obj === 'function') {
+      // 检查是否是 Plugin 的子类（通过 prototype chain）
+      if (obj.prototype instanceof Plugin) {
+        return new obj()
+      }
+      // 否则是工厂函数，调用它获取类或实例
+      const result = obj(Plugin)
+      // 递归处理返回值
+      if (typeof result === 'function' && result.prototype instanceof Plugin) {
+        return new result()
+      }
+      return result
+    }
+
+    // 支持对象形式: { name, version, install, start, ... }
+    class AnonymousPlugin extends Plugin {
+      constructor() {
+        super()
+        this.name = obj.name
+        this.version = obj.version || '1.0.0'
+        this.description = obj.description || ''
+        this.priority = obj.priority || 100
+
+        // 如果提供了 install/start/reload/uninstall 方法，绑定它们
+        if (typeof obj.install === 'function') {
+          this.install = obj.install.bind(this)
+        }
+        if (typeof obj.start === 'function') {
+          this.start = obj.start.bind(this)
+        }
+        if (typeof obj.reload === 'function') {
+          this.reload = obj.reload.bind(this)
+        }
+        if (typeof obj.uninstall === 'function') {
+          this.uninstall = obj.uninstall.bind(this)
+        }
+      }
+    }
+
+    return new AnonymousPlugin()
+  }
+}
+
+module.exports = { PluginManager }

package/src/core/provider.js

@@ -0,0 +1,108 @@
+/**
+ * AI Provider 工厂
+ * 支持多种 AI 提供商
+ */
+
+const { createOpenAICompatible } = require('@ai-sdk/openai-compatible')
+const { createOpenAI } = require('@ai-sdk/openai')
+const { createAnthropic } = require('@ai-sdk/anthropic')
+
+/**
+ * 默认提供商配置
+ */
+const DEFAULT_PROVIDERS = {
+  openai: {
+    name: 'OpenAI',
+    baseURL: 'https://api.openai.com/v1'
+  },
+  ollama: {
+    name: 'Ollama',
+    baseURL: 'http://localhost:11434/v1'
+  },
+  lmstudio: {
+    name: 'LM Studio',
+    baseURL: 'http://localhost:1234/v1'
+  },
+  deepseek: {
+    name: 'DeepSeek',
+    baseURL: 'https://api.deepseek.com/v1'
+  },
+  anthropic: {
+    name: 'Anthropic',
+    baseURL: 'https://api.anthropic.com/v1'
+  }
+}
+
+/**
+ * 创建 AI 客户端
+ * @param {Object} config - 配置
+ * @param {string} config.provider - 提供商名称
+ * @param {string} config.model - 模型名称
+ * @param {string} config.apiKey - API 密钥
+ * @param {string} [config.baseURL] - 自定义 API 地址
+ */
+function createAI(config) {
+  const { provider, model, apiKey, baseURL } = config
+  const providerName = (provider || 'deepseek').toLowerCase()
+
+  // 检查是否是预定义提供商
+  if (DEFAULT_PROVIDERS[providerName]) {
+    const providerConfig = DEFAULT_PROVIDERS[providerName]
+    return createOpenAICompatible({
+      name: providerConfig.name,
+      baseURL: baseURL || providerConfig.baseURL,
+      apiKey: apiKey || 'dummy-key',
+      headers: provider === 'anthropic' ? {
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01'
+      } : undefined,
+      models: {
+        default: {
+          id: model || 'deepseek-chat',
+          streamOptions: {
+            includeUsage: true
+          }
+        }
+      }
+    })
+  }
+
+  // 自定义提供商
+  return createOpenAICompatible({
+    name: providerName || 'Custom',
+    baseURL: baseURL,
+    apiKey: apiKey || 'dummy-key',
+    models: {
+      default: {
+        id: model || 'gpt-4'
+      }
+    }
+  })
+}
+
+/**
+ * 获取可用提供商列表
+ */
+function getAvailableProviders() {
+  return Object.entries(DEFAULT_PROVIDERS).map(([key, value]) => ({
+    id: key,
+    name: value.name,
+    baseURL: value.baseURL
+  }))
+}
+
+/**
+ * 创建模型实例
+ * @param {string} model - 模型名称
+ * @param {Object} provider - Provider 实例
+ */
+function createModel(model, provider) {
+  return provider(model)
+}
+
+module.exports = {
+  createAI,
+  createModel,
+  getAvailableProviders,
+  DEFAULT_PROVIDERS
+}

package/src/core/tool-registry.js

@@ -0,0 +1,134 @@
+/**
+ * ToolRegistry 工具注册表
+ * 统一管理所有工具
+ */
+
+const { EventEmitter } = require('../utils/event-emitter')
+
+class ToolRegistry extends EventEmitter {
+  constructor() {
+    super()
+    this._tools = new Map()
+  }
+
+  /**
+   * 注册工具
+   * @param {Object} tool - 工具定义
+   * @param {string} tool.name - 工具名称
+   * @param {string} tool.description - 工具描述
+   * @param {Function} tool.execute - 执行函数
+   * @param {Object} [tool.parameters] - 参数 schema
+   */
+  register(tool) {
+    if (!tool.name) {
+      throw new Error('Tool must have a name')
+    }
+    if (typeof tool.execute !== 'function') {
+      throw new Error(`Tool '${tool.name}' must have an execute function`)
+    }
+
+    this._tools.set(tool.name, {
+      name: tool.name,
+      description: tool.description || '',
+      inputSchema: tool.inputSchema || null,
+      parameters: tool.parameters || null,
+      execute: tool.execute
+    })
+
+    this.emit('tool:registered', tool)
+    return this
+  }
+
+  /**
+   * 批量注册工具
+   * @param {Array<Object>} tools - 工具数组
+   */
+  registerMany(tools) {
+    for (const tool of tools) {
+      this.register(tool)
+    }
+    return this
+  }
+
+  /**
+   * 注销工具
+   * @param {string} name - 工具名称
+   */
+  unregister(name) {
+    const tool = this._tools.get(name)
+    if (tool) {
+      this._tools.delete(name)
+      this.emit('tool:unregistered', tool)
+    }
+    return this
+  }
+
+  /**
+   * 获取工具
+   * @param {string} name - 工具名称
+   * @returns {Object|undefined}
+   */
+  get(name) {
+    return this._tools.get(name)
+  }
+
+  /**
+   * 获取所有工具
+   * @returns {Array<Object>}
+   */
+  getAll() {
+    return Array.from(this._tools.values())
+  }
+
+  /**
+   * 检查工具是否存在
+   * @param {string} name - 工具名称
+   * @returns {boolean}
+   */
+  has(name) {
+    return this._tools.has(name)
+  }
+
+  /**
+   * 执行工具
+   * @param {string} name - 工具名称
+   * @param {Object} args - 参数
+   * @param {Framework} framework - 框架实例
+   * @returns {Promise<any>}
+   */
+  async execute(name, args, framework) {
+    const tool = this._tools.get(name)
+    if (!tool) {
+      throw new Error(`Tool '${name}' not found`)
+    }
+
+    try {
+      this.emit('tool:call', { name, args })
+      const result = await tool.execute(args, framework)
+      this.emit('tool:result', { name, args, result })
+      return result
+    } catch (err) {
+      this.emit('tool:error', { name, args, error: err })
+      throw err
+    }
+  }
+
+  /**
+   * 清空所有工具
+   */
+  clear() {
+    this._tools.clear()
+    this.emit('tool:cleared')
+    return this
+  }
+
+  /**
+   * 获取工具数量
+   * @returns {number}
+   */
+  size() {
+    return this._tools.size
+  }
+}
+
+module.exports = { ToolRegistry }