ziwei-cli 1.1.0

package/lib/commands/palace.js

@@ -0,0 +1,156 @@
+/**
+ * 宫位查询命令
+ * 支持本命/大限/流年/流月/流日各层级的三方四正查询
+ */
+
+import { generateAstrolabe, formatPalace, formatSurroundedPalaces, getAstrolabeBasicInfo, getScopePalaces } from '../engine/astrolabe.js';
+import { detectPatterns } from '../engine/patterns.js';
+
+/**
+ * 构建查询日期字符串
+ */
+function buildQueryDate(year, month = 1, day = 1) {
+  const m = String(month).padStart(2, '0');
+  const d = String(day).padStart(2, '0');
+  return `${year}-${m}-${d}`;
+}
+
+/**
+ * 获取指定层级的宫位及三方四正
+ */
+function getScopedPalaceAndSurrounded(astrolabe, palaceName, scope, queryDate) {
+  if (scope === 'origin') {
+    // 本命层直接从 astrolabe 获取
+    const targetPalace = astrolabe.palace(palaceName);
+    const surroundedPalaces = astrolabe.surroundedPalaces(palaceName);
+    return { targetPalace, surroundedPalaces, scopeData: {} };
+  } else {
+    // 运限层从 horoscope 获取
+    const horoscope = astrolabe.horoscope(queryDate);
+    const scopeData = horoscope[scope];
+
+    if (!scopeData) {
+      throw new Error(`无效的运限范围: ${scope}`);
+    }
+
+    const targetPalace = horoscope.palace(palaceName, scope);
+    const surroundedPalaces = horoscope.surroundPalaces(palaceName, scope);
+
+    return { targetPalace, surroundedPalaces, scopeData };
+  }
+}
+
+/**
+ * 执行宫位查询
+ * @param {Object} options - 命令选项
+ * @returns {Object} 查询结果 (JSON)
+ */
+export async function executePalace(options) {
+  const { date, time, gender, city, palace, lunar, leap, scope = 'origin', year, month, day } = options;
+
+  try {
+    // 验证必需参数
+    if (!date || !time || !gender || !city || !palace) {
+      return {
+        success: false,
+        error: '缺少必需参数: date, time, gender, city, palace'
+      };
+    }
+
+    // 验证运限层级所需的额外参数
+    if (scope !== 'origin' && !year) {
+      return {
+        success: false,
+        error: `${scope} 层级需要指定 year 参数`
+      };
+    }
+    if ((scope === 'monthly' || scope === 'daily') && !month) {
+      return {
+        success: false,
+        error: `${scope} 层级需要指定 month 参数`
+      };
+    }
+    if (scope === 'daily' && !day) {
+      return {
+        success: false,
+        error: 'daily 层级需要指定 day 参数'
+      };
+    }
+
+    // 生成星盘
+    const astrolabe = await generateAstrolabe({
+      birth_date: date,
+      time: time,
+      gender: gender,
+      city: city,
+      is_lunar: lunar || false,
+      is_leap: leap || false
+    });
+
+    // 获取目标宫位名称
+    // origin 模式需要带"宫"字，horoscope 模式不需要
+    const palaceNameWithSuffix = palace.replace(/宫$/, '') + '宫';
+    const palaceNameWithoutSuffix = palace.replace(/宫$/, '');
+    const targetPalaceName = scope === 'origin' ? palaceNameWithSuffix : palaceNameWithoutSuffix;
+
+    // 构建查询日期
+    const queryDate = scope !== 'origin' ? buildQueryDate(year, month || 1, day || 1) : null;
+
+    // 获取目标宫位和三方四正
+    const { targetPalace, surroundedPalaces, scopeData } = getScopedPalaceAndSurrounded(
+      astrolabe, targetPalaceName, scope, queryDate
+    );
+
+    if (!targetPalace) {
+      return {
+        success: false,
+        error: `未找到宫位: ${palace}`
+      };
+    }
+
+    // 检测格局
+    let patterns;
+    if (scope === 'origin') {
+      patterns = detectPatterns(astrolabe);
+    } else {
+      const horoscope = astrolabe.horoscope(queryDate);
+      patterns = detectPatterns(horoscope, scope);
+    }
+
+    // 构建结果
+    const result = {
+      success: true,
+      data: {
+        basic_info: getAstrolabeBasicInfo(astrolabe),
+        scope: scope,
+        target_palace: formatPalace(targetPalace, scopeData, scope),
+        surrounded_palaces: formatSurroundedPalaces(surroundedPalaces, scopeData, scope),
+        patterns: patterns.map(p => ({
+          title: p.title,
+          blurb: p.blurb,
+          reason: p.reason
+        }))
+      }
+    };
+
+    // 添加查询时间信息
+    if (scope !== 'origin') {
+      result.data.query_year = year;
+      if (month) result.data.query_month = month;
+      if (day) result.data.query_day = day;
+
+      // 添加该层级的四化信息
+      if (scopeData.mutagen) {
+        result.data.mutagen = scopeData.mutagen;
+      }
+    }
+
+    return result;
+
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}

package/lib/commands/synastry.js

@@ -0,0 +1,124 @@
+/**
+ * 合盘分析命令
+ */
+
+import { analyzeSynastryByUserInfo } from '../engine/synastry.js';
+
+/**
+ * 执行本命合盘分析
+ */
+export async function executeSynastry(options) {
+  const {
+    aDate, aTime, aGender, aCity, aName,
+    bDate, bTime, bGender, bCity, bName,
+    aLunar, aLeap, bLunar, bLeap
+  } = options;
+
+  try {
+    // 验证必需参数
+    if (!aDate || !aTime || !aGender || !aCity) {
+      return {
+        success: false,
+        error: '缺少A方必需参数: a-date, a-time, a-gender, a-city'
+      };
+    }
+    if (!bDate || !bTime || !bGender || !bCity) {
+      return {
+        success: false,
+        error: '缺少B方必需参数: b-date, b-time, b-gender, b-city'
+      };
+    }
+
+    const result = await analyzeSynastryByUserInfo({
+      birth_date_a: aDate,
+      birth_time_a: aTime,
+      gender_a: aGender,
+      city_a: aCity,
+      name_a: aName || 'A',
+      birth_date_b: bDate,
+      birth_time_b: bTime,
+      gender_b: bGender,
+      city_b: bCity,
+      name_b: bName || 'B',
+      is_lunar_a: aLunar || false,
+      is_leap_a: aLeap || false,
+      is_lunar_b: bLunar || false,
+      is_leap_b: bLeap || false,
+      scope: 'origin'
+    });
+
+    return result;
+
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * 执行流年合盘分析
+ */
+export async function executeSynastryYearly(options) {
+  const {
+    aDate, aTime, aGender, aCity, aName,
+    bDate, bTime, bGender, bCity, bName,
+    aLunar, aLeap, bLunar, bLeap,
+    year
+  } = options;
+
+  try {
+    if (!aDate || !aTime || !aGender || !aCity) {
+      return {
+        success: false,
+        error: '缺少A方必需参数: a-date, a-time, a-gender, a-city'
+      };
+    }
+    if (!bDate || !bTime || !bGender || !bCity) {
+      return {
+        success: false,
+        error: '缺少B方必需参数: b-date, b-time, b-gender, b-city'
+      };
+    }
+    if (!year) {
+      return {
+        success: false,
+        error: '缺少年份参数: year'
+      };
+    }
+
+    const queryDate = `${year}-01-01`;
+
+    const result = await analyzeSynastryByUserInfo({
+      birth_date_a: aDate,
+      birth_time_a: aTime,
+      gender_a: aGender,
+      city_a: aCity,
+      name_a: aName || 'A',
+      birth_date_b: bDate,
+      birth_time_b: bTime,
+      gender_b: bGender,
+      city_b: bCity,
+      name_b: bName || 'B',
+      is_lunar_a: aLunar || false,
+      is_leap_a: aLeap || false,
+      is_lunar_b: bLunar || false,
+      is_leap_b: bLeap || false,
+      scope: 'yearly',
+      query_date: queryDate
+    });
+
+    if (result.success) {
+      result.data.query_year = year;
+    }
+
+    return result;
+
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}

package/lib/engine/astrolabe.js

@@ -0,0 +1,216 @@
+/**
+ * 星盘生成模块
+ * 封装 iztro 库，提供命盘生成和格式化功能
+ */
+
+import { lookupCity } from './geo.js';
+import { getSolarTime, getTimeIndex } from './solar.js';
+import { starsTypeMapping, scopeMapping, MUTAGENS_MAPPING, PALACE_NAMES } from './config.js';
+
+let astroClient;
+
+/**
+ * 获取 iztro 客户端
+ */
+async function getAstroClient() {
+  if (!astroClient) {
+    const { astro } = await import('iztro');
+    astro.config({ yearDivide: 'normal' });
+    astroClient = astro;
+  }
+  return astroClient;
+}
+
+/**
+ * 生成星盘
+ * @param {Object} params - 参数对象
+ * @param {string} params.birth_date - 出生日期 (YYYY-MM-DD)
+ * @param {string} params.time - 出生时间 (HH:mm)
+ * @param {string} params.gender - 性别 ("男"/"女")
+ * @param {string} params.city - 出生城市
+ * @param {boolean} params.is_lunar - 是否农历 (默认false)
+ * @param {boolean} params.is_leap - 是否闰月 (默认false)
+ * @returns {Object} iztro 星盘对象
+ */
+export async function generateAstrolabe({ birth_date, time, gender, city, is_lunar = false, is_leap = false }) {
+  try {
+    const astro = await getAstroClient();
+    const [hour, minute] = time.split(':').map(Number);
+
+    // 获取城市坐标
+    const locationResult = lookupCity(city);
+    if (!locationResult.success) {
+      throw new Error(`城市查询失败: ${locationResult.error}`);
+    }
+    const coordinates = {
+      lat: locationResult.data.latitude,
+      lng: locationResult.data.longitude
+    };
+
+    // 解析日期
+    let dateParts;
+    if (is_lunar) {
+      const tempAstrolabe = astro.byLunar(birth_date, 0, gender, is_leap, true, 'zh-CN');
+      const [year, month, day] = tempAstrolabe.solarDate.split('-').map(Number);
+      dateParts = { year, month, day };
+    } else {
+      const [year, month, day] = birth_date.split('-').map(Number);
+      dateParts = { year, month, day };
+    }
+
+    // 计算真太阳时
+    const solarTimeResult = getSolarTime({
+      dateTime: { ...dateParts, hour, minute, second: 0 },
+      longitude: coordinates.lng,
+      latitude: coordinates.lat
+    });
+
+    let timeIndex;
+    if (solarTimeResult.success) {
+      const trueSolarTime = solarTimeResult.data.trueSolarTime;
+      timeIndex = getTimeIndex(trueSolarTime.hour, trueSolarTime.minute);
+    } else {
+      timeIndex = getTimeIndex(hour, minute);
+    }
+
+    // 生成星盘
+    const astrolabe = is_lunar
+      ? astro.byLunar(birth_date, timeIndex, gender, is_leap, true, 'zh-CN')
+      : astro.bySolar(birth_date, timeIndex, gender, is_leap, 'zh-CN');
+
+    return astrolabe;
+  } catch (error) {
+    throw new Error(`星盘生成失败: ${error.message}`);
+  }
+}
+
+/**
+ * 格式化宫位信息
+ */
+export function formatPalace(palace, horoscope = {}, scope = 'origin') {
+  const ret = {
+    "宫位索引": palace.index,
+    "宫位名称": horoscope?.palaceNames?.[palace.index] || palace.name,
+    "是否身宫": palace.isBodyPalace,
+    "是否本宫": palace.isOriginalPalace,
+    "天干": palace.heavenlyStem,
+    "地支": palace.earthlyBranch,
+    "主星": palace.majorStars?.map(star => ({
+      "星曜名称": star.name,
+      "星曜类型": starsTypeMapping(star.type),
+      "作用范围": scopeMapping(star.scope),
+      "亮度": star.brightness || "无",
+      "本命盘四化": star.mutagen ? star.name + '化' + star.mutagen : "无"
+    })) || [],
+    "辅星": palace.minorStars?.map(star => ({
+      "星曜名称": star.name,
+      "星曜类型": starsTypeMapping(star.type),
+      "作用范围": scopeMapping(star.scope),
+      "亮度": star.brightness || "无"
+    })) || [],
+    "杂曜": palace.adjectiveStars?.map(star => ({
+      "星曜名称": star.name,
+      "星曜类型": starsTypeMapping(star.type),
+      "作用范围": scopeMapping(star.scope)
+    })) || [],
+  };
+
+  if (scope === 'origin') {
+    ret["长生十二神"] = palace.changsheng12 || "无";
+    ret["博士十二神"] = palace.boshi12 || "无";
+  } else {
+    ret["将前十二神"] = palace.jiangqian12 || "无";
+    ret["岁前十二神"] = palace.suiqian12 || "无";
+  }
+
+  if (scope === 'decadal') {
+    ret["运耀"] = horoscope.stars?.[palace.index]?.map(star => ({
+      "星曜名称": star.name,
+      "星曜类型": starsTypeMapping(star.type),
+      "作用范围": scopeMapping(star.scope),
+      "亮度": star.brightness || "无",
+      "运耀四化": star.mutagen ? star.name + '化' + star.mutagen : "无"
+    })) || [];
+
+    ret["大限飞星四化"] = horoscope.mutagen?.reduce((acc, mutagen, i) => {
+      if (palace.majorStars?.some(star => star.name === mutagen)) {
+        acc.push(mutagen + '化' + MUTAGENS_MAPPING[i]);
+      }
+      return acc;
+    }, []) || [];
+
+    if (palace.index === horoscope.index) {
+      ret["大限年龄范围"] = palace.decadal?.range || [];
+    }
+  }
+
+  if (scope === 'yearly') {
+    ret["流曜"] = horoscope.stars?.[palace.index]?.map(star => ({
+      "星曜名称": star.name,
+      "星曜类型": starsTypeMapping(star.type),
+      "作用范围": scopeMapping(star.scope),
+      "亮度": star.brightness || "无",
+      "流曜四化": star.mutagen ? star.name + '化' + star.mutagen : "无"
+    })) || [];
+
+    ret["流年飞星四化"] = horoscope.mutagen?.reduce((acc, mutagen, i) => {
+      if (palace.majorStars?.some(star => star.name === mutagen)) {
+        acc.push(mutagen + '化' + MUTAGENS_MAPPING[i]);
+      }
+      return acc;
+    }, []) || [];
+  }
+
+  return ret;
+}
+
+/**
+ * 获取指定运限范围内的十二宫信息数组
+ */
+export function getScopePalaces(horoscope, scope) {
+  if (!horoscope || typeof horoscope.palace !== 'function') {
+    throw new Error('无效的运限对象：缺少宫位查询能力');
+  }
+
+  return horoscope[scope].palaceNames.map(name => {
+    const palace = horoscope.palace(name, scope);
+    if (!palace) {
+      throw new Error(`未能获取「${name}」的运限宫位信息`);
+    }
+    palace.name = horoscope[scope].palaceNames[palace.index];
+    return palace;
+  });
+}
+
+/**
+ * 格式化三方四正宫位信息
+ */
+export function formatSurroundedPalaces(surroundedPalaces, horoscope = {}, scope = 'origin') {
+  return {
+    "对宫": formatPalace(surroundedPalaces.opposite, horoscope, scope),
+    "三方": {
+      "三合宫之一": formatPalace(surroundedPalaces.wealth, horoscope, scope),
+      "三合宫之二": formatPalace(surroundedPalaces.career, horoscope, scope),
+    },
+  };
+}
+
+/**
+ * 获取星盘基本信息
+ */
+export function getAstrolabeBasicInfo(astrolabe) {
+  return {
+    "阳历日期": astrolabe.solarDate,
+    "农历日期": astrolabe.lunarDate,
+    "四柱": astrolabe.chineseDate,
+    "时辰": astrolabe.time,
+    "时辰对应时间段": astrolabe.timeRange,
+    "星座": astrolabe.sign,
+    "生肖": astrolabe.zodiac,
+    "命宫地支": astrolabe.earthlyBranchOfSoulPalace,
+    "身宫地支": astrolabe.earthlyBranchOfBodyPalace,
+    "命主": astrolabe.soul,
+    "身主": astrolabe.body,
+    "五行局": astrolabe.fiveElementsClass
+  };
+}

package/lib/engine/bazi.js

@@ -0,0 +1,207 @@
+/**
+ * 八字计算引擎
+ * 基于 tyme4ts 和 cantian-tymext 库
+ */
+
+import { calculateRelation, getShen } from 'cantian-tymext';
+import {
+  ChildLimit,
+  DefaultEightCharProvider,
+  LunarHour,
+  LunarSect2EightCharProvider,
+  SolarTime,
+} from 'tyme4ts';
+
+const eightCharProvider1 = new DefaultEightCharProvider();
+const eightCharProvider2 = new LunarSect2EightCharProvider();
+
+/**
+ * 构建藏干对象
+ */
+function buildHideHeavenObject(heavenStem, me) {
+  if (!heavenStem) return undefined;
+  return {
+    天干: heavenStem.toString(),
+    十神: me.getTenStar(heavenStem).toString(),
+  };
+}
+
+/**
+ * 构建六十甲子柱对象（年柱/月柱/日柱/时柱）
+ */
+function buildSixtyCycleObject(sixtyCycle, me) {
+  const heavenStem = sixtyCycle.getHeavenStem();
+  const earthBranch = sixtyCycle.getEarthBranch();
+  if (!me) me = heavenStem;
+
+  return {
+    天干: {
+      天干: heavenStem.toString(),
+      五行: heavenStem.getElement().toString(),
+      阴阳: heavenStem.getYinYang() === 1 ? '阳' : '阴',
+      十神: me === heavenStem ? undefined : me.getTenStar(heavenStem).toString(),
+    },
+    地支: {
+      地支: earthBranch.toString(),
+      五行: earthBranch.getElement().toString(),
+      阴阳: earthBranch.getYinYang() === 1 ? '阳' : '阴',
+      藏干: {
+        主气: buildHideHeavenObject(earthBranch.getHideHeavenStemMain(), me),
+        中气: buildHideHeavenObject(earthBranch.getHideHeavenStemMiddle(), me),
+        余气: buildHideHeavenObject(earthBranch.getHideHeavenStemResidual(), me),
+      },
+    },
+    纳音: sixtyCycle.getSound().toString(),
+    旬: sixtyCycle.getTen().toString(),
+    空亡: sixtyCycle.getExtraEarthBranches().join(''),
+    星运: me.getTerrain(earthBranch).toString(),
+    自坐: heavenStem.getTerrain(earthBranch).toString(),
+  };
+}
+
+/**
+ * 构建神煞对象
+ */
+function buildGodsObject(eightChar, gender) {
+  const gods = getShen(eightChar.toString(), gender);
+  return {
+    年柱: gods[0],
+    月柱: gods[1],
+    日柱: gods[2],
+    时柱: gods[3],
+  };
+}
+
+/**
+ * 构建大运排盘
+ */
+function buildDecadeFortuneObject(solarTime, gender, me) {
+  const childLimit = ChildLimit.fromSolarTime(solarTime, gender);
+  let decadeFortune = childLimit.getStartDecadeFortune();
+  const firstStartAge = decadeFortune.getStartAge();
+  const startDate = childLimit.getEndTime();
+  const decadeFortuneObjects = [];
+
+  for (let i = 0; i < 10; i++) {
+    const sixtyCycle = decadeFortune.getSixtyCycle();
+    const heavenStem = sixtyCycle.getHeavenStem();
+    const earthBranch = sixtyCycle.getEarthBranch();
+    decadeFortuneObjects.push({
+      干支: sixtyCycle.toString(),
+      开始年份: decadeFortune.getStartSixtyCycleYear().getYear(),
+      结束年份: decadeFortune.getEndSixtyCycleYear().getYear(),
+      天干十神: me.getTenStar(heavenStem).getName(),
+      地支十神: earthBranch.getHideHeavenStems().map((hs) => me.getTenStar(hs.getHeavenStem()).getName()),
+      地支藏干: earthBranch.getHideHeavenStems().map((hs) => hs.toString()),
+      开始年龄: decadeFortune.getStartAge(),
+      结束年龄: decadeFortune.getEndAge(),
+    });
+    decadeFortune = decadeFortune.next(1);
+  }
+
+  return {
+    起运日期: `${startDate.getYear()}-${startDate.getMonth()}-${startDate.getDay()}`,
+    起运年龄: firstStartAge,
+    大运: decadeFortuneObjects,
+  };
+}
+
+/**
+ * 生成完整八字排盘
+ * @param {Object} options
+ * @param {string} options.date - 出生日期 YYYY-MM-DD
+ * @param {string} options.time - 出生时间 HH:MM
+ * @param {string} options.gender - 性别 "男"/"女"
+ * @param {boolean} [options.lunar] - 是否农历
+ * @param {number} [options.sect] - 早晚子时配置 1或2，默认2
+ */
+export function generateBazi({ date, time, gender, lunar = false, sect = 2 }) {
+  const [hour, minute] = time.split(':').map(Number);
+  const genderNum = gender === '男' ? 1 : 0;
+
+  let lunarHour;
+
+  if (lunar) {
+    // 农历输入
+    const [year, month, day] = date.split('-').map(Number);
+    lunarHour = LunarHour.fromYmdHms(year, month, day, hour, minute, 0);
+  } else {
+    // 阳历输入
+    const [year, month, day] = date.split('-').map(Number);
+    const solarTime = SolarTime.fromYmdHms(year, month, day, hour, minute, 0);
+    lunarHour = solarTime.getLunarHour();
+  }
+
+  // 设置子时配置
+  if (sect === 2) {
+    LunarHour.provider = eightCharProvider2;
+  } else {
+    LunarHour.provider = eightCharProvider1;
+  }
+
+  const eightChar = lunarHour.getEightChar();
+  const me = eightChar.getDay().getHeavenStem();
+  const solarTime = lunarHour.getSolarTime();
+
+  return {
+    性别: gender,
+    阳历: solarTime.toString(),
+    农历: lunarHour.toString(),
+    八字: eightChar.toString(),
+    生肖: eightChar.getYear().getEarthBranch().getZodiac().toString(),
+    日主: me.toString(),
+    年柱: buildSixtyCycleObject(eightChar.getYear(), me),
+    月柱: buildSixtyCycleObject(eightChar.getMonth(), me),
+    日柱: buildSixtyCycleObject(eightChar.getDay()),
+    时柱: buildSixtyCycleObject(eightChar.getHour(), me),
+    胎元: eightChar.getFetalOrigin().toString(),
+    胎息: eightChar.getFetalBreath().toString(),
+    命宫: eightChar.getOwnSign().toString(),
+    身宫: eightChar.getBodySign().toString(),
+    神煞: buildGodsObject(eightChar, genderNum),
+    大运: buildDecadeFortuneObject(solarTime, genderNum, me),
+    刑冲合会: calculateRelation({
+      年: { 天干: eightChar.getYear().getHeavenStem().toString(), 地支: eightChar.getYear().getEarthBranch().toString() },
+      月: { 天干: eightChar.getMonth().getHeavenStem().toString(), 地支: eightChar.getMonth().getEarthBranch().toString() },
+      日: { 天干: eightChar.getDay().getHeavenStem().toString(), 地支: eightChar.getDay().getEarthBranch().toString() },
+      时: { 天干: eightChar.getHour().getHeavenStem().toString(), 地支: eightChar.getHour().getEarthBranch().toString() },
+    }),
+  };
+}
+
+/**
+ * 获取黄历信息
+ * @param {string} [date] - 阳历日期 YYYY-MM-DD，不传则为当天
+ */
+export function getCalendar(date) {
+  let solarTime;
+  if (date) {
+    const [year, month, day] = date.split('-').map(Number);
+    solarTime = SolarTime.fromYmdHms(year, month, day, 12, 0, 0);
+  } else {
+    const now = new Date();
+    solarTime = SolarTime.fromYmdHms(
+      now.getFullYear(), now.getMonth() + 1, now.getDate(),
+      now.getHours(), now.getMinutes(), now.getSeconds()
+    );
+  }
+
+  const lunarHour = solarTime.getLunarHour();
+  const lunarDay = lunarHour.getLunarDay();
+  const eightChar = lunarHour.getEightChar();
+  const solarDay = solarTime.getSolarDay();
+
+  return {
+    公历: solarTime.toString().split(' ')[0],
+    农历: lunarDay.toString(),
+    干支: eightChar.toString().split(' ').slice(0, 3).join(' '),
+    年干支: eightChar.getYear().toString(),
+    月干支: eightChar.getMonth().toString(),
+    日干支: eightChar.getDay().toString(),
+    生肖: eightChar.getYear().getEarthBranch().getZodiac().toString(),
+    纳音: eightChar.getDay().getSound().toString(),
+    节气: solarDay.getTerm()?.toString() || '无节气',
+    农历节日: lunarDay.getFestival()?.toString() || undefined,
+    公历节日: solarDay.getFestival()?.toString() || undefined,
+  };
+}