foliko 1.1.93 → 2.0.0

package/src/core/worker-agent.js

@@ -1,192 +0,0 @@
-/**
- * WorkerAgent - 独立子Agent
- * 用于Coordinator模式下的Worker，基于Subagent轻量级实现
- * 任务完成后通过事件通知Coordinator
- */
-
-const { Subagent } = require('./subagent');
-const { EventEmitter } = require('../utils/event-emitter');
-
-class WorkerAgent extends EventEmitter {
-  /**
-   * @param {Framework} framework - 框架实例
-   * @param {Object} config - 配置
-   * @param {string} config.workerId - Worker唯一ID
-   * @param {string} [config.coordinatorId] - Coordinator的agentId
-   * @param {string} [config.name] - Worker名称
-   * @param {string} [config.role] - 角色描述
-   * @param {string} [config.description] - 描述
-   * @param {string} [config.systemPrompt] - 系统提示
-   * @param {string[]} [config.tools] - 可用工具名称列表
-   * @param {string[]} [config.parentTools] - 从父Agent继承的工具名称列表
-   */
-  constructor(framework, config) {
-    super();
-
-    this.framework = framework;
-    this.workerId = config.workerId;
-    this.coordinatorId = config.coordinatorId;
-    this._status = 'idle'; // idle, running, completed, error, stopped
-    this._task = config.task || '';
-
-    // 获取AI配置
-    const aiPlugin = framework.pluginManager?.get('ai');
-    const aiConfig = aiPlugin ? aiPlugin.getConfig() : {};
-    const mergedAIConfig = { ...aiConfig, ...config.llmConfig };
-
-    // 构建工具列表
-    const toolList = [];
-    if (config.tools) {
-      const allTools = framework.getTools();
-      const allowedTools = new Set(config.tools);
-      for (const toolName of allowedTools) {
-        const toolDef = allTools.find((t) => t.name === toolName);
-        if (toolDef) {
-          toolList.push(toolDef);
-        }
-      }
-    }
-
-    // 创建轻量子Agent
-    this._subagent = new Subagent({
-      name: config.name || `worker_${this.workerId}`,
-      role: config.role || 'Worker',
-      description: config.description || '',
-      systemPrompt: config.systemPrompt || WorkerAgent.defaultPrompt(),
-      model: config.model || mergedAIConfig.model || 'deepseek-chat',
-      provider: config.provider || mergedAIConfig.provider || 'deepseek',
-      apiKey: config.apiKey || mergedAIConfig.apiKey,
-      baseURL: config.baseURL || mergedAIConfig.baseURL,
-      tools: toolList,
-      // parentTools: config.parentTools || [],
-      framework: framework,
-      maxRetries: config.maxRetries ?? 2,
-      disableTools: config.disableTools ?? false,
-    });
-
-    // 转发Subagent事件
-    this._subagent.on('chunk', (chunk) => this.emit('chunk', chunk));
-    this._subagent.on('complete', (data) => {
-      this._status = 'completed';
-      this.emit('complete', data);
-    });
-    this._subagent.on('error', (data) => {
-      this._status = 'error';
-      this.emit('error', data);
-    });
-  }
-
-  /**
-   * 获取Worker状态
-   */
-  getStatus() {
-    return this._status;
-  }
-
-  /**
-   * 设置状态
-   */
-  setStatus(status) {
-    this._status = status;
-  }
-
-  /**
-   * 获取内部Subagent实例
-   */
-  getSubagent() {
-    return this._subagent;
-  }
-
-  /**
-   * 执行初始任务
-   * @param {string} task - 任务描述
-   * @param {Object} [options] - 选项
-   * @returns {Promise<Object>} 任务结果
-   */
-  async runTask(task, options) {
-    this._task = task;
-    this._status = 'running';
-
-    try {
-      const result = await this._subagent.chat(task, options);
-      if (!result.success) {
-        this._status = 'error';
-      }
-      return result;
-    } catch (err) {
-      this._status = 'error';
-      throw err;
-    }
-  }
-
-  /**
-   * 发送消息继续Worker
-   * @param {string} message - 继续消息
-   * @param {Object} [options] - 选项
-   * @returns {Promise<Object>} 处理结果
-   */
-  async sendMessage(message, options) {
-    if (this._status === 'stopped') {
-      throw new Error(`Worker ${this.workerId} has been stopped`);
-    }
-
-    this._status = 'running';
-    try {
-      const result = await this._subagent.chat(message, options);
-      return result;
-    } catch (err) {
-      this._status = 'error';
-      throw err;
-    }
-  }
-
-  /**
-   * 停止Worker
-   */
-  stop() {
-    this._status = 'stopped';
-    this._subagent.destroy();
-    this.emit('stopped', { workerId: this.workerId });
-  }
-
-  /**
-   * 生成<task-notification> JSON
-   * @param {string} status - completed, error, stopped
-   * @param {string} result - 任务结果
-   * @param {string} [error] - 错误信息
-   * @returns {string} JSON字符串
-   */
-  static formatNotification(workerId, status, result, error = null) {
-    const notification = {
-      worker_id: workerId,
-      status: status,
-      timestamp: new Date().toISOString(),
-    };
-
-    if (error) {
-      notification.error = error;
-    } else if (result) {
-      notification.result = result;
-    }
-
-    return JSON.stringify(notification);
-  }
-
-  /**
-   * 默认系统提示
-   */
-  static defaultPrompt() {
-    return `你是一个独立的Worker Agent。
-你的职责：
-1. 接收并理解Coordinator分配的任务
-2. 使用你的工具集完成任务
-3. 返回完整的任务结果
-
-重要规则：
-- 任务完成或出错时，在响应末尾添加JSON格式的<task-notification>说明状态
-- 不要主动联系Coordinator，由Coordinator主动查询结果
-- 如果需要更多信息，等待Coordinator发送continue消息`;
-  }
-}
-
-module.exports = { WorkerAgent };

