mingpan 0.1.1 → 0.1.2

package/dist/index.js

@@ -17,8 +17,15 @@ const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const zod_1 = require("zod");
 const zod_to_json_schema_1 = require("zod-to-json-schema");
 const lunar_javascript_1 = require("lunar-javascript");
+const timeNormalization_1 = require("./utils/timeNormalization");
 const BaziService_1 = require("./services/bazi/BaziService");
 const ZiweiService_1 = require("./services/ziwei/ZiweiService");
+const LiuyaoService_1 = require("./services/liuyao/LiuyaoService");
+const liuyaoTextRenderer_1 = require("./output/liuyaoTextRenderer");
+const MeihuaService_1 = require("./services/meihua/MeihuaService");
+const meihuaTextRenderer_1 = require("./output/meihuaTextRenderer");
+const DaliurenService_1 = require("./services/daliuren/DaliurenService");
+const daliurenTextRenderer_1 = require("./output/daliurenTextRenderer");
 const LiuNianCalculator_1 = require("./services/bazi/calculators/LiuNianCalculator");
 const DaYunCalculator_1 = require("./services/bazi/calculators/DaYunCalculator");
 const LuckCycleCalculator_1 = require("./services/bazi/calculators/LuckCycleCalculator");
@@ -30,6 +37,14 @@ const listTextRenderer_1 = require("./output/listTextRenderer");
 const logger_1 = require("./shared/logger");
 const MutagenCore_1 = require("./core/ziwei/MutagenCore");
 const logger = new logger_1.Logger("mingpan");
