yijing-bazi-mcp/src/engines/yijing-engine.js

易经八字分析 MCP 服务器 - 提供传统命理分析和易经卦象解读的AI工具

/**
 * 易经分析引擎
 * 负责卦象生成、解读和决策建议
 */

const HexagramDatabase = require('../data/hexagram-database.js');
const YijingCalculator = require('../utils/yijing-calculator.js');
const Logger = require('../utils/logger.js');

class YijingEngine {
  constructor() {
    this.hexagramDB = new HexagramDatabase();
    this.calculator = new YijingCalculator();
    this.logger = new Logger();
  }

  /**
   * 生成卦象
   * @param {Object} params - 参数对象
   * @param {string} params.method - 起卦方式
   * @param {string} params.question - 用户问题
   * @param {string} [params.seed] - 起卦种子
   * @returns {Object} 卦象结果
   */
  async generateHexagram({ method, question, seed }) {
    try {
      this.logger.info('开始生成卦象', { method, question });

      // 根据不同方法生成爻
      let calculatorResult;
      switch (method) {
        case 'number':
          calculatorResult = this.calculator.generateFromNumber(seed || question);
          break;
        case 'time':
          calculatorResult = this.calculator.generateFromTime(new Date());
          break;
        case 'plum_blossom':
          calculatorResult = this.calculator.generateFromPlumBlossom(seed || question);
          break;
        case 'random':
          calculatorResult = this.calculator.generateRandom(question, seed);
          break;
        default:
          throw new Error(`不支持的起卦方式: ${method}`);
      }

      // 提取爻线数组
      const lines = calculatorResult.lines || calculatorResult;

      // 确定本卦
      const originalHexagram = this.determineHexagram(lines.map(l => l.type));

      // 确定变卦
      const changingLines = lines.filter(l => l.changing || l.is_changing).map(l => l.position);
      const changedHexagram = changingLines.length > 0
        ? this.calculateChangedHexagram(originalHexagram, changingLines)
        : null;

      // 获取卦象详细信息
      const originalInfo = await this.hexagramDB.getHexagram(originalHexagram.id);
      const changedInfo = changedHexagram
        ? await this.hexagramDB.getHexagram(changedHexagram.id)
        : null;

      const result = {
        timestamp: new Date().toISOString(),
        method: method,
        question: question,
        original: {
          ...originalHexagram,
          ...originalInfo,
          lines: lines
        },
        changing_lines: changingLines,
        changed: changedInfo ? {
          ...changedHexagram,
          ...changedInfo
        } : null,
        interpretation_hint: this.generateInterpretationHint(originalInfo, changedInfo, question)
      };

      this.logger.info('卦象生成成功', { hexagramId: originalHexagram.id });
      return result;
    } catch (error) {
      this.logger.error('卦象生成失败', {
        error: error.message,
        stack: error.stack,
        method: method,
        question: question,
        seed: seed
      });
      console.error('详细错误信息:', error);
      throw error;
    }
  }