package/src/executors/executor-base.js

@@ -1,58 +0,0 @@
-/**
- * Executor 基类
- * 执行器的基类，定义执行器接口
- */
-
-const { EventEmitter } = require('../utils/event-emitter');
-
-class ExecutorBase extends EventEmitter {
-  /**
-   * @param {string} name - 执行器名称
-   */
-  constructor(name) {
-    super();
-    this.name = name;
-    this._enabled = true;
-  }
-
-  /**
-   * 执行
-   * @param {Object} params - 执行参数
-   * @returns {Promise<any>}
-   */
-  async execute(params) {
-    throw new Error('execute() must be implemented');
-  }
-
-  /**
-   * 启用执行器
-   */
-  enable() {
-    this._enabled = true;
-    return this;
-  }
-
-  /**
-   * 禁用执行器
-   */
-  disable() {
-    this._enabled = false;
-    return this;
-  }
-
-  /**
-   * 是否启用
-   */
-  isEnabled() {
-    return this._enabled;
-  }
-
-  /**
-   * 销毁
-   */
-  destroy() {
-    this.removeAllListeners();
-  }
-}
-
-module.exports = { ExecutorBase };

package/src/utils/error-boundary.js

@@ -1,363 +0,0 @@
-/**
- * Foliko Error Boundary - 错误边界系统
- * 捕获、处理和恢复错误，提供降级方案
- */
-
-const { EventEmitter } = require('./event-emitter');
-const { logger } = require('./logger');
-const { safeErrorInfo, isErrorOfType } = require('./error');
-
-/**
- * 错误严重级别
- */
-const Severity = {
-  LOW: 'low', // 可忽略的小问题
-  MEDIUM: 'medium', // 需要关注但不阻断流程
-  HIGH: 'high', // 阻断当前操作但可恢复
-  CRITICAL: 'critical', // 致命错误，需要完全降级
-};
-
-/**
- * 错误恢复动作
- */
-const RecoveryAction = {
-  RETRY: 'retry', // 重试操作
-  SKIP: 'skip', // 跳过当前步骤
-  FALLBACK: 'fallback', // 使用降级方案
-  ABORT: 'abort', // 中止流程
-  IGNORE: 'ignore', // 忽略错误继续
-};
-
-/**
- * 错误上下文
- * @typedef {Object} ErrorContext
- * @property {string} operation - 操作名称
- * @property {string} component - 组件名称
- * @property {Object} metadata - 额外元数据
- * @property {number} attempt - 当前尝试次数
- */
-
-/**
- * 错误边界配置
- * @typedef {Object} ErrorBoundaryConfig
- * @property {string} name - 边界名称
- * @property {Function} [onError] - 全局错误处理器
- * @property {Function} [onRecovery] - 恢复处理器
- * @property {Function} [fallback] - 降级函数
- * @property {boolean} [logErrors=true] - 是否记录错误
- * @property {boolean} [propagateErrors=false] - 是否向上传播错误
- */
-
-/**
- * 错误边界类
- * 用于捕获和管理错误，提供恢复机制
- */
-class ErrorBoundary extends EventEmitter {
-  /**
-   * @param {ErrorBoundaryConfig} config
-   */
-  constructor(config = {}) {
-    super();
-
-    this.name = config.name || 'AnonymousBoundary';
-    this._onError = config.onError || null;
-    this._onRecovery = config.onRecovery || null;
-    this._fallback = config.fallback || null;
-    this._logErrors = config.logErrors !== false;
-    this._propagateErrors = config.propagateErrors || false;
-    this._logger = logger.child('ErrorBoundary');
-
-    // 错误统计
-    this._errorCount = 0;
-    this._lastError = null;
-    this._errorHistory = [];
-    this._maxHistorySize = config.maxHistorySize || 50;
-  }
-
-  /**
-   * 执行可能抛出错误的操作
-   * @param {Function} operation - 要执行的操作
-   * @param {Object} [context] - 错误上下文
-   * @returns {Promise<{success: boolean, result?: any, error?: Error, recovered?: boolean}>}
-   */
-  async execute(operation, context = {}) {
-    const operationName = context.operation || 'anonymous';
-
-    try {
-      const result = await (typeof operation === 'function' ? operation() : operation);
-      return { success: true, result };
-    } catch (error) {
-      this._errorCount++;
-      this._lastError = error;
-
-      // 记录到历史
-      this._addToHistory(error, context);
-
-      // 记录错误日志
-      if (this._logErrors) {
-        this._logError(error, context);
-      }
-
-      // 触发错误事件
-      this.emit('error', {
-        error,
-        context,
-        boundary: this.name,
-      });
-
-      // 调用全局错误处理器
-      let recoveryAction = RecoveryAction.ABORT;
-      if (this._onError) {
-        try {
-          // 使用 Promise.resolve 以支持 async 函数
-          recoveryAction = await Promise.resolve(this._onError(error, context, this));
-        } catch (handlerError) {
-          this._logger.warn(`Error in onError handler: ${handlerError.message}`);
-        }
-      }
-
-      // 根据恢复动作处理
-      const { action, fallbackResult } = await this._handleRecovery(error, context, recoveryAction);
-
-      // 触发恢复事件
-      if (action !== RecoveryAction.ABORT) {
-        this.emit('recovery', {
-          error,
-          context,
-          action,
-          boundary: this.name,
-        });
-
-        if (this._onRecovery) {
-          try {
-            await this._onRecovery(error, context, action, this);
-          } catch (recoveryError) {
-            log.warn(`Error in onRecovery handler: ${recoveryError.message}`);
-          }
-        }
-      }
-
-      // 如果需要传播错误，或者没有降级方案且要求传播，则抛出错误
-      if (this._propagateErrors || (action === RecoveryAction.ABORT && !fallbackResult)) {
-        throw error;
-      }
-
-      return {
-        success: false,
-        error,
-        recovered: action !== RecoveryAction.ABORT,
-        fallbackResult,
-        action,
-      };
-    }
-  }
-
-  /**
-   * 执行带重试的操作
-   * @param {Function} operation - 要执行的操作
-   * @param {Object} retryConfig - 重试配置
-   * @param {Object} [context] - 错误上下文
-   * @returns {Promise<any>}
-   */
-  async executeWithRetry(operation, retryConfig = {}, context = {}) {
-    const { maxAttempts = 3, baseDelay = 1000, shouldRetry = () => true } = retryConfig;
-
-    let lastError;
-
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      try {
-        return await this.execute(operation, { ...context, attempt });
-      } catch (error) {
-        lastError = error;
-
-        if (attempt >= maxAttempts || !shouldRetry(error, attempt)) {
-          throw error;
-        }
-
-        // 计算延迟
-        const delay = baseDelay * Math.pow(2, attempt - 1);
-        log.debug(`Retry attempt ${attempt}/${maxAttempts} after ${delay}ms...`);
-
-        await new Promise((resolve) => setTimeout(resolve, delay));
-      }
-    }
-
-    throw lastError;
-  }
-
-  /**
-   * 包装一个函数，使其错误被边界捕获
-   * @param {Function} fn - 要包装的函数
-   * @param {Object} [defaultContext] - 默认上下文
-   * @returns {Function}
-   */
-  wrap(fn, defaultContext = {}) {
-    return async (...args) => {
-      const result = await this.execute(() => fn(...args), defaultContext);
-      return result.success ? result.result : result.fallbackResult;
-    };
-  }
-
-  /**
-   * 处理错误恢复
-   * @private
-   */
-  async _handleRecovery(error, context, recoveryAction) {
-    let fallbackResult = null;
-    let action = recoveryAction;
-
-    switch (recoveryAction) {
-      case RecoveryAction.FALLBACK:
-        if (this._fallback) {
-          try {
-            fallbackResult = await this._fallback(error, context, this);
-            action = RecoveryAction.RETRY; // fallback 成功后视为恢复
-          } catch (fallbackError) {
-            log.warn(`Fallback also failed: ${fallbackError.message}`);
-            action = RecoveryAction.ABORT;
-          }
-        }
-        break;
-
-      case RecoveryAction.SKIP:
-        log.debug(`Skipping operation: ${context.operation}`);
-        fallbackResult = null;
-        break;
-
-      case RecoveryAction.IGNORE:
-        log.debug(`Ignoring error: ${error.message}`);
-        fallbackResult = undefined;
-        break;
-
-      default:
-        action = RecoveryAction.ABORT;
-    }
-
-    return { action, fallbackResult };
-  }
-
-  /**
-   * 记录错误
-   * @private
-   */
-  _logError(error, context) {
-    if (!this._logErrors) return;
-
-    const errorInfo = safeErrorInfo(error);
-    const severity = this._determineSeverity(error);
-
-    const logMessage = `[${this.name}] Error in ${context.operation || 'unknown'}: ${error.message}`;
-
-    switch (severity) {
-      case Severity.LOW:
-        this._logger.debug(logMessage);
-        break;
-      case Severity.MEDIUM:
-        this._logger.warn(logMessage);
-        break;
-      case Severity.HIGH:
-        this._logger.error(logMessage);
-        break;
-      case Severity.CRITICAL:
-        this._logger.error(`CRITICAL: ${logMessage}`, { stack: error.stack });
-        break;
-    }
-  }
-
-  /**
-   * 确定错误严重级别
-   * @private
-   */
-  _determineSeverity(error) {
-    if (isErrorOfType(error, require('./error').FolikoError)) {
-      return error.context?.severity || Severity.MEDIUM;
-    }
-
-    // 根据错误类型和消息判断
-    const message = (error.message || '').toLowerCase();
-
-    if (message.includes('timeout') || message.includes('network')) {
-      return Severity.MEDIUM;
-    }
-
-    if (message.includes('memory') || message.includes('fatal')) {
-      return Severity.CRITICAL;
-    }
-
-    return Severity.HIGH;
-  }
-
-  /**
-   * 添加错误到历史记录
-   * @private
-   */
-  _addToHistory(error, context) {
-    this._errorHistory.push({
-      timestamp: new Date().toISOString(),
-      error: safeErrorInfo(error),
-      context,
-    });
-
-    // 保持历史记录大小
-    if (this._errorHistory.length > this._maxHistorySize) {
-      this._errorHistory.shift();
-    }
-  }
-
-  /**
-   * 获取错误统计
-   * @returns {Object}
-   */
-  getStats() {
-    return {
-      totalErrors: this._errorCount,
-      lastError: this._lastError ? safeErrorInfo(this._lastError) : null,
-      historySize: this._errorHistory.length,
-      recentErrors: this._errorHistory.slice(-10),
-    };
-  }
-
-  /**
-   * 清空错误历史
-   */
-  clearHistory() {
-    this._errorHistory = [];
-    this._lastError = null;
-  }
-}
-
-/**
- * 创建错误边界实例的工厂函数
- * @param {ErrorBoundaryConfig} config
- * @returns {ErrorBoundary}
- */
-function createErrorBoundary(config = {}) {
-  return new ErrorBoundary(config);
-}
-
-/**
- * 组合多个错误边界
- * @param {ErrorBoundary[]} boundaries
- * @returns {ErrorBoundary}
- */
-function combineBoundaries(boundaries) {
-  const combined = new ErrorBoundary({
-    name: 'CombinedBoundary',
-  });
-
-  // 将错误传播到所有子边界
-  for (const boundary of boundaries) {
-    boundary.on('error', (data) => combined.emit('error', data));
-    boundary.on('recovery', (data) => combined.emit('recovery', data));
-  }
-
-  return combined;
-}
-
-module.exports = {
-  ErrorBoundary,
-  Severity,
-  RecoveryAction,
-  createErrorBoundary,
-  combineBoundaries,
-};