foliko 1.1.67 → 1.1.69

package/src/utils/logger.js

@@ -1,19 +1,39 @@
 /**
- * Foliko Logger - 统一日志系统
- * 支持日志级别、命名空间、格式化输出
+ * Foliko Logger - 基于 Pino 的统一日志系统
+ * 支持日志级别、命名空间、格式化输出、文件轮转
  */
 
-const LOG_LEVELS = {
-  DEBUG: 0,
-  INFO: 1,
-  WARN: 2,
-  ERROR: 3,
-  NONE: 4,
-};
+const pino = require('pino');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
 
-const LEVEL_NAMES = ['DEBUG', 'INFO', 'WARN', 'ERROR'];
+// 默认日志目录（在项目 .foliko/logs 下）
+const DEFAULT_LOG_DIR = path.join(process.cwd(), '.foliko', 'logs');
 
-// 全局事件发射器，用于日志事件
+// 创建日志目录
+function ensureLogDir(logDir) {
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true });
+  }
+  return logDir;
+}
+
+// 获取日志文件路径
+function getLogFilePath(logDir) {
+  ensureLogDir(logDir);
+  const date = new Date().toISOString().split('T')[0];
+  return path.join(logDir, `vb-agent-${date}.log`);
+}
+
+// 当前日志文件路径
+let currentLogFile = null;
+let currentFileStream = null;
+
+// 根 logger 引用
+let rootLogger = null;
+
+// 日志事件发射器
 const logEmitter = {
   _listeners: {},
   on(event, listener) {
@@ -37,173 +57,129 @@ const logEmitter = {
   }
 };
 
-class Logger {
-  /**
-   * @param {Object} options
-   * @param {string} options.namespace - 日志命名空间
-   * @param {number} options.level - 日志级别 (0-4)
-   * @param {boolean} options.enableTimestamp - 是否显示时间戳
-   * @param {boolean} options.enableColors - 是否使用颜色
-   */
-  constructor(options = {}) {
-    this.namespace = options.namespace || 'app';
-    this._level = options.level ?? LOG_LEVELS.INFO;
-    this.enableTimestamp = options.enableTimestamp !== false;
-    this.enableColors = options.enableColors !== false;
-
-    // 颜色代码
-    this.colors = {
-      debug: '\x1b[36m', // 青色
-      info: '\x1b[32m', // 绿色
-      warn: '\x1b[33m', // 黄色
-      error: '\x1b[31m', // 红色
-      grey: '\x1b[90m', // 暗灰色
-      reset: '\x1b[0m',
-      dim: '\x1b[2m', // 暗灰色
-    };
+// 初始化 logger
+function initLogger(options = {}) {
+  const {
+    level = process.env.LOG_LEVEL || 'info',
+    logDir = DEFAULT_LOG_DIR,
+    name = 'vb-agent',
+    silent = false, // 是否静默（不输出到控制台）
+  } = options;
+
+  currentLogFile = getLogFilePath(logDir);
+
+  // 关闭旧的文件流
+  if (currentFileStream) {
+    currentFileStream.end();
+    currentFileStream = null;
   }
 
-  /**
-   * 全局日志级别（可被继承的子类覆盖）
-   */
-  get level() {
-    return Logger.globalLevel ?? this._level;
-  }
+  // 如果是静默模式（CLI TUI），只创建文件写入流
+  if (silent) {
+    // 使用 pino.destination 直接写文件，不经过 stdout
+    currentFileStream = pino.destination({
+      dest: currentLogFile,
+      sync: false, // 异步写入
+    });
 
-  set level(v) {
-    this._level = v;
+    rootLogger = pino({
+      name,
+      level,
+      timestamp: pino.stdTimeFunctions.isoTime,
+      base: {
+        pid: process.pid,
+        hostname: os.hostname(),
+      },
+    }, currentFileStream);
+
+    return rootLogger;
   }
 
-  static globalLevel = null;
-  static globalLevelOverride = false;
+  // 非静默模式：同时输出到控制台和文件
+  currentFileStream = fs.createWriteStream(currentLogFile, { flags: 'a' });
 
-  /**
-   * 创建子日志器
-   * @param {string} namespace
-   * @returns {Logger}
-   */
-  child(namespace) {
-    return new Logger({
-      namespace: `${this.namespace}:${namespace}`,
-      level: this.level,
-      enableTimestamp: this.enableTimestamp,
-      enableColors: this.enableColors,
-    });
-  }
+  rootLogger = pino({
+    name,
+    level,
+    timestamp: pino.stdTimeFunctions.isoTime,
+    base: {
+      pid: process.pid,
+      hostname: os.hostname(),
+    },
+  }, currentFileStream);
 
-  /**
-   * 设置日志级别
-   * @param {string|number} level
-   */
-  setLevel(level) {
-    if (typeof level === 'string') {
-      this.level = LOG_LEVELS[level.toUpperCase()] ?? LOG_LEVELS.INFO;
-    } else {
-      this.level = level;
-    }
-  }
+  return rootLogger;
+}
 
-  /**
-   * 格式化日志消息
-   * @private
-   */
-  _format(level, levelName, args) {
-    const color = this.colors[levelName.toLowerCase()] || '';
-    const reset = this.colors.reset;
-    const dim = this.colors.dim;
-    const grey = this.colors.grey;
+// 获取根 logger（延迟初始化）
+function getRootLogger() {
+  if (!rootLogger) {
+    // 默认静默模式（CLI 使用）
+    rootLogger = initLogger({ silent: true });
+  }
+  return rootLogger;
+}
 
-    const parts = [];
+// Logger 类
+class Logger {
+  constructor(options = {}) {
+    this.namespace = options.namespace || 'app';
+    this._logger = getRootLogger().child({ name: this.namespace });
+  }
 
-    // 命名空间
-    parts.push(`${dim}[${this.namespace}]${reset}`);
+  child(namespace) {
+    return new Logger({ namespace: `${this.namespace}:${namespace}` });
+  }
 
-    // 时间戳
-    if (this.enableTimestamp) {
-      const timestamp = new Date().toISOString().split('T')[1].slice(0, -1);
-      parts.push(`${dim}${timestamp}${reset}`);
-    }
+  // 事件监听支持
+  on(event, listener) {
+    logEmitter.on(event, listener);
+  }
 
-    // 级别
-    if (this.enableColors) {
-      parts.push(`${color}${levelName.padEnd(5)}${reset}`);
-    } else {
-      parts.push(levelName.padEnd(5));
-    }
+  off(event, listener) {
+    logEmitter.off(event, listener);
+  }
 
-    // 消息（根据级别着色）
-    const msgColor = this.enableColors ? color : '';
-    const message = args
-      .map((arg) => {
-        if (arg instanceof Error) {
-          return `${arg.message}\n${arg.stack}`;
-        }
-        if (typeof arg === 'object') {
-          try {
-            return JSON.stringify(arg, null, 2);
-          } catch {
-            return String(arg);
-          }
-        }
-        return String(arg);
-      })
-      .join(' ');
-
-    parts.push(`${grey}${message}${reset}`);
-    return parts.join(' ');
+  trace(...args) {
+    const msg = args.join(' ');
+    this._logger.trace({ event: 'trace', msg }, msg);
+    logEmitter.emit('log', { level: 'TRACE', namespace: this.namespace, message: msg });
   }
 
-  /**
-   * 调试日志
-   * @param {...any} args
-   */
   debug(...args) {
-    if (this.level <= LOG_LEVELS.DEBUG) {
-      const formatted = this._format('debug', 'DEBUG', args);
-      logEmitter.emit('log', { level: 'DEBUG', namespace: this.namespace, message: args.join(' '), formatted });
-    }
+    const msg = args.join(' ');
+    this._logger.debug({ event: 'debug', msg }, msg);
+    logEmitter.emit('log', { level: 'DEBUG', namespace: this.namespace, message: msg });
   }
 
-  /**
-   * 信息日志
-   * @param {...any} args
-   */
   info(...args) {
-    if (this.level <= LOG_LEVELS.INFO) {
-      const formatted = this._format('info', 'INFO', args);
-      console.log(formatted);
-      logEmitter.emit('log', { level: 'INFO', namespace: this.namespace, message: args.join(' '), formatted });
-    }
+    const msg = args.join(' ');
+    this._logger.info({ event: 'info', msg }, msg);
+    logEmitter.emit('log', { level: 'INFO', namespace: this.namespace, message: msg });
   }
 
-  /**
-   * 警告日志
-   * @param {...any} args
-   */
   warn(...args) {
-    if (this.level <= LOG_LEVELS.WARN) {
-      const formatted = this._format('warn', 'WARN', args);
-      console.warn(formatted);
-      logEmitter.emit('log', { level: 'WARN', namespace: this.namespace, message: args.join(' '), formatted });
-    }
+    const msg = args.join(' ');
+    this._logger.warn({ event: 'warn', msg }, msg);
+    logEmitter.emit('log', { level: 'WARN', namespace: this.namespace, message: msg });
   }
 
-  /**
-   * 错误日志
-   * @param {...any} args
-   */
   error(...args) {
-    if (this.level <= LOG_LEVELS.ERROR) {
-      const formatted = this._format('error', 'ERROR', args);
-      console.error(formatted);
-      logEmitter.emit('log', { level: 'ERROR', namespace: this.namespace, message: args.join(' '), formatted });
-    }
+    const msg = args.join(' ');
+    this._logger.error({ event: 'error', msg }, msg);
+    logEmitter.emit('log', { level: 'ERROR', namespace: this.namespace, message: msg });
+  }
+
+  fatal(...args) {
+    const msg = args.join(' ');
+    this._logger.fatal({ event: 'fatal', msg }, msg);
+    logEmitter.emit('log', { level: 'FATAL', namespace: this.namespace, message: msg });
   }
 
   /**
-   * 性能计时开始
+   * 性能计时
    * @param {string} label
-   * @returns {function} 结束计时函数
+   * @returns {function} 结束函数，调用后记录耗时
    */
   timer(label) {
     const start = process.hrtime.bigint();
@@ -215,41 +191,37 @@ class Logger {
   }
 }
 
-// 全局日志器实例（单例）
-function getLogger() {
-  if (!getLogger._instance) {
-    getLogger._instance = new Logger({
-      namespace: 'foliko',
-      level: process.env.LOG_LEVEL ? LOG_LEVELS[process.env.LOG_LEVEL.toUpperCase()] : LOG_LEVELS.INFO,
-    });
-  }
-  return getLogger._instance;
-}
-
-// 一次绑定，消除每次访问 getter 重复 bind 的开销
-const _globalLogger = getLogger();
-
-// 允许动态设置全局日志级别
-function setGlobalLogLevel(level) {
-  Logger.globalLevel = level;
-  if (_globalLogger) {
-    _globalLogger._level = level;
-  }
+// 创建全局 logger
+function createGlobalLogger() {
+  return new Logger({ namespace: 'foliko' });
 }
 
 // 导出
 module.exports = {
   Logger,
-  logger: {
-    child: _globalLogger.child.bind(_globalLogger),
-    debug: _globalLogger.debug.bind(_globalLogger),
-    info: _globalLogger.info.bind(_globalLogger),
-    warn: _globalLogger.warn.bind(_globalLogger),
-    error: _globalLogger.error.bind(_globalLogger),
-    timer: _globalLogger.timer.bind(_globalLogger),
-    setLevel: (level) => _globalLogger.setLevel(level),
-    setGlobalLogLevel,
+  logger: createGlobalLogger(),
+  setGlobalLogLevel: (level) => {
+    if (rootLogger) {
+      rootLogger.level = level;
+    }
+  },
+  setSilent: () => {
+    rootLogger = null;
+    getRootLogger();
+  },
+  setConsole: () => {
+    rootLogger = null;
+    rootLogger = initLogger({ silent: false });
+    getRootLogger();
+  },
+  getLogFilePath: () => currentLogFile,
+  initLogger,
+  LOG_LEVELS: {
+    TRACE: 'trace',
+    DEBUG: 'debug',
+    INFO: 'info',
+    WARN: 'warn',
+    ERROR: 'error',
+    NONE: 'silent',
   },
-  logEmitter,
-  LOG_LEVELS,
 };

package/src/utils/message-validator.js

@@ -0,0 +1,283 @@
+/**
+ * 消息验证工具
+ * 统一管理 tool-call / tool-result 配对验证
+ *
+ * 解决的问题：
+ * - 消除 4 处重复的消息配对验证逻辑
+ * - 统一 tool-call 输入格式验证
+ * - 减少消息数组多次遍历
+ */
+
+const { logger } = require('./logger');
+
+/**
+ * 收集所有 assistant 消息中的 tool-call ID
+ * @param {Array} messages - 消息数组
+ * @returns {Set<string>} tool-call ID 集合
+ */
+function collectToolCallIds(messages) {
+  const ids = new Set();
+  for (const msg of messages) {
+    if (msg.role !== 'assistant') continue;
+
+    // 格式1: msg.content 数组中的 tool-call 块 (AI SDK 格式)
+    if (Array.isArray(msg.content)) {
+      for (const item of msg.content) {
+        if ((item.type === 'tool-call' || item.type === 'tool-use') && item.toolCallId) {
+          ids.add(item.toolCallId);
+        }
+      }
+    }
+
+    // 格式2: msg.tool_calls 数组 (OpenAI 兼容格式)
+    if (Array.isArray(msg.tool_calls)) {
+      for (const tc of msg.tool_calls) {
+        if (tc.id) ids.add(tc.id);
+      }
+    }
+  }
+  return ids;
+}
+
+/**
+ * 验证消息配对 — 移除 orphaned tool-result（没有对应 tool-call 的）
+ * @param {Array} messages - 消息数组（会被修改）
+ * @param {Object} [options]
+ * @param {boolean} [options.log=true] - 是否记录日志
+ * @returns {Array} 过滤后的消息数组
+ */
+function validateMessagesPairing(messages, options = {}) {
+  const { log: shouldLog = true } = options;
+  const validToolCallIds = collectToolCallIds(messages);
+
+  let removedToolResultCount = 0;
+
+  for (const msg of messages) {
+    if (msg.role !== 'tool' || !Array.isArray(msg.content)) continue;
+
+    const originalLength = msg.content.length;
+    msg.content = msg.content.filter((item) => {
+      if (
+        item &&
+        (item.type === 'tool-result' || item.type === 'tool_result') &&
+        item.toolCallId &&
+        !validToolCallIds.has(item.toolCallId)
+      ) {
+        removedToolResultCount++;
+        return false;
+      }
+      return true;
+    });
+
+    // content 全被删除了，标记整个消息待删除
+    if (msg.content.length === 0 && originalLength > 0) {
+      msg._orphaned = true;
+    }
+  }
+
+  const originalLen = messages.length;
+  const filtered = messages.filter((msg) => !(msg.role === 'tool' && msg._orphaned));
+
+  if (shouldLog && (removedToolResultCount > 0 || filtered.length !== originalLen)) {
+    logger.debug(
+      `[validateMessagesPairing] removed ${removedToolResultCount} orphaned tool-results,` +
+        ` ${originalLen - filtered.length} orphaned tool messages`
+    );
+  }
+
+  return filtered;
+}
+
+/**
+ * 验证 tool-call 格式 — 修复不完整的 JSON 输入
+ * @param {Array} messages - 消息数组（会被修改）
+ * @param {Object} [options]
+ * @param {boolean} [options.log=true] - 是否记录日志
+ * @returns {number} 修复/移除的数量
+ */
+function validateToolCalls(messages, options = {}) {
+  const { log: shouldLog = true } = options;
+  let fixedCount = 0;
+  const invalidatedToolCallIds = new Set();
+
+  for (const msg of messages) {
+    if (msg.role !== 'assistant' || !Array.isArray(msg.content)) continue;
+
+    for (const item of msg.content) {
+      if (item.type !== 'tool-call' && item.type !== 'tool-use') continue;
+
+      const input = item.input;
+      if (typeof input !== 'string') continue;
+
+      const trimmed = input.trim();
+      if (trimmed === '{' || trimmed === '' || !trimmed.startsWith('{')) {
+        if (item.toolCallId) {
+          invalidatedToolCallIds.add(item.toolCallId);
+        }
+        if (shouldLog) {
+          logger.warn(
+            `[validateToolCalls] invalid input for "${item.toolName}", toolCallId=${item.toolCallId ||
+              '?'}, converting to text`
+          );
+        }
+        // 把无效的 tool-call 转换成 text 文本
+        item.type = 'text';
+        item.text = `（工具调用 ${item.toolName} 参数不完整，已跳过）`;
+        delete item.toolCallId;
+        delete item.toolName;
+        delete item.input;
+        fixedCount++;
+      }
+    }
+  }
+
+  // 清理引用了无效 toolCallId 的 tool-result
+  if (invalidatedToolCallIds.size > 0) {
+    for (const msg of messages) {
+      if (msg.role !== 'tool' || !Array.isArray(msg.content)) continue;
+
+      msg.content = msg.content.filter((item) => {
+        if (
+          item &&
+          (item.type === 'tool-result' || item.type === 'tool_result') &&
+          item.toolCallId &&
+          invalidatedToolCallIds.has(item.toolCallId)
+        ) {
+          fixedCount++;
+          return false;
+        }
+        return true;
+      });
+    }
+  }
+
+  if (shouldLog && fixedCount > 0) {
+    logger.info(`[validateToolCalls] Fixed ${fixedCount} incomplete tool calls/results`);
+  }
+
+  return fixedCount;
+}
+
+/**
+ * 一次遍历完成配对验证 + tool-call 格式验证
+ * 相比分别调用减少消息数组迭代次数
+ * @param {Array} messages - 消息数组（会被修改）
+ * @returns {Array} 过滤后的消息数组
+ */
+function validateAll(messages) {
+  // 1. 先修复 tool-call 格式（避免无效 ID 干扰后续配对验证）
+  validateToolCalls(messages);
+  // 2. 再移除 orphaned tool-result
+  return validateMessagesPairing(messages);
+}
+
+/**
+ * 过滤消息，保留配对的 tool-call → tool-result 链条
+ * 用于上下文压缩后保留完整的工具调用链路
+ * @param {Array} messages - 消息数组
+ * @param {number} [keepRecentAssistant=3] - 保留最近几条无工具调用的 assistant 消息
+ * @returns {Array} 过滤后的消息数组
+ */
+function filterPairedMessages(messages, keepRecentAssistant = 3) {
+  // 第一遍：收集所有 tool-call 及对应的 result
+  const assistantToolCalls = new Map(); // toolCallId → assistant index
+  const toolResults = new Map(); // toolCallId → [result indices]
+
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role === 'assistant') {
+      const content = Array.isArray(msg.content) ? msg.content : [msg.content];
+      for (const item of content) {
+        if ((item.type === 'tool-call' || item.type === 'tool-use') && item.toolCallId) {
+          assistantToolCalls.set(item.toolCallId, i);
+        }
+      }
+      if (Array.isArray(msg.tool_calls)) {
+        for (const tc of msg.tool_calls) {
+          if (tc.id) assistantToolCalls.set(tc.id, i);
+        }
+      }
+    }
+    if (msg.role === 'tool' && Array.isArray(msg.content)) {
+      for (const item of msg.content) {
+        if ((item.type === 'tool-result' || item.type === 'tool_result') && item.toolCallId) {
+          if (!toolResults.has(item.toolCallId)) {
+            toolResults.set(item.toolCallId, []);
+          }
+          toolResults.get(item.toolCallId).push(i);
+        }
+      }
+    }
+  }
+
+  // 第二遍：决定哪些 assistant 消息需要保留
+  const assistantIndicesToKeep = new Set();
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role !== 'assistant') continue;
+
+    // 检查是否有 tool-call
+    let hasToolCall = false;
+    const content = Array.isArray(msg.content) ? msg.content : [msg.content];
+    for (const item of content) {
+      if (item.type === 'tool-call' || item.type === 'tool-use') {
+        hasToolCall = true;
+        break;
+      }
+    }
+    if (!hasToolCall && Array.isArray(msg.tool_calls)) {
+      hasToolCall = msg.tool_calls.some((tc) => tc.id);
+    }
+
+    if (hasToolCall) {
+      assistantIndicesToKeep.add(i);
+    } else if (i >= messages.length - keepRecentAssistant) {
+      // 保留最近几条非工具调用的 assistant 消息
+      assistantIndicesToKeep.add(i);
+    }
+  }
+
+  // 保存有 tool-call 但没有 result 的 assistant（防止切掉半截链条）
+  for (const [toolCallId, assistantIdx] of assistantToolCalls) {
+    if (!toolResults.has(toolCallId)) {
+      assistantIndicesToKeep.add(assistantIdx);
+    }
+  }
+
+  // 第三遍：决定哪些 tool-result 要保留（只保留有对应 assistant 的）
+  const indicesToKeep = new Set();
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role === 'tool') {
+      const content = Array.isArray(msg.content) ? msg.content : [msg.content];
+      const hasPairedAssistant = content.some(
+        (item) =>
+          (item.type === 'tool-result' || item.type === 'tool_result') &&
+          item.toolCallId &&
+          assistantToolCalls.has(item.toolCallId) &&
+          assistantIndicesToKeep.has(assistantToolCalls.get(item.toolCallId))
+      );
+      if (hasPairedAssistant) {
+        indicesToKeep.add(i);
+      }
+    } else if (msg.role === 'assistant') {
+      if (assistantIndicesToKeep.has(i)) {
+        indicesToKeep.add(i);
+      }
+    } else {
+      // user, system 等角色默认保留
+      indicesToKeep.add(i);
+    }
+  }
+
+  return Array.from(indicesToKeep)
+    .sort((a, b) => a - b)
+    .map((i) => messages[i]);
+}
+
+module.exports = {
+  validateMessagesPairing,
+  validateToolCalls,
+  validateAll,
+  filterPairedMessages,
+};

package/src/utils/plugin-helpers.js

@@ -24,8 +24,8 @@ function isDirectory(filePath) {
 /**
  * 解析插件路径
  * 支持两种结构：
- * 1. 文件夹结构: .agent/plugins/my-plugin/index.js
- * 2. 单文件结构: .agent/plugins/my-plugin.js
+ * 1. 文件夹结构: .foliko/plugins/my-plugin/index.js
+ * 2. 单文件结构: .foliko/plugins/my-plugin.js
  * @param {string} pluginsDir - 插件目录
  * @param {string} name - 插件名称
  * @param {Object} options - 选项