  /**
   * 解读卦象
   * @param {Object} params - 参数对象
   * @param {Object} params.hexagram - 卦象数据
   * @param {string} params.focus - 解读焦点
   * @param {number} [params.line_number] - 爻位
   * @param {string} params.context - 应用场景
   * @param {string} [params.detail_level] - 详细程度
   * @returns {Object} 解读结果
   */
  async interpretHexagram({ hexagram, focus, line_number, context, detail_level = 'standard' }) {
    try {
      this.logger.info('开始解读卦象', { focus, context, detail_level });

      const originalInfo = await this.hexagramDB.getHexagram(hexagram.original?.id || hexagram.id || 1);
      const changedInfo = hexagram.changed
        ? await this.hexagramDB.getHexagram(hexagram.changed?.id || 1)
        : null;

      let interpretation = {};

      switch (focus) {
        case 'overall':
          interpretation = this.interpretOverall(originalInfo, changedInfo, context, detail_level);
          break;
        case 'specific_line':
          if (!line_number || line_number < 1 || line_number > 6) {
            throw new Error('解读特定爻位时必须提供有效的爻位号（1-6）');
          }
          interpretation = this.interpretSpecificLine(originalInfo, line_number, context, detail_level);
          break;
        case 'changing':
          if (!changedInfo) {
            throw new Error('没有变卦信息，无法进行变卦解读');
          }
          interpretation = this.interpretChanging(originalInfo, changedInfo, hexagram.changing_lines, context, detail_level);
          break;
        default:
          throw new Error(`不支持的解读焦点: ${focus}`);
      }

      const result = {
        timestamp: new Date().toISOString(),
        focus: focus,
        context: context,
        detail_level: detail_level,
        interpretation: interpretation,
        practical_guidance: this.generatePracticalGuidance(interpretation, context),
        cultural_context: this.getCulturalContext(originalInfo, context)
      };

      this.logger.info('卦象解读成功');
      return result;
    } catch (error) {
      this.logger.error('卦象解读失败', { error: error.message });
      throw error;
    }
  }

  /**
   * 提供决策建议
   * @param {Object} params - 参数对象
   * @param {Object} params.hexagram - 卦象数据
   * @param {string} params.question - 用户问题
   * @param {Array} [params.options] - 可选方案
   * @param {string} [params.time_frame] - 时间框架
   * @returns {Object} 决策建议
   */
  async provideAdvice({ hexagram, question, options = [], time_frame = 'short_term' }) {
    try {
      this.logger.info('开始提供决策建议', { question, time_frame });

      const originalInfo = await this.hexagramDB.getHexagram(hexagram.original?.id || hexagram.id || 1);
      const changedInfo = hexagram.changed
        ? await this.hexagramDB.getHexagram(hexagram.changed?.id || 1)
        : null;

      // 确保changing_lines是数组
      const changingLines = hexagram.changing_lines || [];

      // 分析卦象的行动指导
      const actionGuidance = this.analyzeActionGuidance(originalInfo, changedInfo, changingLines);

      // 判断吉凶和时机
      const timingAnalysis = this.analyzeTimingAndLuck(originalInfo, changedInfo, time_frame);

      // 针对选项进行分析
      const optionAnalysis = (options && options.length > 0)
        ? this.analyzeOptions(options, originalInfo, changedInfo)
        : null;

      // 生成个性化建议
      const personalizedAdvice = this.generatePersonalizedAdvice(
        question,
        actionGuidance,
        timingAnalysis,
        optionAnalysis
      );

      const result = {
        timestamp: new Date().toISOString(),
        question: question,
        time_frame: time_frame,
        overall_guidance: actionGuidance,
        timing_analysis: timingAnalysis,
        option_analysis: optionAnalysis,
        recommendations: personalizedAdvice,
        cautions: this.generateCautions(originalInfo, changedInfo),
        follow_up_suggestions: this.generateFollowUpSuggestions(originalInfo, question)
      };

      this.logger.info('决策建议生成成功');
      return result;
    } catch (error) {
      this.logger.error('决策建议生成失败', { error: error.message });
      throw error;
    }
  }

  /**
   * 确定卦象
   * @param {Array} lineTypes - 爻类型数组
   * @returns {Object} 卦象信息
   */
  determineHexagram(lineTypes) {
    // 将爻类型转换为二进制（阳爻=1，阴爻=0）
    const binary = lineTypes.map(type => type === 'yang' ? 1 : 0).join('');

    // 根据二进制确定卦序，限制在1-8范围内（当前数据库只有8个卦象）
    const binaryValue = parseInt(binary, 2);
    const hexagramId = (binaryValue % 8) + 1; // 确保ID在1-8范围内

    return {
      id: hexagramId,
      binary: binary,
      lines: lineTypes
    };
  }

