@yun520-1/heartflow 0.15.2

package/src/core/utils/error-handler.js

@@ -0,0 +1,228 @@
+/**
+ * Error Handler - 全局错误边界与异常处理
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const ERROR_CONFIG = {
+  maxRetries: 3,
+  retryableErrors: ['ECONNRESET', 'ETIMEDOUT', 'ENOTFOUND', 'ENETUNREACH', 'ECONNREFUSED'],
+  logFile: '.opencode/logs/error.log',
+  gracefulMessage: '我遇到了一些内部波动，让我们重新聚焦当前任务，你刚才说到哪里了？'
+};
+
+class ErrorHandler {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.logFile = path.join(projectRoot, ERROR_CONFIG.logFile);
+    this.retryCounts = new Map();
+    this.errorHistory = [];
+  }
+
+  /**
+   * 错误处理主函数
+   */
+  handleError(error, context = {}) {
+    const errorInfo = this.formatError(error, context);
+    
+    this.logError(errorInfo);
+    
+    this.errorHistory.push(errorInfo);
+    if (this.errorHistory.length > 50) {
+      this.errorHistory.shift();
+    }
+
+    const shouldRetry = this.shouldRetry(error, context);
+    
+    if (shouldRetry) {
+      const retryCount = this.getRetryCount(context.operation || 'default');
+      
+      if (retryCount < ERROR_CONFIG.maxRetries) {
+        const delay = this.calculateBackoff(retryCount);
+        return {
+          action: 'retry',
+          delay,
+          retryCount: retryCount + 1,
+          operation: context.operation,
+          message: `将在 ${delay}ms 后重试 (${retryCount + 1}/${ERROR_CONFIG.maxRetries})`
+        };
+      }
+    }
+
+    return {
+      action: 'graceful_degradation',
+      userMessage: ERROR_CONFIG.gracefulMessage,
+      internalMessage: error.message,
+      recoverable: false
+    };
+  }
+
+  formatError(error, context) {
+    return {
+      timestamp: new Date().toISOString(),
+      name: error.name,
+      message: error.message,
+      stack: error.stack || '',
+      context: context,
+      operation: context.operation || 'unknown'
+    };
+  }
+
+  logError(errorInfo) {
+    try {
+      const dir = path.dirname(this.logFile);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+
+      const logEntry = `[${errorInfo.timestamp}] ${errorInfo.name}: ${errorInfo.message}\n` +
+        `  Operation: ${errorInfo.operation}\n` +
+        `  Context: ${JSON.stringify(errorInfo.context)}\n` +
+        (errorInfo.stack ? `  Stack: ${errorInfo.stack}\n` : '') +
+        '---\n';
+
+      fs.appendFileSync(this.logFile, logEntry);
+    } catch (e) {
+      console.error('[ErrorHandler] Failed to write log:', e.message);
+    }
+  }
+
+  shouldRetry(error, context) {
+    if (context.noRetry) return false;
+    if (context.retriesRemaining !== undefined && context.retriesRemaining <= 0) return false;
+
+    const errorCode = error.code || error.name;
+    if (ERROR_CONFIG.retryableErrors.includes(errorCode)) {
+      return true;
+    }
+
+    const retryablePatterns = [
+      /timeout/i,
+      /network/i,
+      /connection/i,
+      /ECONN/i,
+      /ETIMEDOUT/i,
+      /fetch/i
+    ];
+
+    const errorMessage = error.message || '';
+    return retryablePatterns.some(pattern => pattern.test(errorMessage));
+  }
+
+  getRetryCount(operation) {
+    const current = this.retryCounts.get(operation) || 0;
+    return current;
+  }
+
+  incrementRetryCount(operation) {
+    const current = this.retryCounts.get(operation) || 0;
+    this.retryCounts.set(operation, current + 1);
+  }
+
+  resetRetryCount(operation) {
+    this.retryCounts.delete(operation);
+  }
+
+  calculateBackoff(retryCount) {
+    const baseDelay = 1000;
+    const backoffFactor = 2;
+    const delay = baseDelay * Math.pow(backoffFactor, retryCount);
+    return Math.min(delay, 10000);
+  }
+
+  /**
+   * 执行带重试的操作
+   */
+  async executeWithRetry(operationFn, context = {}) {
+    const operation = context.operation || 'operation';
+    let lastError = null;
+
+    for (let attempt = 0; attempt < ERROR_CONFIG.maxRetries; attempt++) {
+      try {
+        this.resetRetryCount(operation);
+        const result = await operationFn();
+        return { success: true, result };
+      } catch (error) {
+        lastError = error;
+        
+        const handleResult = this.handleError(error, {
+          ...context,
+          operation
+        });
+
+        if (handleResult.action === 'retry') {
+          this.incrementRetryCount(operation);
+          await this.sleep(handleResult.delay);
+          continue;
+        }
+
+        return {
+          success: false,
+          error: handleResult,
+          message: handleResult.userMessage
+        };
+      }
+    }
+
+    return {
+      success: false,
+      error: lastError,
+      message: ERROR_CONFIG.gracefulMessage
+    };
+  }
+
+  sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  /**
+   * 获取错误历史
+   */
+  getErrorHistory(limit = 10) {
+    return this.errorHistory.slice(-limit);
+  }
+
+  /**
+   * 获取统计信息
+   */
+  getStats() {
+    const errorTypes = {};
+    for (const e of this.errorHistory) {
+      errorTypes[e.name] = (errorTypes[e.name] || 0) + 1;
+    }
+
+    return {
+      totalErrors: this.errorHistory.length,
+      errorTypes,
+      recentErrors: this.errorHistory.slice(-5).map(e => ({
+        timestamp: e.timestamp,
+        name: e.name,
+        operation: e.operation
+      }))
+    };
+  }
+
+  /**
+   * 清理旧日志
+   */
+  cleanOldLogs(maxAgeDays = 7) {
+    try {
+      if (!fs.existsSync(this.logFile)) return;
+
+      const stats = fs.statSync(this.logFile);
+      const ageMs = Date.now() - stats.mtimeMs;
+      const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1000;
+
+      if (ageMs > maxAgeMs) {
+        const backupFile = this.logFile + '.old';
+        fs.renameSync(this.logFile, backupFile);
+        console.log(`[ErrorHandler] Rotated old log to ${backupFile}`);
+      }
+    } catch (e) {
+      console.error('[ErrorHandler] Failed to clean logs:', e.message);
+    }
+  }
+}
+
+module.exports = { ErrorHandler, ERROR_CONFIG };

