mingpan 0.1.1 → 0.1.3

package/dist/index.js

@@ -10,6 +10,39 @@
  * - 八字流月 uses 干支月 (solar term months)
  * - 紫微流月 uses 农历月 (lunar months)
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
@@ -17,8 +50,17 @@ 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 QimenService_1 = require("./services/qimen/QimenService");
+const qimenTextRenderer_1 = require("./output/qimenTextRenderer");
 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 +72,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 +88,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 +99,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 +134,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 +147,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 +161,110 @@ 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=另一種"),
+});
+// ============================================
+// 奇門遁甲 Schema
+// ============================================
+const QimenBasicSchema = zod_1.z.object({
+    year: zod_1.z.number().int().min(1900).max(2100).describe("年份（公曆，1900-2100）"),
+    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，24小時制）"),
+    minute: zod_1.z.number().int().min(0).max(59).optional().default(0).describe("分鐘（0-59）"),
+    isLunar: isLunarField,
+    panType: zod_1.z.enum(['时盘', '日盘', '月盘', '年盘']).optional().default('时盘').describe("盤類型：时盘（默認）、日盘、月盘、年盘"),
+    panStyle: zod_1.z.enum(['转盘', '飞盘']).optional().default('转盘').describe("盤式：转盘（默認，遵循《神奇之門》）或飞盘"),
+    zhiRunMethod: zod_1.z.enum(['chaibu', 'maoshan']).optional().default('chaibu').describe("置閏方法：chaibu=拆補法（默認），maoshan=茅山法"),
+});
+// 奇门用神分析
+const QimenYongShenSchema = zod_1.z.object({
+    year: zod_1.z.number().int().min(1900).max(2100).describe("年份（公曆，1900-2100）"),
+    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，24小時制）"),
+    minute: zod_1.z.number().int().min(0).max(59).optional().default(0).describe("分鐘（0-59）"),
+    isLunar: isLunarField,
+    panType: zod_1.z.enum(['时盘', '日盘', '月盘', '年盘']).optional().default('时盘').describe("盤類型：时盘（默認）、日盘、月盘、年盘"),
+    panStyle: zod_1.z.enum(['转盘', '飞盘']).optional().default('转盘').describe("盤式：转盘（默認）或飞盘"),
+    zhiRunMethod: zod_1.z.enum(['chaibu', 'maoshan']).optional().default('chaibu').describe("置閏方法"),
+    shiLei: zod_1.z.enum([
+        '求财', '婚姻', '疾病', '出行', '诉讼', '考试', '工作',
+        '失物', '置业', '求官', '孕产', '寻人', '合作', '其他'
+    ]).describe("事類（用於確定用神）"),
+    nianGan: zod_1.z.enum(['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸']).optional().describe("年干（用於年命分析，可選）"),
+    includeShenSha: zod_1.z.boolean().optional().default(true).describe("是否包含神煞分析"),
+});
+// 奇门择日
+const QimenZeRiSchema = zod_1.z.object({
+    startYear: zod_1.z.number().int().min(1900).max(2100).describe("起始年份"),
+    startMonth: zod_1.z.number().int().min(1).max(12).describe("起始月份"),
+    startDay: zod_1.z.number().int().min(1).max(31).describe("起始日期"),
+    endYear: zod_1.z.number().int().min(1900).max(2100).describe("結束年份"),
+    endMonth: zod_1.z.number().int().min(1).max(12).describe("結束月份"),
+    endDay: zod_1.z.number().int().min(1).max(31).describe("結束日期"),
+    shiLei: zod_1.z.enum([
+        '求财', '婚姻', '疾病', '出行', '诉讼', '考试', '工作',
+        '失物', '置业', '求官', '孕产', '寻人', '合作', '其他'
+    ]).describe("事類"),
+    limit: zod_1.z.number().int().min(1).max(50).optional().default(10).describe("返回數量限制（默認10）"),
+    minScore: zod_1.z.number().int().min(0).max(100).optional().default(60).describe("最小評分閾值（0-100，默認60）"),
+    includeDirection: zod_1.z.boolean().optional().default(false).describe("是否輸出方位信息"),
+    excludeJieQiDay: zod_1.z.boolean().optional().default(false).describe("是否排除節氣交接日"),
+    excludeSuiPo: zod_1.z.boolean().optional().default(false).describe("是否排除歲破日"),
+    excludeYuePo: zod_1.z.boolean().optional().default(false).describe("是否排除月破日"),
+    panType: zod_1.z.enum(['时盘', '日盘', '月盘', '年盘']).optional().default('时盘').describe("盤類型"),
+    panStyle: zod_1.z.enum(['转盘', '飞盘']).optional().default('转盘').describe("盤式"),
+    zhiRunMethod: zod_1.z.enum(['chaibu', 'maoshan']).optional().default('chaibu').describe("置閏方法"),
+});
+// ============================================
 // List Tool Schemas
 // ============================================
 // 八字大运列表