  /**
   * 计算变卦
   * @param {Object} originalHexagram - 本卦
   * @param {Array} changingLines - 变爻位置
   * @returns {Object} 变卦信息
   */
  calculateChangedHexagram(originalHexagram, changingLines) {
    const newLines = [...originalHexagram.lines];

    // 变换指定位置的爻
    changingLines.forEach(position => {
      const index = position - 1; // 转换为数组索引
      newLines[index] = newLines[index] === 'yang' ? 'yin' : 'yang';
    });

    return this.determineHexagram(newLines);
  }

  /**
   * 整体卦象解读
   */
  interpretOverall(originalInfo, changedInfo, context, detailLevel) {
    const interpretation = {
      hexagram_meaning: originalInfo.meaning,
      judgment: originalInfo.judgment,
      image: originalInfo.image,
      context_application: this.applyToContext(originalInfo, context),
      energy_analysis: this.analyzeEnergy(originalInfo),
      development_trend: changedInfo ? this.analyzeTrend(originalInfo, changedInfo) : null
    };

    if (detailLevel === 'detailed') {
      interpretation.detailed_analysis = {
        upper_trigram: originalInfo.upper_trigram,
        lower_trigram: originalInfo.lower_trigram,
        trigram_interaction: this.analyzeTrigramInteraction(originalInfo),
        five_elements: this.analyzeFiveElements(originalInfo),
        historical_references: originalInfo.historical_cases || []
      };
    }

    return interpretation;
  }

  /**
   * 特定爻位解读
   */
  interpretSpecificLine(hexagramInfo, lineNumber, context, detailLevel) {
    const line = hexagramInfo.lines[lineNumber - 1];

    return {
      line_position: lineNumber,
      line_type: line.type,
      line_text: line.text,
      line_meaning: line.meaning,
      position_significance: this.getPositionSignificance(lineNumber),
      context_application: this.applyLineToContext(line, context),
      action_guidance: line.action_guidance || '根据爻辞指导行动',
      timing_indication: line.timing || '适宜时机的判断'
    };
  }

  /**
   * 变卦解读
   */
  interpretChanging(originalInfo, changedInfo, changingLines, context, detailLevel) {
    return {
      transformation_meaning: `从${originalInfo.name}变为${changedInfo.name}`,
      change_significance: this.analyzeChangeSignificance(originalInfo, changedInfo),
      changing_lines_analysis: changingLines.map(line => ({
        position: line,
        significance: this.getLineChangeSignificance(originalInfo, line)
      })),
      development_direction: this.analyzeDevelopmentDirection(originalInfo, changedInfo),
      timing_of_change: this.analyzeChangeTimimg(changingLines),
      context_implications: this.analyzeChangeInContext(originalInfo, changedInfo, context)
    };
  }

  /**
   * 生成解读提示
   */
  generateInterpretationHint(originalInfo, changedInfo, question) {
    const hints = [
      `本卦${originalInfo?.name || ''}代表当前状况`,
      question.includes('事业') || question.includes('工作') ? '建议从事业角度解读' : null,
      question.includes('感情') || question.includes('关系') ? '建议从人际关系角度解读' : null,
      changedInfo ? `变卦${changedInfo.name}显示未来发展趋势` : '无变爻，当前状态相对稳定'
    ].filter(Boolean);

    return hints.join('；');
  }