package/src/core/utils/fs-adapter.js

@@ -0,0 +1,36 @@
+/**
+ * FS Adapter — 文件系统适配器
+ * 跨平台：Node.js / Python / Browser
+ * @version v0.12.50
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+class FSAdapter {
+  constructor(rootPath) {
+    this.root = rootPath || path.resolve(__dirname, '../../../..');
+  }
+  readFileSync(p) {
+    return fs.readFileSync(path.isAbsolute(p) ? p : path.join(this.root, p), 'utf8');
+  }
+  writeFileSync(p, content) {
+    const fp = path.isAbsolute(p) ? p : path.join(this.root, p);
+    fs.mkdirSync(path.dirname(fp), { recursive: true });
+    fs.writeFileSync(fp, content, 'utf8');
+  }
+  existsSync(p) {
+    return fs.existsSync(path.isAbsolute(p) ? p : path.join(this.root, p));
+  }
+  mkdirSync(p) {
+    fs.mkdirSync(path.isAbsolute(p) ? p : path.join(this.root, p), { recursive: true });
+  }
+  readdirSync(p) {
+    return fs.readdirSync(path.isAbsolute(p) ? p : path.join(this.root, p));
+  }
+  readJSON(p) { return JSON.parse(this.readFileSync(p)); }
+  writeJSON(p, obj) { this.writeFileSync(p, JSON.stringify(obj, null, 2)); }
+}
+
+module.exports = { FSAdapter };

package/src/core/utils/logger.js

@@ -0,0 +1,25 @@
+/**
+ * Logger — 简单日志工具
+ * @version v0.12.50
+ */
+'use strict';
+
+class Logger {
+  constructor(level = 'info') {
+    this.level = level;
+    this.levels = { debug: 0, info: 1, warn: 2, error: 3 };
+  }
+  _log(level, ...args) {
+    if (this.levels[level] >= this.levels[this.level]) {
+      const ts = new Date().toISOString().slice(0, 19);
+      const fn = level === 'debug' ? 'log' : level;
+      console[fn](`[${ts}] [${level.toUpperCase()}]`, ...args);
+    }
+  }
+  debug(...a) { this._log('debug', ...a); }
+  info(...a)  { this._log('info', ...a); }
+  warn(...a)  { this._log('warn', ...a); }
+  error(...a) { this._log('error', ...a); }
+}
+
+module.exports = { Logger };

