foliko 1.1.93 → 2.0.0

package/src/{core → session}/branch-summary-auto.js

@@ -9,9 +9,9 @@ const {
   BRANCH_SUMMARY_PREAMBLE,
   BRANCH_SUMMARY_PROMPT,
   serializeConversation
-} = require('./context-compressor');
+} = require('../context/compressor');
 
-const { logger } = require('../utils/logger');
+const { logger } = require('../common/logger');
 
 class BranchSummaryAuto {
   /**

package/src/{core/chat-session.js → session/chat.js}

@@ -8,8 +8,8 @@
  * 4. SessionScope 事件作用域
  */
 
-const { EventEmitter } = require('../utils/event-emitter');
-const { logger } = require('../utils/logger');
+const { EventEmitter } = require('../common/events');
+const { logger } = require('../common/logger');
 
 /**
  * Session 作用域的事件监听器

package/src/session/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = {
+  SessionManager: require('./session').SessionManager,
+  SessionEntry: require('./entry'),
+  ChatSession: require('./chat').ChatSession,
+};

package/src/{core/session-manager.js → session/session.js}

@@ -6,7 +6,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { JsonlSessionStorage } = require('./jsonl-storage');
+const { JsonlSessionStorage } = require('../storage/jsonl');
 const {
   EntryTypes,
   generateEntryId,
@@ -15,7 +15,7 @@ const {
   createBranchSummaryMessage,
   createCompactionSummaryMessage,
   createCustomMessage
-} = require('./session-entry');
+} = require('./entry');
 
 const CURRENT_SESSION_VERSION = 3;
 

package/src/session/ttl.js

@@ -0,0 +1,92 @@
+'use strict';
+
+/**
+ * SessionTTL - Session 过期清理管理
+ * 从 framework.js 中提取的 TTL 清理逻辑
+ */
+
+const { DEFAULT_SESSION_CLEANUP_INTERVAL_MS } = require('../common/constants');
+
+class SessionTTL {
+  /**
+   * @param {Object} options
+   * @param {Function} options.getSessionContexts - 返回 session 上下文 Map
+   * @param {Function} options.destroySession - 销毁 session 的函数
+   * @param {number} [options.ttlMs=1800000] - TTL 毫秒数，默认 30 分钟
+   * @param {number} [options.checkIntervalMs=60000] - 检查间隔，默认 60 秒
+   */
+  constructor(options = {}) {
+    this._getSessionContexts = options.getSessionContexts;
+    this._destroySession = options.destroySession;
+    this._ttlMs = options.ttlMs || 30 * 60 * 1000;
+    this._checkIntervalMs = options.checkIntervalMs || DEFAULT_SESSION_CLEANUP_INTERVAL_MS;
+    this._intervalId = null;
+    this._lastAccessMap = new Map();
+  }
+
+  /**
+   * 设置 TTL
+   */
+  setTTL(ttlMs) {
+    this._ttlMs = ttlMs;
+    return this;
+  }
+
+  /**
+   * 启动定期清理
+   */
+  start() {
+    if (this._intervalId) return;
+    this._intervalId = setInterval(() => this._cleanup(), this._checkIntervalMs);
+    this._intervalId.unref();
+    return this;
+  }
+
+  /**
+   * 停止定期清理
+   */
+  stop() {
+    if (this._intervalId) {
+      clearInterval(this._intervalId);
+      this._intervalId = null;
+    }
+    return this;
+  }
+
+  /**
+   * 标记 session 活跃（更新最后访问时间）
+   */
+  touch(sessionId) {
+    this._lastAccessMap.set(sessionId, Date.now());
+  }
+
+  /**
+   * 清理过期 session
+   */
+  _cleanup() {
+    if (!this._getSessionContexts) return;
+    const contexts = this._getSessionContexts();
+    if (!contexts || contexts.size === 0) return;
+
+    const now = Date.now();
+    for (const [sessionId] of contexts) {
+      const lastAccess = this._lastAccessMap.get(sessionId) || now;
+      if (now - lastAccess > this._ttlMs) {
+        this._lastAccessMap.delete(sessionId);
+        if (this._destroySession) {
+          this._destroySession(sessionId);
+        }
+      }
+    }
+  }
+
+  /**
+   * 销毁
+   */
+  destroy() {
+    this.stop();
+    this._lastAccessMap.clear();
+  }
+}
+
+module.exports = { SessionTTL };

package/src/{core/jsonl-storage.js → storage/jsonl.js}

@@ -6,7 +6,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { generateEntryId, EntryTypes } = require('./session-entry');
+const { generateEntryId, EntryTypes } = require('../session/entry');
 
 const CURRENT_SESSION_VERSION = 3;
 

package/src/tool/executor.js

@@ -0,0 +1,85 @@
+'use strict';
+
+/**
+ * ToolExecutor - 工具执行器
+ *
+ * 职责：
+ * 1. 工具发现和注册
+ * 2. 工具执行
+ * 3. 工具调用验证
+ */
+
+const { EventEmitter } = require('../common/events');
+const { logger } = require('../common/logger');
+const { validateToolCalls } = require('../utils/message-validator');
+
+class ToolExecutor extends EventEmitter {
+  constructor(config = {}) {
+    super();
+
+    this.config = config;
+    this.agent = config.agent;
+    this.framework = config.framework;
+
+    this._tools = new Map();
+    this._toolStats = {
+      totalCalls: 0,
+      failedCalls: 0,
+      lastCall: null,
+    };
+  }
+
+  registerTool(tool) {
+    if (!tool || !tool.name) {
+      logger.warn('ToolExecutor', 'Ignoring tool with no name');
+      return;
+    }
+    this._tools.set(tool.name, tool);
+    logger.debug('ToolExecutor', `Registered tool: ${tool.name}`);
+  }
+
+  unregisterTool(name) {
+    this._tools.delete(name);
+  }
+
+  getTool(name) {
+    return this._tools.get(name) || null;
+  }
+
+  getAllTools() {
+    return Array.from(this._tools.values());
+  }
+
+  async executeTool(name, args, context = {}) {
+    const tool = this._tools.get(name);
+    if (!tool) {
+      throw new Error(`Tool '${name}' not found`);
+    }
+
+    this._toolStats.totalCalls++;
+    this._toolStats.lastCall = Date.now();
+
+    try {
+      const result = await tool.execute(args, context);
+      this.emit('tool:executed', { name, args, result });
+      return result;
+    } catch (err) {
+      this._toolStats.failedCalls++;
+      this.emit('tool:error', { name, args, error: err });
+      throw err;
+    }
+  }
+
+  validateToolCalls(messages) {
+    return validateToolCalls(messages);
+  }
+
+  getStats() {
+    return {
+      ...this._toolStats,
+      toolCount: this._tools.size,
+    };
+  }
+}
+
+module.exports = { ToolExecutor };

package/src/tool/index.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const { ToolRegistry } = require('./registry');
+const { ToolExecutor } = require('./executor');
+const { ToolRouter, INTENT_PATTERNS } = require('./router');
+const { jsonSchemaToZod, toAISDKTool } = require('./schema');
+
+module.exports = {
+  ToolRegistry,
+  ToolExecutor,
+  ToolRouter,
+  INTENT_PATTERNS,
+  jsonSchemaToZod,
+  toAISDKTool,
+};

package/src/tool/registry.js

@@ -0,0 +1,143 @@
+'use strict';
+
+/**
+ * ToolRegistry 工具注册表
+ * 统一管理所有工具
+ */
+
+const { EventEmitter } = require('../common/events');
+const { globalCircuitBreaker } = require('../common/circuit');
+const { logger } = require('../common/logger');
+const { z } = require('zod');
+const { withRetry, isNetworkError, PRESETS } = require('../common/retry');
+const { ErrorBoundary, Severity, RecoveryAction } = require('../common/errors');
+const { jsonSchemaToZod } = require('./schema');
+
+const log = logger.child('ToolRegistry');
+
+class ToolRegistry extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this._tools = new Map();
+
+    this._circuitBreakerEnabled = options.circuitBreaker !== false;
+    this._circuitBreaker = globalCircuitBreaker;
+
+    this._defaultCircuitBreakerOptions = {
+      failureThreshold: options.failureThreshold || 3,
+      successThreshold: options.successThreshold || 2,
+      timeout: options.circuitBreakerTimeout || 60000,
+    };
+  }
+
+  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 || '',
+      execute: tool.execute,
+      parameters: tool.parameters || {},
+      inputSchema: tool.inputSchema || null,
+      retry: tool.retry,
+      circuitBreaker: tool.circuitBreaker,
+    });
+    log.debug(`Tool registered: ${tool.name}`);
+    this.emit('tool:registered', tool);
+  }
+
+  get(name) {
+    return this._tools.get(name) || null;
+  }
+
+  has(name) {
+    return this._tools.has(name);
+  }
+
+  getAll() {
+    return Array.from(this._tools.values());
+  }
+
+  getNames() {
+    return Array.from(this._tools.keys());
+  }
+
+  unregister(name) {
+    this._tools.delete(name);
+    this.emit('tool:unregistered', { name });
+  }
+
+  clear() {
+    this._tools.clear();
+    this._tools = new Map();
+  }
+
+  count() {
+    return this._tools.size;
+  }
+
+  async execute(name, args, context = {}) {
+    const tool = this._tools.get(name);
+    if (!tool) {
+      throw new Error(`Tool '${name}' not found`);
+    }
+
+    const executeFn = async () => {
+      const startTime = Date.now();
+      let result;
+      let error;
+
+      try {
+        result = await tool.execute(args, context);
+      } catch (err) {
+        error = err;
+      }
+
+      const duration = Date.now() - startTime;
+
+      if (error) {
+        this.emit('tool:error', { name, args, error, duration });
+        throw error;
+      }
+
+      this.emit('tool:result', { name, args, result, duration });
+      return result;
+    };
+
+    if (tool.retry) {
+      const retryConfig = typeof tool.retry === 'string'
+        ? PRESETS[tool.retry] || PRESETS.standard
+        : tool.retry;
+
+      return withRetry(executeFn, {
+        ...retryConfig,
+        onRetry: (err, attempt) => {
+          log.warn(`Tool '${name}' failed (attempt ${attempt}), retrying: ${err.message}`);
+        },
+      });
+    }
+
+    return executeFn();
+  }
+
+  getCircuitBreakerStatus() {
+    return {
+      enabled: this._circuitBreakerEnabled,
+      state: this._circuitBreaker.getState(),
+    };
+  }
+
+  _jsonSchemaToZod(schema, key, isRequired) {
+    if (!schema) return z.any();
+
+    // 委托给 schema.js 处理
+    return jsonSchemaToZod(schema, isRequired);
+  }
+}
+
+module.exports = { ToolRegistry };