  /**
   * 生成实用指导
   */
  generatePracticalGuidance(interpretation, context) {
    const guidance = {
      immediate_actions: [],
      things_to_avoid: [],
      optimal_timing: '',
      long_term_strategy: ''
    };

    // 根据上下文和解读结果生成具体指导
    switch (context) {
      case 'career':
        guidance.immediate_actions = ['专注当前工作', '寻求合作机会', '提升专业技能'];
        guidance.things_to_avoid = ['冒险投资', '频繁跳槽', '与同事冲突'];
        break;
      case 'relationship':
        guidance.immediate_actions = ['真诚沟通', '理解包容', '共同成长'];
        guidance.things_to_avoid = ['争吵冲突', '猜疑不信', '过度依赖'];
        break;
      case 'health':
        guidance.immediate_actions = ['规律作息', '适度运动', '心态平和'];
        guidance.things_to_avoid = ['过度劳累', '情绪波动', '忽视身体信号'];
        break;
      case 'finance':
        guidance.immediate_actions = ['谨慎理财', '稳健投资', '开源节流'];
        guidance.things_to_avoid = ['投机取巧', '盲目跟风', '过度消费'];
        break;
      default:
        guidance.immediate_actions = ['顺应自然', '把握时机', '积极行动'];
        guidance.things_to_avoid = ['急躁冒进', '消极等待', '违背原则'];
    }

    return guidance;
  }

  /**
   * 获取文化背景
   */
  getCulturalContext(hexagramInfo, context) {
    return {
      philosophical_background: '易经作为中华文化瑰宝，体现了阴阳变化的哲学思想',
      historical_significance: hexagramInfo.historical_background || '此卦在历史上的重要意义',
      modern_application: '将古老智慧应用于现代生活决策',
      cultural_values: ['和谐平衡', '顺应自然', '自强不息', '厚德载物']
    };
  }

  /**
   * 分析行动指导
   */
  analyzeActionGuidance(originalInfo, changedInfo, changingLines = []) {
    return {
      primary_guidance: originalInfo.action_guidance || '根据卦象指导行动',
      secondary_guidance: changedInfo?.action_guidance || null,
      change_guidance: (changingLines && changingLines.length > 0) ? '注意变化时机，适时调整策略' : '保持当前方向',
      energy_direction: this.determineEnergyDirection(originalInfo, changedInfo)
    };
  }

  /**
   * 分析时机和吉凶
   */
  analyzeTimingAndLuck(originalInfo, changedInfo, timeFrame) {
    return {
      current_luck: originalInfo.luck_indication || 'neutral',
      future_trend: changedInfo ? this.compareLuck(originalInfo, changedInfo) : 'stable',
      optimal_timing: this.determineOptimalTiming(originalInfo, timeFrame),
      caution_periods: this.identifyCautionPeriods(originalInfo, changedInfo),
      opportunity_windows: this.identifyOpportunities(originalInfo, changedInfo)
    };
  }

  /**
   * 分析选项
   */
  analyzeOptions(options, originalInfo, changedInfo) {
    return options.map((option, index) => ({
      option: option,
      compatibility: this.assessOptionCompatibility(option, originalInfo),
      recommendation_level: this.getRecommendationLevel(option, originalInfo, changedInfo),
      potential_outcomes: this.predictOutcomes(option, originalInfo, changedInfo),
      timing_advice: this.getTimingAdviceForOption(option, originalInfo)
    }));
  }

  /**
   * 生成个性化建议
   */
  generatePersonalizedAdvice(question, actionGuidance, timingAnalysis, optionAnalysis) {
    const advice = {
      primary_recommendation: actionGuidance.primary_guidance,
      timing_recommendation: timingAnalysis.optimal_timing,
      strategic_approach: this.generateStrategicApproach(question, actionGuidance),
      risk_management: this.generateRiskManagement(timingAnalysis),
      success_factors: this.identifySuccessFactors(actionGuidance, timingAnalysis)
    };

    if (optionAnalysis) {
      advice.option_ranking = optionAnalysis
        .sort((a, b) => b.recommendation_level - a.recommendation_level)
        .map(opt => opt.option);
    }

    return advice;
  }

  /**
   * 生成注意事项
   */
  generateCautions(originalInfo, changedInfo) {
    const cautions = [
      '易经解读仅供参考，最终决策需结合实际情况',
      '保持理性思考，避免过度依赖占卜结果'
    ];

    if (originalInfo.cautions) {
      cautions.push(...originalInfo.cautions);
    }

    if (changedInfo && changedInfo.cautions) {
      cautions.push(`变卦提醒：${changedInfo.cautions}`);
    }

    return cautions;
  }