@@ -147,7 +322,7 @@ const ZiweiLiuRiListSchema = BaseBirthInfoSchema.extend({
 // ============================================
 const server = new index_js_1.Server({
     name: "mingpan",
-    version: "0.1.1",
+    version: "0.1.3",
 }, {
     capabilities: {
         tools: {},
@@ -327,6 +502,167 @@ 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),
+            },
+            {
+                name: "qimen_basic",
+                description: `奇門遁甲排盤（基礎排盤）。
+
+奇門遁甲是中國古代三式之一，與大六壬、太乙神數並稱，用於預測和決策。
+
+輸入時間信息，返回完整的奇門盤面：
+- 陰陽遁和局數（根據節氣判定）
+- 九宮布局（地盤干、天盤干）
+- 八門飛布（休、生、傷、杜、景、死、驚、開）
+- 九星飛布（天蓬、天芮、天沖、天輔、天禽、天心、天柱、天任、天英）
+- 八神排布（值符、螣蛇、太陰、六合、白虎、玄武、九地、九天）
+- 旬首信息（符頭、值符星、值使門、空亡）
+- 日干/時干落宮
+- 格局判斷（吉格/凶格約20-30種）
+
+支持選項：
+- 盤類型：時盤（默認）、日盤、月盤、年盤
+- 盤式：轉盤（默認，遵循《神奇之門》）或飛盤
+- 置閏法：拆補法（默認）或茅山法
+
+盤類型說明：
+- 時盤：以時辰為主導，適用於即時預測
+- 日盤：以日干支為主導，適用於當日吉凶
+- 月盤：以月干支為主導，適用於月度運勢
+- 年盤：以年干支為主導，適用於年度規劃
+
+盤式說明：
+- 轉盤：天盤、八門、九星按物理方向旋轉（《神奇之門》派）
+- 飛盤：天盤、八門、九星按洛書軌跡飛布（傳統飛宮法）
+
+輸出為 Markdown 格式，含 ASCII 九宮格，便於 AI 分析解讀。`,
+                inputSchema: schemaToJson(QimenBasicSchema),
+            },
+            {
+                name: "qimen_yongshen",
+                description: `奇門遁甲用神分析。
+
+在基礎排盤基礎上，根據事類選取用神並分析：
+
+**支持 14 種事類**：
+求財、婚姻、疾病、出行、訴訟、考試、工作、失物、置業、求官、孕產、尋人、合作、其他
+
+**分析內容**：
+- 主用神/輔用神識別及落宮
+- 用神旺相休囚死狀態
+- 用神空亡、入墓、擊刑檢測
+- 與日干生克關係
+- 受格局影響評估
+- 主客分析（涉及雙方的事類）
+- 年命分析（可選）
+- 神煞信息（可選）
+
+**評分系統**：
+每個用神 0-100 分，綜合考量各因素
+
+輸出為結構化 Markdown，便於 AI 斷卦分析。`,
+                inputSchema: schemaToJson(QimenYongShenSchema),
+            },
+            {
+                name: "qimen_zeri",
+                description: `奇門遁甲擇日功能。
+
+在指定日期範圍內篩選吉時：
+
+**輸入**：
+- 起止日期範圍
+- 事類（14 種）
+- 可選過濾條件
+
+**評分維度**：
+- 格局評分（吉格加分、凶格減分）
+- 用神評分（得位、空墓等）
+- 神煞評分（吉神凶煞）
+
+**過濾條件**：
+- 最小評分閾值
+- 排除歲破日
+- 排除月破日
+- 排除節氣交接日
+
+**輸出**：
+- 推薦時辰列表（含評分、評級）
+- 有利因素、注意事項
+- 可選方位信息（三吉門方位、用神方位）
+
+**性能目標**：
+- 7天：< 2秒
+- 30天：< 5秒
+- 365天：< 60秒`,
+                inputSchema: schemaToJson(QimenZeRiSchema),
+            },
         ],
     };
 });
