foliko 1.1.93 → 2.0.0

package/src/common/errors.js

@@ -0,0 +1,402 @@
+'use strict';
+
+/**
+ * Foliko Errors - 统一错误处理系统
+ * 合并了 error.js (错误类型) + error-boundary.js (错误边界)
+ */
+
+const { EventEmitter } = require('./events');
+const { logger } = require('./logger');
+
+// ============================================
+// 错误类型
+// ============================================
+
+/**
+ * Foliko 错误基类
+ */
+class FolikoError extends Error {
+  constructor(message, options = {}) {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = options.code || 'FOLIKO_ERROR';
+    this.context = options.context || {};
+    if (options.stack) {
+      this.stack = options.stack;
+    } else {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      context: this.context,
+      stack: this.stack,
+    };
+  }
+}
+
+class PluginError extends FolikoError {
+  constructor(message, options = {}) {
+    super(message, { code: 'PLUGIN_ERROR', context: options.context });
+  }
+}
+
+class ToolError extends FolikoError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: 'TOOL_ERROR',
+      context: { toolName: options.toolName, args: options.args, ...options.context },
+    });
+  }
+}
+
+class AIError extends FolikoError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: 'AI_ERROR',
+      context: { model: options.model, provider: options.provider, statusCode: options.statusCode, ...options.context },
+    });
+  }
+}
+
+class SessionError extends FolikoError {
+  constructor(message, options = {}) {
+    super(message, { code: 'SESSION_ERROR', context: { sessionId: options.sessionId, ...options.context } });
+  }
+}
+
+class ConfigError extends FolikoError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: 'CONFIG_ERROR',
+      context: { configKey: options.configKey, expected: options.expected, actual: options.actual, ...options.context },
+    });
+  }
+}
+
+class WorkflowError extends FolikoError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: 'WORKFLOW_ERROR',
+      context: { workflowName: options.workflowName, stepName: options.stepName, stepIndex: options.stepIndex, ...options.context },
+    });
+  }
+}
+
+class ValidationError extends FolikoError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: 'VALIDATION_ERROR',
+      context: { field: options.field, value: options.value, expected: options.expected, ...options.context },
+    });
+  }
+}
+
+class ToolNotFoundError extends ToolError {
+  constructor(toolName) {
+    super(`Tool not found: ${toolName}`, { toolName });
+    this.code = 'TOOL_NOT_FOUND';
+  }
+}
+
+class PluginNotFoundError extends PluginError {
+  constructor(pluginName) {
+    super(`Plugin not found: ${pluginName}`, { context: { pluginName } });
+    this.code = 'PLUGIN_NOT_FOUND';
+  }
+}
+
+class NetworkError extends FolikoError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: 'NETWORK_ERROR',
+      context: { host: options.host, port: options.port, code: options.code, ...options.context },
+    });
+  }
+}
+
+class AuthError extends FolikoError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: 'AUTH_ERROR',
+      context: { authType: options.authType, userId: options.userId, ...options.context },
+    });
+  }
+}
+
+class RateLimitError extends FolikoError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: 'RATE_LIMIT_ERROR',
+      context: { retryAfter: options.retryAfter, limit: options.limit, ...options.context },
+    });
+  }
+}
+
+class TimeoutError extends FolikoError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: 'TIMEOUT_ERROR',
+      context: { timeout: options.timeout, operation: options.operation, ...options.context },
+    });
+  }
+}
+
+class FileSystemError extends FolikoError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: 'FS_ERROR',
+      context: { path: options.path, operation: options.operation, ...options.context },
+    });
+  }
+}
+
+function isErrorOfType(error, ErrorClass) {
+  return error instanceof ErrorClass;
+}
+
+function safeErrorInfo(error) {
+  if (error instanceof FolikoError) {
+    return error.toJSON();
+  }
+  return {
+    name: error.name || 'Error',
+    message: error.message,
+    code: 'UNKNOWN_ERROR',
+    context: {},
+    stack: error.stack,
+  };
+}
+
+function createError(type, message, options = {}) {
+  const errorClasses = {
+    plugin: PluginError, tool: ToolError, ai: AIError, session: SessionError,
+    config: ConfigError, workflow: WorkflowError, validation: ValidationError,
+    network: NetworkError, auth: AuthError, rateLimit: RateLimitError,
+    timeout: TimeoutError, fs: FileSystemError,
+  };
+  const ErrorClass = errorClasses[type] || FolikoError;
+  return new ErrorClass(message, options);
+}
+
+function isRetryable(error) {
+  if (error instanceof RateLimitError) return true;
+  if (error instanceof TimeoutError) return true;
+  if (error instanceof NetworkError) return true;
+  if (error instanceof FolikoError) {
+    return ['RATE_LIMIT_ERROR', 'TIMEOUT_ERROR', 'NETWORK_ERROR'].includes(error.code);
+  }
+  return false;
+}
+
+function getFriendlyMessage(error) {
+  if (error instanceof FolikoError) {
+    const messages = {
+      PLUGIN_NOT_FOUND: '插件未找到，请检查配置',
+      TOOL_NOT_FOUND: '工具未找到，请检查工具名称',
+      CONFIG_ERROR: '配置错误，请检查配置文件',
+      VALIDATION_ERROR: '输入验证失败，请检查输入数据',
+      RATE_LIMIT_ERROR: '请求过于频繁，请稍后再试',
+      TIMEOUT_ERROR: '请求超时，请检查网络连接',
+      NETWORK_ERROR: '网络错误，请检查网络连接',
+      AUTH_ERROR: '认证失败，请检查凭据是否正确',
+    };
+    return messages[error.code] || error.message;
+  }
+  return error.message || '发生未知错误';
+}
+
+// ============================================
+// 错误边界
+// ============================================
+
+const Severity = {
+  LOW: 'low',
+  MEDIUM: 'medium',
+  HIGH: 'high',
+  CRITICAL: 'critical',
+};
+
+const RecoveryAction = {
+  RETRY: 'retry',
+  SKIP: 'skip',
+  FALLBACK: 'fallback',
+  ABORT: 'abort',
+  IGNORE: 'ignore',
+};
+
+class ErrorBoundary extends EventEmitter {
+  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;
+  }
+
+  async execute(operation, context = {}) {
+    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 {
+          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) {
+            logger.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 };
+    }
+  }
+
+  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);
+        logger.debug(`Retry attempt ${attempt}/${maxAttempts} after ${delay}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    throw lastError;
+  }
+
+  wrap(fn, defaultContext = {}) {
+    return async (...args) => {
+      const result = await this.execute(() => fn(...args), defaultContext);
+      return result.success ? result.result : result.fallbackResult;
+    };
+  }
+
+  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;
+          } catch (fallbackError) {
+            logger.warn(`Fallback also failed: ${fallbackError.message}`);
+            action = RecoveryAction.ABORT;
+          }
+        }
+        break;
+      case RecoveryAction.SKIP:
+        fallbackResult = null;
+        break;
+      case RecoveryAction.IGNORE:
+        fallbackResult = undefined;
+        break;
+      default:
+        action = RecoveryAction.ABORT;
+    }
+    return { action, fallbackResult };
+  }
+
+  _logError(error, context) {
+    const errorInfo = safeErrorInfo(error);
+    const severity = this._determineSeverity(error);
+    const logMsg = `[${this.name}] Error in ${context.operation || 'unknown'}: ${error.message}`;
+    switch (severity) {
+      case Severity.LOW: this._logger.debug(logMsg); break;
+      case Severity.MEDIUM: this._logger.warn(logMsg); break;
+      case Severity.HIGH: this._logger.error(logMsg); break;
+      case Severity.CRITICAL: this._logger.error(`CRITICAL: ${logMsg}`, { stack: error.stack }); break;
+    }
+  }
+
+  _determineSeverity(error) {
+    if (isErrorOfType(error, FolikoError)) {
+      return error.context?.severity || Severity.MEDIUM;
+    }
+    const msg = (error.message || '').toLowerCase();
+    if (msg.includes('timeout') || msg.includes('network')) return Severity.MEDIUM;
+    if (msg.includes('memory') || msg.includes('fatal')) return Severity.CRITICAL;
+    return Severity.HIGH;
+  }
+
+  _addToHistory(error, context) {
+    this._errorHistory.push({ timestamp: new Date().toISOString(), error: safeErrorInfo(error), context });
+    if (this._errorHistory.length > this._maxHistorySize) this._errorHistory.shift();
+  }
+
+  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; }
+}
+
+function createErrorBoundary(config = {}) {
+  return new ErrorBoundary(config);
+}
+
+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;
+}
+
+// ============================================
+// Exports
+// ============================================
+
+module.exports = {
+  // Error types
+  FolikoError, PluginError, ToolError, AIError, SessionError, ConfigError,
+  WorkflowError, ValidationError, ToolNotFoundError, PluginNotFoundError,
+  NetworkError, AuthError, RateLimitError, TimeoutError, FileSystemError,
+  isErrorOfType, safeErrorInfo, createError, isRetryable, getFriendlyMessage,
+  // Error boundary
+  ErrorBoundary, Severity, RecoveryAction, createErrorBoundary, combineBoundaries,
+};

package/src/{utils → common}/logger.js

@@ -196,6 +196,38 @@ function createGlobalLogger() {
   return new Logger({ namespace: 'foliko' });
 }
 
+/**
+ * Create a framework-bound logger that forwards log events to the framework
+ * @param {Object} framework - Framework instance (EventEmitter)
+ * @returns {Logger}
+ */
+function createFrameworkLogger(framework) {
+  const logger = new Logger({ namespace: 'foliko' });
+  const state = { silent: false };
+
+  // Forward log events to framework
+  const onLog = (data) => {
+    if (!state.silent) framework.emit('log', data);
+  };
+  logger.on('log', onLog);
+
+  // Override methods to emit per-level events
+  const LEVEL_METHODS = ['trace', 'debug', 'info', 'warn', 'error', 'fatal'];
+  for (const method of LEVEL_METHODS) {
+    const original = logger[method].bind(logger);
+    logger[method] = (...args) => {
+      if (!state.silent) original(...args);
+    };
+  }
+
+  logger.setSilent = (v) => { state.silent = v; };
+  logger.setGlobalLogLevel = (level) => {
+    if (rootLogger) rootLogger.level = level;
+  };
+
+  return logger;
+}
+
 // 导出
 module.exports = {
   Logger,
@@ -216,6 +248,7 @@ module.exports = {
   },
   getLogFilePath: () => currentLogFile,
   initLogger,
+  createFrameworkLogger,
   LOG_LEVELS: {
     TRACE: 'trace',
     DEBUG: 'debug',

package/src/{utils/chat-queue.js → common/queue.js}

@@ -1,5 +1,5 @@
-const { EventEmitter } = require('./event-emitter');
-const { cleanResponse } = require('./index');
+const { EventEmitter } = require('./events');
+const { cleanResponse } = require('../utils');
 const { logger } = require('./logger');
 const { isNetworkError, calculateDelay, PRESETS } = require('./retry');
 const log = logger.child('ChatQueue');

package/src/config/plugin-config.js

@@ -0,0 +1,50 @@
+/**
+ * 插件管理器公共配置
+ */
+
+// 默认插件仓库
+const DEFAULT_REPO = 'https://github.com/chnak/foliko-plugins.git';
+
+// 发布时忽略的文件和目录
+const IGNORE_PATTERNS = [
+  'node_modules',
+  '.git',
+  '.env',
+  '.DS_Store',
+  'Thumbs.db',
+  '*.log',
+  '*.lock',
+  '*.bak',
+  '.claude',
+  '.foliko',
+  'examples',
+  'dist',
+  'build',
+  'coverage',
+  'tests',
+  '__tests__',
+  '*.test.js',
+  '*.spec.js',
+  'package-lock.json',
+  'yarn.lock',
+  'pnpm-lock.yaml',
+];
+
+/**
+ * 检查文件/目录是否应该被忽略
+ */
+function shouldIgnore(name) {
+  return IGNORE_PATTERNS.some((pattern) => {
+    if (pattern.startsWith('*.')) {
+      const ext = pattern.slice(1);
+      return name.endsWith(ext);
+    }
+    return name === pattern;
+  });
+}
+
+module.exports = {
+  DEFAULT_REPO,
+  IGNORE_PATTERNS,
+  shouldIgnore,
+};

package/src/context/agent.js

@@ -0,0 +1,32 @@
+'use strict';
+
+/**
+ * AgentContext - Agent 级上下文
+ * 管理 Agent 运行时的状态
+ */
+
+class AgentContext {
+  constructor(options = {}) {
+    this.agentId = options.agentId;
+    this.name = options.name || 'Agent';
+    this.parentContext = options.parentContext || null;
+    this._data = new Map();
+    this.status = 'idle';
+    this.startedAt = Date.now();
+  }
+
+  set(key, value) { this._data.set(key, value); }
+  get(key) { return this._data.get(key); }
+  has(key) { return this._data.has(key); }
+
+  toJSON() {
+    return {
+      agentId: this.agentId,
+      name: this.name,
+      status: this.status,
+      startedAt: this.startedAt,
+    };
+  }
+}
+
+module.exports = { AgentContext };

package/src/context/compaction-prompts.js

@@ -0,0 +1,170 @@
+'use strict';
+
+/**
+ * Compaction and branch summarization prompt templates
+ */
+
+const SUMMARIZATION_SYSTEM_PROMPT = `You are a context summarization assistant. Your task is to read a conversation between a user and an AI coding assistant, then produce a structured summary following the exact format specified.
+
+Do NOT continue the conversation. Do NOT respond to any questions in the conversation. ONLY output the structured summary.`;
+
+const SUMMARIZATION_PROMPT = `The messages above are a conversation to summarize. Create a structured context checkpoint summary that another LLM will use to continue the work.
+
+Use this EXACT format:
+
+## Goal
+[What is the user trying to accomplish? Can be multiple items if the session covers different tasks.]
+
+## Constraints & Preferences
+- [Any constraints, preferences, or requirements mentioned by user]
+- [Or "(none)" if none were mentioned]
+
+## Progress
+### Done
+- [x] [Completed tasks/changes]
+
+### In Progress
+- [ ] [Current work]
+
+### Blocked
+- [Issues preventing progress, if any]
+
+## Key Decisions
+- **[Decision]**: [Brief rationale]
+
+## Next Steps
+1. [Ordered list of what should happen next]
+
+## Critical Context
+- [Any data, examples, or references needed to continue]
+- [Or "(none)" if not applicable]
+
+Keep each section concise. Preserve exact file paths, function names, and error messages.`;
+
+const UPDATE_SUMMARIZATION_PROMPT = `The messages above are NEW conversation messages to incorporate into the existing summary provided in <previous-summary> tags.
+
+Update the existing structured summary with new information. RULES:
+- PRESERVE all existing information from the previous summary
+- ADD new progress, decisions, and context from the new messages
+- UPDATE the Progress section: move items from "In Progress" to "Done" when completed
+- UPDATE "Next Steps" based on what was accomplished
+- PRESERVE exact file paths, function names, and error messages
+- If something is no longer relevant, you may remove it
+
+Use this EXACT format:
+
+## Goal
+[Preserve existing goals, add new ones if the task expanded]
+
+## Constraints & Preferences
+- [Preserve existing, add new ones discovered]
+
+## Progress
+### Done
+- [x] [Include previously done items AND newly completed items]
+
+### In Progress
+- [ ] [Current work - update based on progress]
+
+### Blocked
+- [Current blockers - remove if resolved]
+
+## Key Decisions
+- **[Decision]**: [Brief rationale] (preserve all previous, add new)
+
+## Next Steps
+1. [Update based on current state]
+
+## Critical Context
+- [Preserve important context, add new if needed]
+
+Keep each section concise. Preserve exact file paths, function names, and error messages.`;
+
+const TURN_PREFIX_SUMMARIZATION_PROMPT = `This is the PREFIX of a turn that was too large to keep. The SUFFIX (recent work) is retained.
+
+Summarize the prefix to provide context for the retained suffix:
+
+## Original Request
+[What did the user ask for in this turn?]
+
+## Early Progress
+- [Key decisions and work done in the prefix]
+
+## Context for Suffix
+- [Information needed to understand the retained recent work]
+
+Be concise. Focus on what's needed to understand the kept suffix.`;
+
+const BRANCH_SUMMARY_PREAMBLE = `The user explored a different conversation branch before returning here.
+Summary of that exploration:
+
+`;
+
+const BRANCH_SUMMARY_PROMPT = `Create a structured summary of this conversation branch for context when returning later.
+
+Use this EXACT format:
+
+## Goal
+[What was the user trying to accomplish in this branch?]
+
+## Constraints & Preferences
+- [Any constraints, preferences, or requirements mentioned]
+- [Or "(none)" if none were mentioned]
+
+## Progress
+### Done
+- [x] [Completed tasks/changes]
+
+### In Progress
+- [ ] [Work that was started but not finished]
+
+### Blocked
+- [Issues preventing progress, if any]
+
+## Key Decisions
+- **[Decision]**: [Brief rationale]
+
+## Next Steps
+1. [What should happen next to continue this work]
+
+Keep each section concise. Preserve exact file paths, function names, and error messages.`;
+
+const DEFAULT_COMPACTION_SETTINGS = {
+  enabled: true,
+  reserveTokens: 16384,
+  keepRecentTokens: 20000,
+};
+
+const MODEL_CONTEXT_LIMITS = {
+  'deepseek-chat': 100000,
+  'deepseek-coder': 100000,
+  'deepseek-v4-pro': 800000,
+  'deepseek-v4-flash': 800000,
+  'deepseek-reasoner': 100000,
+  'MiniMax-M2.7': 100000,
+  'gpt-4': 100000,
+  'gpt-4o': 100000,
+  'gpt-4o-mini': 100000,
+  'gpt-4-turbo': 100000,
+  'claude-3-5-sonnet': 110000,
+  'claude-3-opus': 110000,
+  'claude-3-sonnet': 110000,
+  'claude-3-haiku': 110000,
+  'claude-4-sonnet': 110000,
+  'claude-4-opus': 110000,
+  'glm-5.1': 110000,
+};
+
+const COMPRESSION_TIMEOUT_MS = 120000;
+
+module.exports = {
+  SUMMARIZATION_SYSTEM_PROMPT,
+  SUMMARIZATION_PROMPT,
+  UPDATE_SUMMARIZATION_PROMPT,
+  TURN_PREFIX_SUMMARIZATION_PROMPT,
+  BRANCH_SUMMARY_PREAMBLE,
+  BRANCH_SUMMARY_PROMPT,
+  DEFAULT_COMPACTION_SETTINGS,
+  MODEL_CONTEXT_LIMITS,
+  COMPRESSION_TIMEOUT_MS,
+};