+// ============================================
+// Timezone Configuration
+// ============================================
+// Force deterministic timezone behavior (Beijing Time) across environments.
+// This ensures lunar-javascript and Date operations behave consistently
+// regardless of the host machine's timezone setting.
+// TODO: Remove when multi-timezone support is implemented (M4 milestone)
+process.env.TZ = timeNormalization_1.BEIJING_TZ;
 // Helper to avoid TypeScript's excessively deep type instantiation error
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function schemaToJson(schema) {
@@ -38,6 +53,8 @@ function schemaToJson(schema) {
 // ============================================
 // Zod Schemas for Tool Inputs
 // ============================================
+// isLunar field schema (reusable)
+const isLunarField = zod_1.z.boolean().optional().default(false).describe("Whether the input date is in lunar calendar (農曆). If true, will be converted to solar calendar internally.");
 // Base birth info schema
 const BaseBirthInfoSchema = zod_1.z.object({
     year: zod_1.z.number().int().min(1900).max(2100).describe("Birth year (e.g., 1990)"),
@@ -47,8 +64,33 @@ const BaseBirthInfoSchema = zod_1.z.object({
     minute: zod_1.z.number().int().min(0).max(59).optional().default(0).describe("Birth minute (0-59)"),
     gender: zod_1.z.enum(["male", "female"]).describe("Gender for fortune direction calculation"),
     longitude: zod_1.z.number().min(-180).max(180).optional().describe("Birth location longitude for true solar time adjustment"),
+    isLunar: isLunarField,
     name: zod_1.z.string().optional().describe("Subject name (optional)"),
 });
+/**
+ * Normalize birth info: handle lunar-to-solar conversion
+ * Call this at the start of each handler to get consistent, normalized values
+ */
+function normalizeBirthInfo(input) {
+    const normalized = (0, timeNormalization_1.normalizeBirthDateTime)({
+        year: input.year,
+        month: input.month,
+        day: input.day,
+        hour: input.hour,
+        minute: input.minute,
+        isLunar: input.isLunar,
+    });
+    return {
+        ...input,
+        year: normalized.year,
+        month: normalized.month,
+        day: normalized.day,
+        hour: normalized.hour,
+        minute: normalized.minute,
+        isLunar: false, // After normalization, always use solar calendar
+        _isLunarInput: normalized.isLunarInput,
+    };
+}
 const BaziCalculateSchema = zod_1.z.object({
     year: zod_1.z.number().int().min(1900).max(2100).describe("Birth year (e.g., 1990)"),
     month: zod_1.z.number().int().min(1).max(12).describe("Birth month (1-12)"),
@@ -57,7 +99,7 @@ const BaziCalculateSchema = zod_1.z.object({
     minute: zod_1.z.number().int().min(0).max(59).optional().default(0).describe("Birth minute (0-59)"),
     gender: zod_1.z.enum(["male", "female"]).optional().default("male").describe("Gender for DaYun calculation direction"),
     longitude: zod_1.z.number().min(-180).max(180).optional().describe("Birth location longitude for true solar time adjustment"),
-    isLunar: zod_1.z.boolean().optional().default(false).describe("Whether the birth date is in lunar calendar"),
+    isLunar: isLunarField,
     detail: zod_1.z.enum(["simple", "standard", "detailed"]).optional().default("standard").describe("Output detail level"),
     includeAnalysis: zod_1.z.boolean().optional().default(true).describe("Include strength and pattern analysis"),
     includeDaYun: zod_1.z.boolean().optional().default(true).describe("Include decade fortune (大運)"),
@@ -70,7 +112,7 @@ const ZiweiCalculateSchema = zod_1.z.object({
     hour: zod_1.z.number().int().min(0).max(23).describe("Birth hour in 24-hour format (0-23)"),
     minute: zod_1.z.number().int().min(0).max(59).optional().default(0).describe("Birth minute (0-59)"),
     gender: zod_1.z.enum(["male", "female"]).describe("Gender (required for ZiWei calculation)"),
-    isLunar: zod_1.z.boolean().optional().default(false).describe("Whether the birth date is in lunar calendar"),
+    isLunar: isLunarField,
     detail: zod_1.z.enum(["simple", "standard", "detailed"]).optional().default("standard").describe("Output detail level"),
     targetYear: zod_1.z.number().int().optional().describe("Calculate yearly fortune for this specific year"),
     includeDecades: zod_1.z.boolean().optional().default(true).describe("Include decade fortune (大限)"),
@@ -84,12 +126,56 @@ const CombinedCalculateSchema = zod_1.z.object({
     minute: zod_1.z.number().int().min(0).max(59).optional().default(0).describe("Birth minute (0-59)"),
     gender: zod_1.z.enum(["male", "female"]).describe("Gender (required for both calculations)"),
     longitude: zod_1.z.number().min(-180).max(180).optional().describe("Birth location longitude for true solar time adjustment"),
-    isLunar: zod_1.z.boolean().optional().default(false).describe("Whether the birth date is in lunar calendar"),
+    isLunar: isLunarField,
     detail: zod_1.z.enum(["simple", "standard", "detailed"]).optional().default("standard").describe("Output detail level"),
     targetYear: zod_1.z.number().int().optional().describe("Calculate yearly fortune for this specific year"),
     systems: zod_1.z.array(zod_1.z.enum(["bazi", "ziwei"])).optional().default(["bazi", "ziwei"]).describe("Which systems to calculate"),
 });
 // ============================================
+// 六爻 Schema
+// ============================================
+const LiuyaoBasicSchema = zod_1.z.object({
+    yaoValues: zod_1.z.tuple([
+        zod_1.z.union([zod_1.z.literal(6), zod_1.z.literal(7), zod_1.z.literal(8), zod_1.z.literal(9)]),
+        zod_1.z.union([zod_1.z.literal(6), zod_1.z.literal(7), zod_1.z.literal(8), zod_1.z.literal(9)]),
+        zod_1.z.union([zod_1.z.literal(6), zod_1.z.literal(7), zod_1.z.literal(8), zod_1.z.literal(9)]),
+        zod_1.z.union([zod_1.z.literal(6), zod_1.z.literal(7), zod_1.z.literal(8), zod_1.z.literal(9)]),
+        zod_1.z.union([zod_1.z.literal(6), zod_1.z.literal(7), zod_1.z.literal(8), zod_1.z.literal(9)]),
+        zod_1.z.union([zod_1.z.literal(6), zod_1.z.literal(7), zod_1.z.literal(8), zod_1.z.literal(9)]),
+    ]).describe("六個爻值（自下而上，初爻到上爻）。6=老陰(動), 7=少陽(靜), 8=少陰(靜), 9=老陽(動)"),
+    year: zod_1.z.number().int().min(1900).max(2100).describe("起卦年份（公曆）"),
+    month: zod_1.z.number().int().min(1).max(12).describe("起卦月份（1-12）"),
+    day: zod_1.z.number().int().min(1).max(31).describe("起卦日期（1-31）"),
+    hour: zod_1.z.number().int().min(0).max(23).describe("起卦時辰（0-23）"),
+    isLunar: isLunarField,
+});
+// ============================================
+// 梅花易數 Schema
+// ============================================
+const MeihuaBasicSchema = zod_1.z.object({
+    method: zod_1.z.enum(['time', 'number']).describe("起卦方式：time=時間起卦，number=數字起卦"),
+    // time 模式參數
+    year: zod_1.z.number().int().min(1900).max(2100).optional().describe("起卦年份（公曆，time 模式必填）"),
+    month: zod_1.z.number().int().min(1).max(12).optional().describe("起卦月份（1-12，time 模式必填）"),
+    day: zod_1.z.number().int().min(1).max(31).optional().describe("起卦日期（1-31，time 模式必填）"),
+    hour: zod_1.z.number().int().min(0).max(23).optional().describe("起卦時辰（0-23，time 模式必填）"),
+    isLunar: isLunarField,
+    // number 模式參數
+    upperNumber: zod_1.z.number().int().min(1).optional().describe("上卦數（number 模式必填）"),
+    lowerNumber: zod_1.z.number().int().min(1).optional().describe("下卦數（number 模式必填）"),
+    yaoNumber: zod_1.z.number().int().min(1).optional().describe("動爻數（可選，默認用上下卦數之和）"),
+});
+// ============================================
+// 大六壬 Schema
+// ============================================
+const DaliurenBasicSchema = zod_1.z.object({
+    jieqi: zod_1.z.string().describe("節氣（如：立春、雨水、驚蟄等）"),
+    lunarMonth: zod_1.z.number().int().min(1).max(12).describe("農曆月份（1-12）"),
+    dayGanZhi: zod_1.z.string().describe("日干支（如：甲子、乙丑等）"),
+    hourGanZhi: zod_1.z.string().describe("時干支（如：甲子、乙丑等）"),
+    guirenMethod: zod_1.z.union([zod_1.z.literal(0), zod_1.z.literal(1)]).optional().default(0).describe("貴人起法：0=標準, 1=另一種"),
+});
+// ============================================
 // List Tool Schemas
 // ============================================
 // 八字大运列表
@@ -147,7 +233,7 @@ const ZiweiLiuRiListSchema = BaseBirthInfoSchema.extend({
 // ============================================
 const server = new index_js_1.Server({
     name: "mingpan",
-    version: "0.1.1",
+    version: "0.1.2",
 }, {
     capabilities: {
         tools: {},
@@ -327,6 +413,75 @@ server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
 用于精细的日期选择。`,
                 inputSchema: schemaToJson(ZiweiLiuRiListSchema),
             },
+            {
+                name: "liuyao_basic",
+                description: `六爻排盤（基礎排盤）。
+
+輸入六個爻值和起卦時間，返回完整的六爻盤面：
+- 本卦/變卦（含卦名、卦宮、五行）
+- 六爻納甲（每爻地支及五行）
+- 六親（父母/兄弟/子孫/妻財/官鬼）
+- 六神（青龍/朱雀/勾陳/螣蛇/白虎/玄武）
+- 世應位置
+- 動爻標註
+- 日干支、月建、旬空
+
+爻值說明：
+- 6 = 老陰（動爻，陰變陽）
+- 7 = 少陽（靜爻，陽）
+- 8 = 少陰（靜爻，陰）
+- 9 = 老陽（動爻，陽變陰）
+
+輸入順序：自下而上（初爻到上爻）
+
+輸出為 Markdown 格式，便於 AI 分析解讀。`,
+                inputSchema: schemaToJson(LiuyaoBasicSchema),
+            },
+            {
+                name: "meihua_basic",
+                description: `梅花易數排盤（基礎排盤）。
+
+支持兩種起卦方式：
+1. 時間起卦（method='time'）：根據農曆年月日時起卦
+2. 數字起卦（method='number'）：根據兩個數字起卦
+
+返回完整的梅花盤面：
+- 本卦/變卦/互卦
+- 上卦/下卦（含卦象、五行）
+- 動爻位置
+- 體用分析（體卦、用卦、五行生剋關係）
+- 起卦數據詳情
+
+時間起卦算法（農曆）：
+- 上卦 = (年干支序數 + 月 + 日) % 8
+- 下卦 = (年干支序數 + 月 + 日 + 時辰序數) % 8
+- 動爻 = (年干支序數 + 月 + 日 + 時辰序數) % 6
+
+輸出為 Markdown 格式，便於 AI 分析解讀。`,
+                inputSchema: schemaToJson(MeihuaBasicSchema),
+            },
+            {
+                name: "daliuren_basic",
+                description: `大六壬排盤（基礎排盤）。
+
+大六壬是中國古老三大占卜術之一，與奇門遁甲、太乙神數並稱三式。
+
+輸入節氣、農曆月、日干支、時干支，返回完整的六壬盤面：
+- 天地盤（月將加時辰起盤）
+- 四課（日干支推演）
+- 三傳（九宗門推演：賊尅、比用、涉害、遙尅、昴星、別責、八專、伏吟、返吟）
+- 十二天將（貴人、螣蛇、朱雀、六合、勾陳、青龍、天空、白虎、太常、玄武、太陰、天后）
+- 格局判斷
+- 神煞（日馬、月馬、丁馬、華蓋、閃電）
+
+注意：
+- 需要提供節氣（如：立春、雨水、驚蟄等）
+- 日干支和時干支需要是完整的干支（如：甲子、乙丑）
+- 本工具只負責排盤，斷課解讀交給 Agent
+
+輸出為 Markdown 格式，便於 AI 分析解讀。`,
+                inputSchema: schemaToJson(DaliurenBasicSchema),
+            },
         ],
     };
 });
@@ -335,6 +490,8 @@ server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
 // ============================================
 const baziService = new BaziService_1.BaziService({ debug: false });
 const ziweiService = new ZiweiService_1.ZiweiService();
+const liuyaoService = new LiuyaoService_1.LiuyaoService();
+const meihuaService = new MeihuaService_1.MeihuaService();
 // Helper: Calculate year stem and branch
 function getYearStemBranch(year) {
     const STEMS = ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸'];
@@ -407,20 +564,21 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
         // === Existing Chart Calculation Handlers ===
         if (name === "bazi_basic") {
             const validated = BaziCalculateSchema.parse(args);
+            const normalized = normalizeBirthInfo(validated);
             const result = await baziService.calculate({
-                year: validated.year,
-                month: validated.month,
-                day: validated.day,
-                hour: validated.hour,
-                minute: validated.minute,
-                gender: validated.gender,
-                longitude: validated.longitude,
-                useLunar: validated.isLunar,
+                year: normalized.year,
+                month: normalized.month,
+                day: normalized.day,
+                hour: normalized.hour,
+                minute: normalized.minute,
+                gender: normalized.gender,
+                longitude: normalized.longitude,
+                useLunar: false, // Already converted to solar if needed
             });
             // If targetYear is specified, calculate LiuNian
             let liuNianInfo = "";
             if (validated.targetYear && result.chart) {
-                const liuNians = LiuNianCalculator_1.LiuNianCalculator.calculate(result.chart, validated.year, validated.targetYear, validated.targetYear);
+                const liuNians = LiuNianCalculator_1.LiuNianCalculator.calculate(result.chart, normalized.year, validated.targetYear, validated.targetYear);
                 if (liuNians.length > 0) {
                     const liunian = liuNians[0];
                     liuNianInfo = `\n\n=== 流年 ${validated.targetYear} ===\n干支：${liunian.stem}${liunian.branch}`;
@@ -431,8 +589,8 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                 includePersonal: false,
                 includeLocation: !!validated.longitude,
             };
-            const birthDate = new Date(validated.year, validated.month - 1, validated.day, validated.hour, validated.minute);
-            const text = (0, fortuneTextRenderer_1.renderBaziText)({ bazi: result, gender: validated.gender, birthDate }, options);
+            const birthDate = new Date(normalized.year, normalized.month - 1, normalized.day, normalized.hour, normalized.minute);
+            const text = (0, fortuneTextRenderer_1.renderBaziText)({ bazi: result, gender: normalized.gender, birthDate }, options);
             return {
                 content: [
                     {
@@ -444,21 +602,22 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
         }
         if (name === "ziwei_basic") {
             const validated = ZiweiCalculateSchema.parse(args);
+            const normalized = normalizeBirthInfo(validated);
             const result = await ziweiService.calculate({
-                year: validated.year,
-                month: validated.month,
-                day: validated.day,
-                hour: validated.hour,
-                gender: validated.gender,
+                year: normalized.year,
+                month: normalized.month,
+                day: normalized.day,
+                hour: normalized.hour,
+                gender: normalized.gender,
             });
             const options = {
                 detail: validated.detail,
                 includePersonal: false,
             };
-            const birthDate = new Date(validated.year, validated.month - 1, validated.day, validated.hour, validated.minute);
+            const birthDate = new Date(normalized.year, normalized.month - 1, normalized.day, normalized.hour, normalized.minute);
             const text = (0, fortuneTextRenderer_1.renderZiweiText)({
                 ziwei: result,
-                gender: validated.gender,
+                gender: normalized.gender,
                 birthDate,
                 mutagen: result.mutagenInfo // 傳入四化信息
             }, options);
@@ -471,36 +630,103 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                 ],
             };
         }
+        // === 六爻工具處理器 ===
+        if (name === "liuyao_basic") {
+            const validated = LiuyaoBasicSchema.parse(args);
+            const result = liuyaoService.calculate({
+                yaoValues: validated.yaoValues,
+                year: validated.year,
+                month: validated.month,
+                day: validated.day,
+                hour: validated.hour,
+                isLunar: validated.isLunar,
+            });
+            const text = (0, liuyaoTextRenderer_1.renderLiuyaoText)(result);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text,
+                    },
+                ],
+            };
+        }
+        // === 梅花易數工具處理器 ===
+        if (name === "meihua_basic") {
+            const validated = MeihuaBasicSchema.parse(args);
+            const result = meihuaService.calculate({
+                method: validated.method,
+                year: validated.year,
+                month: validated.month,
+                day: validated.day,
+                hour: validated.hour,
+                isLunar: validated.isLunar,
+                upperNumber: validated.upperNumber,
+                lowerNumber: validated.lowerNumber,
+                yaoNumber: validated.yaoNumber,
+            });
+            const text = (0, meihuaTextRenderer_1.renderMeihuaText)(result);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text,
+                    },
+                ],
+            };
+        }
+        // === 大六壬工具處理器 ===
+        if (name === "daliuren_basic") {
+            const validated = DaliurenBasicSchema.parse(args);
+            const daliurenService = new DaliurenService_1.DaliurenService();
+            const result = daliurenService.calculate({
+                jieqi: validated.jieqi,
+                lunarMonth: validated.lunarMonth,
+                dayGanZhi: validated.dayGanZhi,
+                hourGanZhi: validated.hourGanZhi,
+                guirenMethod: validated.guirenMethod,
+            });
+            const text = (0, daliurenTextRenderer_1.renderDaliurenText)(result);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text,
+                    },
+                ],
+            };
+        }
         // === BaZi List Tool Handlers ===
         if (name === "bazi_dayun") {
             const validated = BaziDaYunListSchema.parse(args);
+            const normalized = normalizeBirthInfo(validated);
             // Calculate BaZi chart first
             const result = await baziService.calculate({
-                year: validated.year,
-                month: validated.month,
-                day: validated.day,
-                hour: validated.hour,
-                minute: validated.minute,
-                gender: validated.gender,
-                longitude: validated.longitude,
+                year: normalized.year,
+                month: normalized.month,
+                day: normalized.day,
+                hour: normalized.hour,
+                minute: normalized.minute,
+                gender: normalized.gender,
+                longitude: normalized.longitude,
             });
             if (!result.chart || !result.birthInfo) {
                 throw new Error("Failed to calculate BaZi chart");
             }
             // Calculate DaYun
-            const daYunList = DaYunCalculator_1.DaYunCalculator.calculate(result.chart, result.birthInfo, validated.gender, { startYear: validated.year, endYear: validated.year + 100 });
+            const daYunList = DaYunCalculator_1.DaYunCalculator.calculate(result.chart, result.birthInfo, normalized.gender, { startYear: normalized.year, endYear: normalized.year + 100 });
             // Get direction and start info
-            const direction = LuckCycleCalculator_1.LuckCycleCalculator.calLuckySequence(validated.gender, result.chart.year.stem) === 'forward' ? '顺行' : '逆行';
+            const direction = LuckCycleCalculator_1.LuckCycleCalculator.calLuckySequence(normalized.gender, result.chart.year.stem) === 'forward' ? '顺行' : '逆行';
             const startAge = daYunList.length > 0 ? daYunList[0].startAge : 1;
-            const startYear = validated.year + startAge - 1;
+            const startYear = normalized.year + startAge - 1;
             const options = {
-                name: validated.name,
-                birthYear: validated.year,
-                birthMonth: validated.month,
-                birthDay: validated.day,
-                birthHour: validated.hour,
-                birthMinute: validated.minute,
-                gender: validated.gender,
+                name: normalized.name,
+                birthYear: normalized.year,
+                birthMonth: normalized.month,
+                birthDay: normalized.day,
+                birthHour: normalized.hour,
+                birthMinute: normalized.minute,
+                gender: normalized.gender,
                 dayMaster: result.chart.day.stem,
                 yearPillar: { stem: result.chart.year.stem, branch: result.chart.year.branch },
                 monthPillar: { stem: result.chart.month.stem, branch: result.chart.month.branch },
@@ -515,31 +741,32 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
         }
         if (name === "bazi_liunian") {
             const validated = BaziLiuNianListSchema.parse(args);
+            const normalized = normalizeBirthInfo(validated);
             // Calculate BaZi chart first
             const result = await baziService.calculate({
-                year: validated.year,
-                month: validated.month,
-                day: validated.day,
-                hour: validated.hour,
-                minute: validated.minute,
-                gender: validated.gender,
-                longitude: validated.longitude,
+                year: normalized.year,
+                month: normalized.month,
+                day: normalized.day,
+                hour: normalized.hour,
+                minute: normalized.minute,
+                gender: normalized.gender,
+                longitude: normalized.longitude,
             });
             if (!result.chart || !result.birthInfo) {
                 throw new Error("Failed to calculate BaZi chart");
             }
             // Calculate DaYun list to match each LiuNian to its DaYun
-            const daYunList = DaYunCalculator_1.DaYunCalculator.calculate(result.chart, result.birthInfo, validated.gender, { startYear: validated.year, endYear: validated.year + 100 });
+            const daYunList = DaYunCalculator_1.DaYunCalculator.calculate(result.chart, result.birthInfo, normalized.gender, { startYear: normalized.year, endYear: normalized.year + 100 });
             // Calculate LiuNian for the range
-            const liuNianList = LiuNianCalculator_1.LiuNianCalculator.calculate(result.chart, validated.year, validated.startYear, validated.endYear);
+            const liuNianList = LiuNianCalculator_1.LiuNianCalculator.calculate(result.chart, normalized.year, validated.startYear, validated.endYear);
             const options = {
-                name: validated.name,
-                birthYear: validated.year,
-                birthMonth: validated.month,
-                birthDay: validated.day,
-                birthHour: validated.hour,
-                birthMinute: validated.minute,
-                gender: validated.gender,
+                name: normalized.name,
+                birthYear: normalized.year,
+                birthMonth: normalized.month,
+                birthDay: normalized.day,
+                birthHour: normalized.hour,
+                birthMinute: normalized.minute,
+                gender: normalized.gender,
                 dayMaster: result.chart.day.stem,
                 yearPillar: { stem: result.chart.year.stem, branch: result.chart.year.branch },
                 monthPillar: { stem: result.chart.month.stem, branch: result.chart.month.branch },
@@ -554,16 +781,17 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
         }
         if (name === "bazi_liuyue") {
             const validated = BaziLiuYueListSchema.parse(args);
+            const normalized = normalizeBirthInfo(validated);
             const { year: gregorianYear, ganzhi: ganzhiYear } = parseGanzhiYear(validated.ganzhiYear);
             // Calculate BaZi chart first
             const result = await baziService.calculate({
-                year: validated.year,
-                month: validated.month,
-                day: validated.day,
-                hour: validated.hour,
-                minute: validated.minute,
-                gender: validated.gender,
-                longitude: validated.longitude,
+                year: normalized.year,
+                month: normalized.month,
+                day: normalized.day,
+                hour: normalized.hour,
+                minute: normalized.minute,
+                gender: normalized.gender,
+                longitude: normalized.longitude,
             });
             if (!result.chart || !result.birthInfo) {
                 throw new Error("Failed to calculate BaZi chart");
@@ -571,9 +799,9 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             // Get year stem and branch
             const { stem: yearStem, branch: yearBranch } = getYearStemBranch(gregorianYear);
             // Calculate DaYun list to find current DaYun
-            const daYunList = DaYunCalculator_1.DaYunCalculator.calculate(result.chart, result.birthInfo, validated.gender, { startYear: validated.year, endYear: validated.year + 100 });
+            const daYunList = DaYunCalculator_1.DaYunCalculator.calculate(result.chart, result.birthInfo, normalized.gender, { startYear: normalized.year, endYear: normalized.year + 100 });
             // Calculate age for the target year (虛歲)
-            const targetAge = gregorianYear - validated.year + 1;
+            const targetAge = gregorianYear - normalized.year + 1;
             // Find current DaYun
             let currentDaYun;
             const matchedDaYun = daYunList.find(dy => targetAge >= dy.startAge && targetAge <= dy.endAge);
@@ -586,7 +814,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                 };
             }
             // Calculate current LiuNian
-            const liuNianList = LiuNianCalculator_1.LiuNianCalculator.calculate(result.chart, validated.year, gregorianYear, gregorianYear);
+            const liuNianList = LiuNianCalculator_1.LiuNianCalculator.calculate(result.chart, normalized.year, gregorianYear, gregorianYear);
             let currentLiuNian;
             if (liuNianList.length > 0) {
                 const ln = liuNianList[0];
@@ -599,20 +827,20 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             // Calculate LiuYue
             const calculator = new LiuYueCalculator_1.LiuYueCalculator();
             const liuYueList = calculator.calculateLiuYue(yearStem, yearBranch, (result.basic?.dayMasterElement || '木'), (result.traditional?.yongShen?.yongShen || []), {
-                year: validated.year,
-                month: validated.month,
-                day: validated.day,
-                hour: validated.hour,
-                minute: validated.minute,
+                year: normalized.year,
+                month: normalized.month,
+                day: normalized.day,
+                hour: normalized.hour,
+                minute: normalized.minute,
             }, gregorianYear);
             const options = {
-                name: validated.name,
-                birthYear: validated.year,
-                birthMonth: validated.month,
-                birthDay: validated.day,
-                birthHour: validated.hour,
-                birthMinute: validated.minute,
-                gender: validated.gender,
+                name: normalized.name,
+                birthYear: normalized.year,
+                birthMonth: normalized.month,
+                birthDay: normalized.day,
+                birthHour: normalized.hour,
+                birthMinute: normalized.minute,
+                gender: normalized.gender,
                 dayMaster: result.chart.day.stem,
                 yearPillar: { stem: result.chart.year.stem, branch: result.chart.year.branch },
                 monthPillar: { stem: result.chart.month.stem, branch: result.chart.month.branch },
@@ -628,17 +856,18 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
         }
         if (name === "bazi_liuri") {
             const validated = BaziLiuRiListSchema.parse(args);
+            const normalized = normalizeBirthInfo(validated);
             const { year: gregorianYear, ganzhi: ganzhiYear } = parseGanzhiYear(validated.ganzhiYear);
             const monthNum = parseGanzhiMonth(validated.ganzhiMonth);
             // Calculate BaZi chart first
             const result = await baziService.calculate({
-                year: validated.year,
-                month: validated.month,
-                day: validated.day,
-                hour: validated.hour,
-                minute: validated.minute,
-                gender: validated.gender,
-                longitude: validated.longitude,
+                year: normalized.year,
+                month: normalized.month,
+                day: normalized.day,
+                hour: normalized.hour,
+                minute: normalized.minute,
+                gender: normalized.gender,
+                longitude: normalized.longitude,
             });
             if (!result.chart || !result.birthInfo) {
                 throw new Error("Failed to calculate BaZi chart");
@@ -647,9 +876,9 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             const { stem: yearStem, branch: yearBranch } = getYearStemBranch(gregorianYear);
             const { stem: monthStem, branch: monthBranch } = getMonthStemBranch(gregorianYear, monthNum);
             // Calculate DaYun list to find current DaYun
-            const daYunList = DaYunCalculator_1.DaYunCalculator.calculate(result.chart, result.birthInfo, validated.gender, { startYear: validated.year, endYear: validated.year + 100 });
+            const daYunList = DaYunCalculator_1.DaYunCalculator.calculate(result.chart, result.birthInfo, normalized.gender, { startYear: normalized.year, endYear: normalized.year + 100 });
             // Calculate age for the target year (虛歲)
-            const targetAge = gregorianYear - validated.year + 1;
+            const targetAge = gregorianYear - normalized.year + 1;
             // Find current DaYun
             let currentDaYun;
             const matchedDaYun = daYunList.find(dy => targetAge >= dy.startAge && targetAge <= dy.endAge);
@@ -662,7 +891,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                 };
             }
             // Calculate current LiuNian
-            const liuNianList = LiuNianCalculator_1.LiuNianCalculator.calculate(result.chart, validated.year, gregorianYear, gregorianYear);
+            const liuNianList = LiuNianCalculator_1.LiuNianCalculator.calculate(result.chart, normalized.year, gregorianYear, gregorianYear);
             let currentLiuNian;
             if (liuNianList.length > 0) {
                 const ln = liuNianList[0];
@@ -685,13 +914,13 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             const startDate = liuRiList.length > 0 ? liuRiList[0].date : new Date();
             const endDate = liuRiList.length > 0 ? liuRiList[liuRiList.length - 1].date : new Date();
             const options = {
-                name: validated.name,
-                birthYear: validated.year,
-                birthMonth: validated.month,
-                birthDay: validated.day,
-                birthHour: validated.hour,
-                birthMinute: validated.minute,
-                gender: validated.gender,
+                name: normalized.name,
+                birthYear: normalized.year,
+                birthMonth: normalized.month,
+                birthDay: normalized.day,
+                birthHour: normalized.hour,
+                birthMinute: normalized.minute,
+                gender: normalized.gender,
                 dayMaster: result.chart.day.stem,
                 yearPillar: { stem: result.chart.year.stem, branch: result.chart.year.branch },
                 monthPillar: { stem: result.chart.month.stem, branch: result.chart.month.branch },
@@ -712,13 +941,14 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
         // === ZiWei List Tool Handlers ===
         if (name === "ziwei_daxian") {
             const validated = ZiweiDaXianListSchema.parse(args);
+            const normalized = normalizeBirthInfo(validated);
             // Calculate ZiWei chart
             const result = ziweiService.calculate({
-                year: validated.year,
-                month: validated.month,
-                day: validated.day,
-                hour: validated.hour,
-                gender: validated.gender,
+                year: normalized.year,
+                month: normalized.month,
+                day: normalized.day,
+                hour: normalized.hour,
+                gender: normalized.gender,
             });
             if (!result.decades || result.decades.length === 0) {
                 throw new Error("Failed to calculate ZiWei decades");
@@ -736,13 +966,13 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             const shenGongPalace = result.palaces?.find(p => p.isBodyPalace);
             const shenGongStars = shenGongPalace?.majorStars?.map(s => typeof s === 'string' ? s : s.name) || [];
             const options = {
-                name: validated.name,
-                birthYear: validated.year,
-                birthMonth: validated.month,
-                birthDay: validated.day,
-                birthHour: validated.hour,
-                birthMinute: validated.minute,
-                gender: validated.gender,
+                name: normalized.name,
+                birthYear: normalized.year,
+                birthMonth: normalized.month,
+                birthDay: normalized.day,
+                birthHour: normalized.hour,
+                birthMinute: normalized.minute,
+                gender: normalized.gender,
                 mingGong: mingGongPalace?.name || '命宮',
                 mingGongStars,
                 shenGong: shenGongPalace?.name,
@@ -756,21 +986,22 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
         }
         if (name === "ziwei_xiaoxian") {
             const validated = ZiweiXiaoXianListSchema.parse(args);
+            const normalized = normalizeBirthInfo(validated);
             const result = ziweiService.calculate({
-                year: validated.year,
-                month: validated.month,
-                day: validated.day,
-                hour: validated.hour,
-                gender: validated.gender,
+                year: normalized.year,
+                month: normalized.month,
+                day: normalized.day,
+                hour: normalized.hour,
+                gender: normalized.gender,
             });
             if (!result.palaces) {
                 throw new Error("Failed to calculate ZiWei chart");
             }
-            const minorLimitList = ziweiService.getMinorLimitRange(validated.year, validated.startAge, validated.endAge);
+            const minorLimitList = ziweiService.getMinorLimitRange(normalized.year, validated.startAge, validated.endAge);
             const mingGongPalace = result.palaces?.find(p => p.name === '命宮' || p.name === '命宫' || p.name === 'Life');
             const mingGongStars = mingGongPalace?.majorStars?.map(s => typeof s === 'string' ? s : s.name) || [];
             const currentYear = new Date().getFullYear();
-            const currentAge = currentYear - validated.year + 1;
+            const currentAge = currentYear - normalized.year + 1;
             let currentDecade;
             if (result.decades && result.decades.length > 0) {
                 const matchedDecade = result.decades.find(d => currentAge >= d.startAge && currentAge <= d.endAge);
@@ -783,13 +1014,13 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                 }
             }
             const options = {
-                name: validated.name,
-                birthYear: validated.year,
-                birthMonth: validated.month,
-                birthDay: validated.day,
-                birthHour: validated.hour,
-                birthMinute: validated.minute,
-                gender: validated.gender,
+                name: normalized.name,
+                birthYear: normalized.year,
+                birthMonth: normalized.month,
+                birthDay: normalized.day,
+                birthHour: normalized.hour,
+                birthMinute: normalized.minute,
+                gender: normalized.gender,
                 mingGong: mingGongPalace?.name || '命宮',
                 mingGongStars,
                 palaces: result.palaces,
@@ -804,13 +1035,14 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
         }
         if (name === "ziwei_liunian") {
             const validated = ZiweiLiuNianListSchema.parse(args);
+            const normalized = normalizeBirthInfo(validated);
             // Calculate ZiWei chart
             const result = ziweiService.calculate({
-                year: validated.year,
-                month: validated.month,
-                day: validated.day,
-                hour: validated.hour,
-                gender: validated.gender,
+                year: normalized.year,
+                month: normalized.month,
+                day: normalized.day,
+                hour: normalized.hour,
+                gender: normalized.gender,
             });
             if (!result.palaces) {
                 throw new Error("Failed to calculate ZiWei chart");
@@ -818,7 +1050,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             // Calculate yearly info for each year in the range
             const yearlyList = [];
             for (let year = validated.startYear; year <= validated.endYear; year++) {
-                const yearly = YearlyCalculator_1.YearlyCalculator.calculate(year, validated.year, result.palaces);
+                const yearly = YearlyCalculator_1.YearlyCalculator.calculate(year, normalized.year, result.palaces);
                 if (yearly) {
                     yearlyList.push(yearly);
                 }
@@ -827,13 +1059,13 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             const mingGongPalace = result.palaces?.find(p => p.name === '命宮' || p.name === '命宫' || p.name === 'Life');
             const mingGongStars = mingGongPalace?.majorStars?.map(s => typeof s === 'string' ? s : s.name) || [];
             const options = {
-                name: validated.name,
-                birthYear: validated.year,
-                birthMonth: validated.month,
-                birthDay: validated.day,
-                birthHour: validated.hour,
-                birthMinute: validated.minute,
-                gender: validated.gender,
+                name: normalized.name,
+                birthYear: normalized.year,
+                birthMonth: normalized.month,
+                birthDay: normalized.day,
+                birthHour: normalized.hour,
+                birthMinute: normalized.minute,
+                gender: normalized.gender,
                 mingGong: mingGongPalace?.name || '命宮',
                 mingGongStars,
                 palaces: result.palaces, // 传入完整宫位数据
@@ -847,13 +1079,14 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
         }
         if (name === "ziwei_liuyue") {
             const validated = ZiweiLiuYueListSchema.parse(args);
+            const normalized = normalizeBirthInfo(validated);
             // Calculate ZiWei chart
             const result = ziweiService.calculate({
-                year: validated.year,
-                month: validated.month,
-                day: validated.day,
-                hour: validated.hour,
-                gender: validated.gender,
+                year: normalized.year,
+                month: normalized.month,
+                day: normalized.day,
+                hour: normalized.hour,
+                gender: normalized.gender,
             });
             // Get yearly months (农历月)
             const monthlyList = ziweiService.getYearlyMonths(validated.lunarYear);
@@ -865,7 +1098,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             const leapMonth = lunar.getYear() === validated.lunarYear ?
                 lunar_javascript_1.Lunar.fromYmd(validated.lunarYear, 6, 1).getLeapMonth?.() : undefined;
             // Calculate age for the target year (虛歲)
-            const targetAge = validated.lunarYear - validated.year + 1;
+            const targetAge = validated.lunarYear - normalized.year + 1;
             // Find current decade (大限)
             let currentDecade;
             if (result.decades && result.decades.length > 0) {
@@ -879,7 +1112,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                 }
             }
             // Calculate current yearly (流年)
-            const yearlyInfo = YearlyCalculator_1.YearlyCalculator.calculate(validated.lunarYear, validated.year, result.palaces);
+            const yearlyInfo = YearlyCalculator_1.YearlyCalculator.calculate(validated.lunarYear, normalized.year, result.palaces);
             let currentYearly;
             if (yearlyInfo) {
                 const { stem: yearStem, branch: yearBranch } = getYearStemBranch(validated.lunarYear);
@@ -892,7 +1125,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                 };
             }
             // Calculate current minor limit (小限)
-            const minorLimitInfo = ziweiService.getMinorLimitInfo(validated.year, validated.lunarYear);
+            const minorLimitInfo = ziweiService.getMinorLimitInfo(normalized.year, validated.lunarYear);
             let currentMinorLimit;
             if (minorLimitInfo) {
                 currentMinorLimit = {
@@ -908,13 +1141,13 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                 enhancedMutagenInfo.minorLimit = MutagenCore_1.MutagenCore.getMutagen(minorLimitInfo.heavenlyStem) || undefined;
             }
             const options = {
-                name: validated.name,
-                birthYear: validated.year,
-                birthMonth: validated.month,
-                birthDay: validated.day,
-                birthHour: validated.hour,
-                birthMinute: validated.minute,
-                gender: validated.gender,
+                name: normalized.name,
+                birthYear: normalized.year,
+                birthMonth: normalized.month,
+                birthDay: normalized.day,
+                birthHour: normalized.hour,
+                birthMinute: normalized.minute,
+                gender: normalized.gender,
                 mingGong: mingGongPalace?.name || '命宮',
                 mingGongStars,
                 palaces: result.palaces,
@@ -931,13 +1164,14 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
         }
         if (name === "ziwei_liuri") {
             const validated = ZiweiLiuRiListSchema.parse(args);
+            const normalized = normalizeBirthInfo(validated);
             // Calculate ZiWei chart
             const result = ziweiService.calculate({
-                year: validated.year,
-                month: validated.month,
-                day: validated.day,
-                hour: validated.hour,
-                gender: validated.gender,
+                year: normalized.year,
+                month: normalized.month,
+                day: normalized.day,
+                hour: normalized.hour,
+                gender: normalized.gender,
             });
             // Handle leap month (negative number)
             const isLeapMonth = validated.lunarMonth < 0;
@@ -989,7 +1223,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             const monthlyInfo = ziweiService.getMonthlyInfo(validated.lunarYear, actualMonth - 1, actualMonth, isLeapMonth);
             const monthlyPalace = monthlyInfo ? result.palaces?.[monthlyInfo.palaceIndex]?.name : undefined;
             // Calculate age for the target year (虛歲)
-            const targetAge = validated.lunarYear - validated.year + 1;
+            const targetAge = validated.lunarYear - normalized.year + 1;
             // Find current decade (大限)
             let currentDecade;
             if (result.decades && result.decades.length > 0) {
@@ -1003,7 +1237,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                 }
             }
             // Calculate current yearly (流年)
-            const yearlyInfo = YearlyCalculator_1.YearlyCalculator.calculate(validated.lunarYear, validated.year, result.palaces);
+            const yearlyInfo = YearlyCalculator_1.YearlyCalculator.calculate(validated.lunarYear, normalized.year, result.palaces);
             let currentYearly;
             if (yearlyInfo) {
                 const { stem: yearStem, branch: yearBranch } = getYearStemBranch(validated.lunarYear);
@@ -1026,7 +1260,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                 };
             }
             // Calculate current minor limit (小限)
-            const minorLimitInfo = ziweiService.getMinorLimitInfo(validated.year, validated.lunarYear);
+            const minorLimitInfo = ziweiService.getMinorLimitInfo(normalized.year, validated.lunarYear);
             let currentMinorLimit;
             if (minorLimitInfo) {
                 currentMinorLimit = {
@@ -1045,13 +1279,13 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                 enhancedMutagenInfo.monthly = MutagenCore_1.MutagenCore.getMutagen(monthlyInfo.heavenlyStem) || undefined;
             }
             const options = {
-                name: validated.name,
-                birthYear: validated.year,
-                birthMonth: validated.month,
-                birthDay: validated.day,
-                birthHour: validated.hour,
-                birthMinute: validated.minute,
-                gender: validated.gender,
+                name: normalized.name,
+                birthYear: normalized.year,
+                birthMonth: normalized.month,
+                birthDay: normalized.day,
+                birthHour: normalized.hour,
+                birthMinute: normalized.minute,
+                gender: normalized.gender,
                 mingGong: mingGongPalace?.name || '命宮',
                 mingGongStars,
                 palaces: result.palaces,
@@ -1092,7 +1326,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
 async function main() {
     const transport = new stdio_js_1.StdioServerTransport();
     await server.connect(transport);
-    logger.info("Mingpan MCP server started (v0.1.1)");
+    logger.info("Mingpan MCP server started (v0.1.2)");
 }
 main().catch((error) => {
     logger.error("Server failed to start", error);