package/src/{core/tool-router.js → tool/router.js}

@@ -1,75 +1,36 @@
+'use strict';
+
 /**
  * 意图路由工具管理器
  * 根据用户输入智能选择要传递给 LLM 的工具
  */
 
-const { EventEmitter } = require('../utils/event-emitter');
+const { EventEmitter } = require('../common/events');
 
-/**
- * 内置意图分类
- */
 const INTENT_PATTERNS = {
   file_operation: {
     keywords: [
-      '读取文件',
-      '写文件',
-      '创建文件',
-      '删除文件',
-      '修改文件',
-      '查看文件',
-      'read',
-      'write',
-      'create',
-      'delete',
-      'modify',
-      'file',
-      '文件',
+      '读取文件', '写文件', '创建文件', '删除文件', '修改文件', '查看文件',
+      'read', 'write', 'create', 'delete', 'modify', 'file', '文件',
     ],
     tools: [
-      'read_file',
-      'write_file',
-      'delete_file',
-      'modify_file',
-      'read_directory',
-      'create_directory',
-      'search_file',
+      'read_file', 'write_file', 'delete_file', 'modify_file',
+      'read_directory', 'create_directory', 'search_file',
     ],
   },
   code_development: {
     keywords: [
-      '写代码',
-      '开发',
-      '编程',
-      '创建插件',
-      '编写函数',
-      'code',
-      'develop',
-      'plugin',
-      '编程',
+      '写代码', '开发', '编程', '创建插件', '编写函数',
+      'code', 'develop', 'plugin', '编程',
     ],
     tools: ['loadSkill', 'read_file', 'write_file', 'execute_command', 'shell'],
   },
   system_info: {
     keywords: [
-      '系统信息',
-      '内存',
-      'CPU',
-      '磁盘',
-      '进程',
-      'system',
-      'memory',
-      'cpu',
-      'disk',
-      'process',
-      'info',
-    ],
-    tools: [
-      'get_system_info',
-      'get_memory_usage',
-      'get_cpu_info',
-      'get_disk_space',
-      'get_process_info',
+      '系统信息', '内存', 'CPU', '磁盘', '进程',
+      'system', 'memory', 'cpu', 'disk', 'process', 'info',
     ],
+    tools: ['get_system_info', 'get_memory_usage', 'get_cpu_info', 'get_disk_space', 'get_process_info'],
   },
   data_analysis: {
     keywords: ['分析', '数据', '统计', '查询', 'analyze', 'data', 'statistics', 'query'],
@@ -89,43 +50,14 @@ const INTENT_PATTERNS = {
   },
   scheduling: {
     keywords: [
-      '定时',
-      '提醒',
-      '通知',
-      'schedule',
-      'remind',
-      'notify',
-      'cron',
-      '任务',
-      '稍后',
-      '天后',
-      '秒后',
-      '分钟后',
-      '小时后',
-      '明天',
-      '今天',
-    ],
-    tools: [
-      'schedule_cron',
-      'schedule_once',
-      'schedule_list',
-      'schedule_cancel',
-      'schedule_get_results',
-      'schedule_notify',
+      '定时', '提醒', '通知', 'schedule', 'remind', 'notify',
+      'cron', '任务', '稍后', '天后', '秒后', '分钟后', '小时后',
+      '明天', '今天',
     ],
+    tools: ['schedule_cron', 'schedule_once', 'schedule_list', 'schedule_cancel', 'schedule_get_results', 'schedule_notify'],
   },
   thinking: {
-    keywords: [
-      '思考',
-      '反思',
-      '想想',
-      'think',
-      'reflect',
-      '分析一下',
-      '头脑风暴',
-      '持续思考',
-      '自动思考',
-    ],
+    keywords: ['思考', '反思', '想想', 'think', 'reflect', '分析一下', '头脑风暴', '持续思考', '自动思考'],
     tools: ['think_now', 'think_continue', 'think_stop', 'think_get_thoughts'],
   },
 };
@@ -136,36 +68,23 @@ class ToolRouter extends EventEmitter {
     this._tools = new Map();
     this._defaultTools = new Set();
 
-    // 注册工具
     for (const tool of tools) {
       this.register(tool);
     }
   }
 
-  /**
-   * 注册工具
-   */
   register(tool) {
     this._tools.set(tool.name, tool);
   }
 
-  /**
-   * 设置默认工具（每个请求都会包含）
-   */
   setDefaultTools(toolNames) {
     this._defaultTools = new Set(toolNames);
   }
 
-  /**
-   * 判断是否为默认工具
-   */
   isDefaultTool(name) {
     return this._defaultTools.has(name);
   }
 
-  /**
-   * 分析用户输入，识别意图
-   */
   analyzeIntent(userMessage) {
     const message = userMessage.toLowerCase();
 
@@ -189,15 +108,11 @@ class ToolRouter extends EventEmitter {
       }
     }
 
-    // 按分数排序
     matchedIntents.sort((a, b) => b.score - a.score);
 
     return matchedIntents;
   }
 