@@ -335,6 +671,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 +745,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 +770,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 +783,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 +811,189 @@ 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,
+                    },
+                ],
+            };
+        }
+        // === 奇門遁甲工具處理器 ===
+        if (name === "qimen_basic") {
+            const validated = QimenBasicSchema.parse(args);
+            const normalized = normalizeBirthInfo(validated);
+            const qimenService = new QimenService_1.QimenService();
+            const result = qimenService.calculate({
+                year: normalized.year,
+                month: normalized.month,
+                day: normalized.day,
+                hour: normalized.hour,
+                minute: normalized.minute,
+                isLunar: false, // Already converted to solar if needed
+                panType: validated.panType,
+                panStyle: validated.panStyle,
+                zhiRunMethod: validated.zhiRunMethod,
+            });
+            const text = (0, qimenTextRenderer_1.renderQimenText)(result);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text,
+                    },
+                ],
+            };
+        }
+        // === 奇門遁甲用神 ===
+        if (name === "qimen_yongshen") {
+            const validated = QimenYongShenSchema.parse(args);
+            const normalized = normalizeBirthInfo(validated);
+            const qimenService = new QimenService_1.QimenService();
+            const result = qimenService.calculateWithYongShen({
+                year: normalized.year,
+                month: normalized.month,
+                day: normalized.day,
+                hour: normalized.hour,
+                minute: normalized.minute,
+                isLunar: false,
+                panType: validated.panType,
+                panStyle: validated.panStyle,
+                zhiRunMethod: validated.zhiRunMethod,
+            }, validated.shiLei, {
+                nianGan: validated.nianGan,
+                includeShenSha: validated.includeShenSha,
+            });
+            // 使用渲染器生成输出
+            const { renderQimenYongShenText } = await Promise.resolve().then(() => __importStar(require("./output/qimenTextRenderer")));
+            const text = renderQimenYongShenText(result);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text,
+                    },
+                ],
+            };
+        }
+        if (name === "qimen_zeri") {
+            const validated = QimenZeRiSchema.parse(args);
+            const qimenService = new QimenService_1.QimenService();
+            const results = qimenService.findAuspiciousDates({
+                startDate: new Date(validated.startYear, validated.startMonth - 1, validated.startDay),
+                endDate: new Date(validated.endYear, validated.endMonth - 1, validated.endDay),
+                shiLei: validated.shiLei,
+                limit: validated.limit,
+                minScore: validated.minScore,
+                includeDirection: validated.includeDirection,
+                excludeJieQiDay: validated.excludeJieQiDay,
+                excludeSuiPo: validated.excludeSuiPo,
+                excludeYuePo: validated.excludeYuePo,
+                panType: validated.panType,
+                panStyle: validated.panStyle,
+                zhiRunMethod: validated.zhiRunMethod,
+            });
+            // 使用渲染器生成输出
+            const { renderQimenZeRiText } = await Promise.resolve().then(() => __importStar(require("./output/qimenTextRenderer")));
+            const text = renderQimenZeRiText(results, validated.shiLei);
+            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 +1008,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 +1048,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 +1066,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 +1081,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 +1094,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 +1123,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 +1143,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 +1158,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 +1181,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 +1208,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 +1233,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 +1253,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 +1281,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 +1302,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 +1317,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 +1326,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 +1346,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 +1365,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 +1379,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 +1392,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 +1408,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 +1431,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 +1490,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 +1504,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 +1527,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 +1546,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 +1593,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.3)");
 }
 main().catch((error) => {
     logger.error("Server failed to start", error);