  /**
   * 生成后续建议
   */
  generateFollowUpSuggestions(originalInfo, question) {
    return [
      '可以在重要决策前再次求卦确认',
      '建议学习相关卦象的深层含义',
      '关注事态发展，适时调整策略',
      '保持内心平静，以智慧应对变化'
    ];
  }

  // 辅助方法（简化实现）
  applyToContext(hexagramInfo, context) {
    return `在${context}方面，${hexagramInfo.name}卦提示...`;
  }

  analyzeEnergy(hexagramInfo) {
    return {
      overall_energy: hexagramInfo.energy || 'balanced',
      yin_yang_balance: 'harmonious',
      movement_tendency: 'progressive'
    };
  }

  analyzeTrend(originalInfo, changedInfo) {
    return `从${originalInfo.name}到${changedInfo.name}的发展趋势`;
  }

  analyzeTrigramInteraction(hexagramInfo) {
    return '上下卦的相互作用分析';
  }

  analyzeFiveElements(hexagramInfo) {
    return {
      primary_element: hexagramInfo.primary_element || 'earth',
      element_balance: 'harmonious',
      seasonal_correspondence: 'spring'
    };
  }

  getPositionSignificance(lineNumber) {
    const positions = {
      1: '初爻：事物开始阶段',
      2: '二爻：发展阶段',
      3: '三爻：转折阶段',
      4: '四爻：上升阶段',
      5: '五爻：成功阶段',
      6: '六爻：完成阶段'
    };
    return positions[lineNumber] || '未知位置';
  }

  applyLineToContext(line, context) {
    return `在${context}方面，此爻提示...`;
  }

  analyzeChangeSignificance(originalInfo, changedInfo) {
    return `变化的重要意义：从${originalInfo.nature}转向${changedInfo.nature}`;
  }

  getLineChangeSignificance(hexagramInfo, linePosition) {
    return `第${linePosition}爻变化的意义`;
  }

  analyzeDevelopmentDirection(originalInfo, changedInfo) {
    return `发展方向：向${changedInfo.nature}发展`;
  }

  analyzeChangeTimimg(changingLines) {
    return `变化时机：${changingLines.length}个变爻显示变化程度`;
  }

  analyzeChangeInContext(originalInfo, changedInfo, context) {
    return `在${context}方面的变化含义`;
  }

  determineEnergyDirection(originalInfo, changedInfo) {
    return changedInfo ? 'transforming' : 'stable';
  }

  compareLuck(originalInfo, changedInfo) {
    return 'improving'; // 简化实现
  }

  determineOptimalTiming(hexagramInfo, timeFrame) {
    return `在${timeFrame}时间框架内的最佳时机`;
  }

  identifyCautionPeriods(originalInfo, changedInfo) {
    return ['需要谨慎的时期'];
  }

  identifyOpportunities(originalInfo, changedInfo) {
    return ['机会窗口期'];
  }

  assessOptionCompatibility(option, hexagramInfo) {
    return 'high'; // 简化实现
  }

  getRecommendationLevel(option, originalInfo, changedInfo) {
    return Math.random() * 10; // 简化实现
  }

  predictOutcomes(option, originalInfo, changedInfo) {
    return ['可能的结果1', '可能的结果2'];
  }

  getTimingAdviceForOption(option, hexagramInfo) {
    return '时机建议';
  }

  generateStrategicApproach(question, actionGuidance) {
    return '战略方法建议';
  }

  generateRiskManagement(timingAnalysis) {
    return '风险管理建议';
  }

  identifySuccessFactors(actionGuidance, timingAnalysis) {
    return ['成功因素1', '成功因素2'];
  }
}

module.exports = YijingEngine;