package/src/core/utils/retry-util.js

@@ -0,0 +1,118 @@
+/**
+ * Retry Utility - 重试与退避策略工具
+ */
+
+const RETRY_CONFIG = {
+  maxRetries: 3,
+  initialDelay: 1000,
+  backoffFactor: 2,
+  maxDelay: 10000,
+  retryableErrors: ['ECONNRESET', 'ETIMEDOUT', 'ENOTFOUND', 'ENETUNREACH', 'ECONNREFUSED', '429', '500', '502', '503', '504']
+};
+
+class RetryUtility {
+  constructor(config = {}) {
+    this.config = { ...RETRY_CONFIG, ...config };
+  }
+
+  /**
+   * 带指数退避的重试执行
+   */
+  async executeWithRetry(fn, context = {}) {
+    let lastError = null;
+    const { maxRetries, initialDelay, backoffFactor, maxDelay } = this.config;
+
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      try {
+        const result = await fn();
+        return {
+          success: true,
+          result,
+          attempts: attempt + 1
+        };
+      } catch (error) {
+        lastError = error;
+
+        const isRetryable = this.isRetryable(error);
+        
+        if (!isRetryable || attempt === maxRetries - 1) {
+          return {
+            success: false,
+            error,
+            attempts: attempt + 1,
+            message: error.message
+          };
+        }
+
+        const delay = this.calculateDelay(attempt, initialDelay, backoffFactor, maxDelay);
+        
+        if (context.onRetry) {
+          context.onRetry({
+            attempt: attempt + 1,
+            maxRetries,
+            delay,
+            error: error.message
+          });
+        }
+
+        await this.sleep(delay);
+      }
+    }
+
+    return {
+      success: false,
+      error: lastError,
+      attempts: maxRetries
+    };
+  }
+
+  /**
+   * 判断错误是否可重试
+   */
+  isRetryable(error) {
+    const errorMessage = error.message || '';
+    const errorCode = error.code || '';
+
+    if (this.config.retryableErrors.includes(errorCode)) {
+      return true;
+    }
+
+    const patterns = [
+      /timeout/i,
+      /network/i,
+      /connection/i,
+      /ECONN/i,
+      /ETIMEDOUT/i,
+      /fetch/i,
+      /rate.?limit/i,
+      /429/i,
+      /5\d{2}/i
+    ];
+
+    return patterns.some(pattern => 
+      pattern.test(errorMessage) || pattern.test(errorCode)
+    );
+  }
+
+  /**
+   * 计算延迟
+   */
+  calculateDelay(attempt, initialDelay, backoffFactor, maxDelay) {
+    const delay = initialDelay * Math.pow(backoffFactor, attempt);
+    return Math.min(delay, maxDelay);
+  }
+
+  sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  /**
+   * 创建带重试的 Promise
+   */
+  retryablePromise(promiseFn, config = {}) {
+    const retry = new RetryUtility(config);
+    return retry.executeWithRetry(promiseFn);
+  }
+}
+
+module.exports = { RetryUtility, RETRY_CONFIG };