-  /**
-   * 获取指定意图对应的工具
-   */
   getToolsForIntent(intent) {
     const result = [];
 
@@ -211,42 +126,29 @@ class ToolRouter extends EventEmitter {
     return result;
   }
 
-  /**
-   * 为用户消息选择合适的工具
-   * @param {string} userMessage - 用户消息
-   * @param {Object} options - 选项
-   * @param {number} options.maxTools - 最大工具数量（默认10）
-   * @param {boolean} options.forceIntent - 强制使用指定意图
-   */
   selectTools(userMessage, options = {}) {
     const { maxTools = 10 } = options;
 
-    // 如果没有工具，直接返回空的
     if (this._tools.size === 0) {
       return [];
     }
 
-    // 如果消息为空，返回默认工具
     if (!userMessage || userMessage.trim() === '') {
       return this.getDefaultTools();
     }
 
-    // 分析意图
     const intents = this.analyzeIntent(userMessage);
 
-    // 如果没有匹配到意图，返回默认工具
     if (intents.length === 0) {
       return this.getDefaultTools();
     }
 
     const selectedTools = new Map();
 
-    // 添加默认工具
     for (const tool of this.getDefaultTools()) {
       selectedTools.set(tool.name, tool);
     }
 
-    // 按意图选择工具
     for (const intent of intents) {
       if (selectedTools.size >= maxTools) break;
 
@@ -262,9 +164,6 @@ class ToolRouter extends EventEmitter {
     return Array.from(selectedTools.values());
   }
 
-  /**
-   * 获取默认工具
-   */
   getDefaultTools() {
     const result = [];
     for (const name of this._defaultTools) {
@@ -276,16 +175,10 @@ class ToolRouter extends EventEmitter {
     return result;
   }
 
-  /**
-   * 获取所有工具
-   */
   getAllTools() {
     return Array.from(this._tools.values());
   }
 
-  /**
-   * 按类别获取工具
-   */
   getToolsByCategory(category) {
     const intent = INTENT_PATTERNS[category];
     if (!intent) return [];