mingpan 0.1.1

package/dist/index.js

@@ -0,0 +1,1101 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Mingpan MCP Server
+ *
+ * MCP service for accurate BaZi (八字) and ZiWei (紫微) chart calculations.
+ * Takes birth date/time and outputs structured fortune-telling information.
+ *
+ * Version 1.1.0: Added fortune list tools for DaYun, LiuNian, LiuYue, LiuRi
+ * - 八字流月 uses 干支月 (solar term months)
+ * - 紫微流月 uses 农历月 (lunar months)
+ */
+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");
+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 BaziService_1 = require("./services/bazi/BaziService");
+const ZiweiService_1 = require("./services/ziwei/ZiweiService");
+const LiuNianCalculator_1 = require("./services/bazi/calculators/LiuNianCalculator");
+const DaYunCalculator_1 = require("./services/bazi/calculators/DaYunCalculator");
+const LuckCycleCalculator_1 = require("./services/bazi/calculators/LuckCycleCalculator");
+const LiuYueCalculator_1 = require("./services/bazi/calculators/LiuYueCalculator");
+const LiuRiCalculator_1 = require("./services/bazi/calculators/LiuRiCalculator");
+const YearlyCalculator_1 = require("./services/ziwei/calculators/YearlyCalculator");
+const fortuneTextRenderer_1 = require("./output/fortuneTextRenderer");
+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");
+// Helper to avoid TypeScript's excessively deep type instantiation error
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function schemaToJson(schema) {
+    return (0, zod_to_json_schema_1.zodToJsonSchema)(schema);
+}
+// ============================================
+// Zod Schemas for Tool Inputs
+// ============================================
+// 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)"),
+    month: zod_1.z.number().int().min(1).max(12).describe("Birth month (1-12)"),
+    day: zod_1.z.number().int().min(1).max(31).describe("Birth day (1-31)"),
+    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 for fortune direction calculation"),
+    longitude: zod_1.z.number().min(-180).max(180).optional().describe("Birth location longitude for true solar time adjustment"),
+    name: zod_1.z.string().optional().describe("Subject name (optional)"),
+});
+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)"),
+    day: zod_1.z.number().int().min(1).max(31).describe("Birth day (1-31)"),
+    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"]).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"),
+    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 (大運)"),
+    targetYear: zod_1.z.number().int().optional().describe("Calculate LiuNian (流年) for this specific year"),
+});
+const ZiweiCalculateSchema = 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)"),
+    day: zod_1.z.number().int().min(1).max(31).describe("Birth day (1-31)"),
+    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"),
+    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 (大限)"),
+    includeMutagen: zod_1.z.boolean().optional().default(true).describe("Include four mutagens (四化)"),
+});
+const CombinedCalculateSchema = 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)"),
+    day: zod_1.z.number().int().min(1).max(31).describe("Birth day (1-31)"),
+    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 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"),
+    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"),
+});
+// ============================================
+// List Tool Schemas
+// ============================================
+// 八字大运列表
+const BaziDaYunListSchema = BaseBirthInfoSchema.extend({
+    count: zod_1.z.number().int().min(1).max(12).optional().default(10).describe("Number of DaYun periods to display (default 10)"),
+});
+// 八字流年列表
+const BaziLiuNianListSchema = BaseBirthInfoSchema.extend({
+    startYear: zod_1.z.number().int().min(1900).max(2100).describe("Start year for the range"),
+    endYear: zod_1.z.number().int().min(1900).max(2100).describe("End year for the range"),
+});
+// 八字流月列表（干支月/节气月）
+const BaziLiuYueListSchema = BaseBirthInfoSchema.extend({
+    ganzhiYear: zod_1.z.union([
+        zod_1.z.string().describe("GanZhi year like '乙巳'"),
+        zod_1.z.number().int().min(1900).max(2100).describe("Gregorian year like 2025")
+    ]).describe("The year to query (either GanZhi string or Gregorian year)"),
+});
+// 八字流日列表
+const BaziLiuRiListSchema = BaseBirthInfoSchema.extend({
+    ganzhiYear: zod_1.z.union([
+        zod_1.z.string().describe("GanZhi year like '乙巳'"),
+        zod_1.z.number().int().min(1900).max(2100).describe("Gregorian year like 2025")
+    ]).describe("The year of the month"),
+    ganzhiMonth: zod_1.z.union([
+        zod_1.z.string().describe("GanZhi month like '丙寅' (month 1 = 寅月)"),
+        zod_1.z.number().int().min(1).max(12).describe("Month number (1=寅月, 2=卯月, ..., 12=丑月)")
+    ]).describe("The month to query (either GanZhi string or month number 1-12)"),
+});
+// 紫微大限列表
+const ZiweiDaXianListSchema = BaseBirthInfoSchema.extend({
+    count: zod_1.z.number().int().min(1).max(12).optional().default(10).describe("Number of decade periods to display (default 10)"),
+});
+// 紫微小限列表
+const ZiweiXiaoXianListSchema = BaseBirthInfoSchema.extend({
+    startAge: zod_1.z.number().int().min(1).max(120).describe("Start age (nominal age) for the range"),
+    endAge: zod_1.z.number().int().min(1).max(120).describe("End age (nominal age) for the range"),
+});
+// 紫微流年列表
+const ZiweiLiuNianListSchema = BaseBirthInfoSchema.extend({
+    startYear: zod_1.z.number().int().min(1900).max(2100).describe("Start year for the range"),
+    endYear: zod_1.z.number().int().min(1900).max(2100).describe("End year for the range"),
+});
+// 紫微流月列表（农历月）
+const ZiweiLiuYueListSchema = BaseBirthInfoSchema.extend({
+    lunarYear: zod_1.z.number().int().min(1900).max(2100).describe("The lunar year (Gregorian year) to query"),
+});
+// 紫微流日列表（农历日）
+const ZiweiLiuRiListSchema = BaseBirthInfoSchema.extend({
+    lunarYear: zod_1.z.number().int().min(1900).max(2100).describe("The lunar year (Gregorian year)"),
+    lunarMonth: zod_1.z.number().int().min(-12).max(12).describe("Lunar month (1-12, use negative for leap month, e.g. -6 for leap 6th month)"),
+});
+// ============================================
+// Create Server
+// ============================================
+const server = new index_js_1.Server({
+    name: "mingpan",
+    version: "0.1.1",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// ============================================
+// Tool Definitions
+// ============================================
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: "bazi_basic",
+                description: `计算八字命盘（基础排盘）。
+
+输入出生时间，返回完整的八字命盘信息：
+- 四柱（年柱、月柱、日柱、时柱）干支
+- 各柱藏干
+- 十神配置
+- 五行力量分析（360分制）
+- 日主强弱判定
+- 格局识别
+- 神煞标注
+
+输出为结构化文本，便于 AI 分析解读。`,
+                inputSchema: schemaToJson(BaziCalculateSchema),
+            },
+            {
+                name: "ziwei_basic",
+                description: `计算紫微斗数命盘（基础排盘）。
+
+输入出生时间，返回完整的紫微命盘信息：
+- 十二宫位排布及干支
+- 各宫主星及亮度（庙/旺/得/利/平/不/陷）
+- 各宫辅星配置
+- 命宫与身宫位置
+- 本命四化（化禄/权/科/忌）
+
+输出为结构化文本，便于 AI 分析解读。`,
+                inputSchema: schemaToJson(ZiweiCalculateSchema),
+            },
+            {
+                name: "bazi_dayun",
+                description: `八字大运列表。
+
+返回命主一生的大运周期（十年一运）：
+- 大运干支
+- 起止虚岁
+- 对应公历年份
+- 起运方向（顺行/逆行）
+- 起运年龄
+
+用于了解人生各阶段的运势大框架。`,
+                inputSchema: schemaToJson(BaziDaYunListSchema),
+            },
+            {
+                name: "bazi_liunian",
+                description: `八字流年列表。
+
+返回指定年份范围内的流年信息：
+- 公历年份
+- 干支年
+- 虚岁
+- 所属大运
+
+用于分析多年运势趋势。`,
+                inputSchema: schemaToJson(BaziLiuNianListSchema),
+            },
+            {
+                name: "bazi_liuyue",
+                description: `八字流月列表。
+
+重要：八字流月使用【节气月】，非农历月！
+- 以节气为边界（立春起算）
+- 寅月（正月）从立春开始，约2月4日
+- 丑月（腊月）跨越公历年界
+
+返回指定年份的12个月运势：
+- 干支月
+- 节气起止
+- 公历日期范围
+
+用于规划年度活动时机。`,
+                inputSchema: schemaToJson(BaziLiuYueListSchema),
+            },
+            {
+                name: "bazi_liuri",
+                description: `八字流日列表。
+
+返回指定月份内的每日运势（含上下文）：
+- 当前大运、流年、流月资讯
+- 公历日期
+- 干支日
+
+用于精细的日期选择。`,
+                inputSchema: schemaToJson(BaziLiuRiListSchema),
+            },
+            {
+                name: "ziwei_daxian",
+                description: `紫微大限列表。
+
+返回命主一生的大限周期（十年一限）：
+- 起止虚岁
+- 对应公历年份
+- 大限宫位名称
+- 宫内主星配置
+- 大限四化
+
+用于了解人生各阶段的运势大框架。`,
+                inputSchema: schemaToJson(ZiweiDaXianListSchema),
+            },
+            {
+                name: "ziwei_xiaoxian",
+                description: `紫微小限列表。
+
+小限是紫微斗数中的年度运限单位，每年一宫：
+- 虚岁（1岁起）
+- 对应公历年份
+- 小限宫位（根据出生年支起宫，男顺女逆）
+- 宫内主星
+- 所属大限
+- 小限四化
+
+小限与流年并列但计算方式不同：
+- 小限：以出生年支定起宫，逐年移宫
+- 流年：以该年地支定宫位
+
+层级顺序：大限 > 小限 > 流年 > 流月 > 流日`,
+                inputSchema: schemaToJson(ZiweiXiaoXianListSchema),
+            },
+            {
+                name: "ziwei_liunian",
+                description: `紫微流年列表。
+
+返回指定年份范围内的流年信息：
+- 公历年份
+- 干支年
+- 虚岁
+- 流年宫位
+- 宫内主星
+- 所属大限
+- 流年四化
+
+用于分析多年运势趋势。`,
+                inputSchema: schemaToJson(ZiweiLiuNianListSchema),
+            },
+            {
+                name: "ziwei_liuyue",
+                description: `紫微流月列表。
+
+重要：紫微流月使用【农历月】，非节气月！
+- 以农历初一为边界
+- 正月从春节开始
+- 闰月单独显示（如"闰六月"）
+
+返回指定年份的流月运势（含上下文）：
+- 当前大限、小限、流年资讯
+- 农历月份及公历日期范围
+- 流月宫位及宫内主星
+- 完整四化系统（本命/大限/小限/流年/流月）
+
+用于规划年度活动时机。`,
+                inputSchema: schemaToJson(ZiweiLiuYueListSchema),
+            },
+            {
+                name: "ziwei_liuri",
+                description: `紫微流日列表。
+
+返回指定农历月内的每日运势（含上下文）：
+- 当前大限、小限、流年、流月资讯
+- 农历日期与公历日期对照
+- 干支日及流日宫位
+- 完整四化系统（本命/大限/小限/流年/流月/流日）
+
+闰月使用负数表示（如 -6 表示闰六月）。
+
+用于精细的日期选择。`,
+                inputSchema: schemaToJson(ZiweiLiuRiListSchema),
+            },
+        ],
+    };
+});
+// ============================================
+// Tool Handlers
+// ============================================
+const baziService = new BaziService_1.BaziService({ debug: false });
+const ziweiService = new ZiweiService_1.ZiweiService();
+// Helper: Calculate year stem and branch
+function getYearStemBranch(year) {
+    const STEMS = ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸'];
+    const BRANCHES = ['子', '丑', '寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥'];
+    const baseYear = 1984; // 甲子年
+    const yearDiff = year - baseYear;
+    const stemIndex = ((yearDiff % 10) + 10) % 10;
+    const branchIndex = ((yearDiff % 12) + 12) % 12;
+    return { stem: STEMS[stemIndex], branch: BRANCHES[branchIndex] };
+}
+// Helper: Parse GanZhi year input
+function parseGanzhiYear(input) {
+    if (typeof input === 'number') {
+        const { stem, branch } = getYearStemBranch(input);
+        return { year: input, ganzhi: stem + branch };
+    }
+    // Parse GanZhi string to find year - search nearby years
+    const currentYear = new Date().getFullYear();
+    for (let y = currentYear - 60; y <= currentYear + 60; y++) {
+        const { stem, branch } = getYearStemBranch(y);
+        if (stem + branch === input) {
+            return { year: y, ganzhi: input };
+        }
+    }
+    // Default to current year if not found
+    const { stem, branch } = getYearStemBranch(currentYear);
+    return { year: currentYear, ganzhi: stem + branch };
+}
+// Helper: Parse GanZhi month input
+function parseGanzhiMonth(input) {
+    if (typeof input === 'number') {
+        return input; // 1-12
+    }
+    // Parse GanZhi month string to get month index
+    const BRANCHES = ['寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥', '子', '丑'];
+    const branch = input.substring(1, 2);
+    const idx = BRANCHES.indexOf(branch);
+    return idx >= 0 ? idx + 1 : 1;
+}
+// Helper: Get month stem branch for a given year and month
+function getMonthStemBranch(year, monthNum) {
+    const STEMS = ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸'];
+    const BRANCHES = ['寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥', '子', '丑'];
+    // Month branch: monthNum 1 = 寅, 2 = 卯, ..., 12 = 丑
+    const branch = BRANCHES[(monthNum - 1) % 12];
+    // Month stem depends on year stem
+    const { stem: yearStem } = getYearStemBranch(year);
+    const yearStemIndex = STEMS.indexOf(yearStem);
+    // 五虎遁年起月诀
+    const firstMonthStemMap = {
+        0: 2, // 甲年 -> 丙寅月
+        1: 4, // 乙年 -> 戊寅月
+        2: 6, // 丙年 -> 庚寅月
+        3: 8, // 丁年 -> 壬寅月
+        4: 0, // 戊年 -> 甲寅月
+        5: 2, // 己年 -> 丙寅月
+        6: 4, // 庚年 -> 戊寅月
+        7: 6, // 辛年 -> 庚寅月
+        8: 8, // 壬年 -> 壬寅月
+        9: 0 // 癸年 -> 甲寅月
+    };
+    const firstMonthStemIndex = firstMonthStemMap[yearStemIndex];
+    const monthStemIndex = (firstMonthStemIndex + monthNum - 1) % 10;
+    return { stem: STEMS[monthStemIndex], branch };
+}
+server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    logger.info(`Tool called: ${name}`, args);
+    try {
+        // === Existing Chart Calculation Handlers ===
+        if (name === "bazi_basic") {
+            const validated = BaziCalculateSchema.parse(args);
+            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,
+            });
+            // 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);
+                if (liuNians.length > 0) {
+                    const liunian = liuNians[0];
+                    liuNianInfo = `\n\n=== 流年 ${validated.targetYear} ===\n干支：${liunian.stem}${liunian.branch}`;
+                }
+            }
+            const options = {
+                detail: validated.detail,
+                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);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: text + liuNianInfo,
+                    },
+                ],
+            };
+        }
+        if (name === "ziwei_basic") {
+            const validated = ZiweiCalculateSchema.parse(args);
+            const result = await ziweiService.calculate({
+                year: validated.year,
+                month: validated.month,
+                day: validated.day,
+                hour: validated.hour,
+                gender: validated.gender,
+            });
+            const options = {
+                detail: validated.detail,
+                includePersonal: false,
+            };
+            const birthDate = new Date(validated.year, validated.month - 1, validated.day, validated.hour, validated.minute);
+            const text = (0, fortuneTextRenderer_1.renderZiweiText)({
+                ziwei: result,
+                gender: validated.gender,
+                birthDate,
+                mutagen: result.mutagenInfo // 傳入四化信息
+            }, options);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text,
+                    },
+                ],
+            };
+        }
+        // === BaZi List Tool Handlers ===
+        if (name === "bazi_dayun") {
+            const validated = BaziDaYunListSchema.parse(args);
+            // 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,
+            });
+            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 });
+            // Get direction and start info
+            const direction = LuckCycleCalculator_1.LuckCycleCalculator.calLuckySequence(validated.gender, result.chart.year.stem) === 'forward' ? '顺行' : '逆行';
+            const startAge = daYunList.length > 0 ? daYunList[0].startAge : 1;
+            const startYear = validated.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,
+                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 },
+                dayPillar: { stem: result.chart.day.stem, branch: result.chart.day.branch },
+                hourPillar: { stem: result.chart.hour.stem, branch: result.chart.hour.branch },
+                direction,
+                startAge,
+                startYear,
+            };
+            const text = (0, listTextRenderer_1.renderBaziDaYunList)(daYunList.slice(0, validated.count), options);
+            return { content: [{ type: "text", text }] };
+        }
+        if (name === "bazi_liunian") {
+            const validated = BaziLiuNianListSchema.parse(args);
+            // 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,
+            });
+            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 });
+            // Calculate LiuNian for the range
+            const liuNianList = LiuNianCalculator_1.LiuNianCalculator.calculate(result.chart, validated.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,
+                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 },
+                dayPillar: { stem: result.chart.day.stem, branch: result.chart.day.branch },
+                hourPillar: { stem: result.chart.hour.stem, branch: result.chart.hour.branch },
+                startYear: validated.startYear,
+                endYear: validated.endYear,
+                daYunList,
+            };
+            const text = (0, listTextRenderer_1.renderBaziLiuNianList)(liuNianList, options);
+            return { content: [{ type: "text", text }] };
+        }
+        if (name === "bazi_liuyue") {
+            const validated = BaziLiuYueListSchema.parse(args);
+            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,
+            });
+            if (!result.chart || !result.birthInfo) {
+                throw new Error("Failed to calculate BaZi chart");
+            }
+            // 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 });
+            // Calculate age for the target year (虛歲)
+            const targetAge = gregorianYear - validated.year + 1;
+            // Find current DaYun
+            let currentDaYun;
+            const matchedDaYun = daYunList.find(dy => targetAge >= dy.startAge && targetAge <= dy.endAge);
+            if (matchedDaYun) {
+                currentDaYun = {
+                    stem: matchedDaYun.stem,
+                    branch: matchedDaYun.branch,
+                    startAge: matchedDaYun.startAge,
+                    endAge: matchedDaYun.endAge,
+                };
+            }
+            // Calculate current LiuNian
+            const liuNianList = LiuNianCalculator_1.LiuNianCalculator.calculate(result.chart, validated.year, gregorianYear, gregorianYear);
+            let currentLiuNian;
+            if (liuNianList.length > 0) {
+                const ln = liuNianList[0];
+                currentLiuNian = {
+                    stem: ln.stem,
+                    branch: ln.branch,
+                    age: ln.age,
+                };
+            }
+            // 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,
+            }, gregorianYear);
+            const options = {
+                name: validated.name,
+                birthYear: validated.year,
+                birthMonth: validated.month,
+                birthDay: validated.day,
+                birthHour: validated.hour,
+                birthMinute: validated.minute,
+                gender: validated.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 },
+                dayPillar: { stem: result.chart.day.stem, branch: result.chart.day.branch },
+                hourPillar: { stem: result.chart.hour.stem, branch: result.chart.hour.branch },
+                ganzhiYear,
+                gregorianYear,
+                currentDaYun,
+                currentLiuNian,
+            };
+            const text = (0, listTextRenderer_1.renderBaziLiuYueList)(liuYueList, options);
+            return { content: [{ type: "text", text }] };
+        }
+        if (name === "bazi_liuri") {
+            const validated = BaziLiuRiListSchema.parse(args);
+            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,
+            });
+            if (!result.chart || !result.birthInfo) {
+                throw new Error("Failed to calculate BaZi chart");
+            }
+            // Get year and month stem/branch
+            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 });
+            // Calculate age for the target year (虛歲)
+            const targetAge = gregorianYear - validated.year + 1;
+            // Find current DaYun
+            let currentDaYun;
+            const matchedDaYun = daYunList.find(dy => targetAge >= dy.startAge && targetAge <= dy.endAge);
+            if (matchedDaYun) {
+                currentDaYun = {
+                    stem: matchedDaYun.stem,
+                    branch: matchedDaYun.branch,
+                    startAge: matchedDaYun.startAge,
+                    endAge: matchedDaYun.endAge,
+                };
+            }
+            // Calculate current LiuNian
+            const liuNianList = LiuNianCalculator_1.LiuNianCalculator.calculate(result.chart, validated.year, gregorianYear, gregorianYear);
+            let currentLiuNian;
+            if (liuNianList.length > 0) {
+                const ln = liuNianList[0];
+                currentLiuNian = {
+                    stem: ln.stem,
+                    branch: ln.branch,
+                    age: ln.age,
+                };
+            }
+            // Current LiuYue info
+            const currentLiuYue = {
+                stem: monthStem,
+                branch: monthBranch,
+                month: monthNum,
+            };
+            // Calculate LiuRi
+            const calculator = new LiuRiCalculator_1.LiuRiCalculator();
+            const liuRiList = calculator.calculateLiuRi(monthStem, monthBranch, yearStem, yearBranch, (result.basic?.dayMasterElement || '木'), (result.traditional?.yongShen?.yongShen || []), gregorianYear, monthNum);
+            // Get the first and last date from the calculated list
+            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,
+                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 },
+                dayPillar: { stem: result.chart.day.stem, branch: result.chart.day.branch },
+                hourPillar: { stem: result.chart.hour.stem, branch: result.chart.hour.branch },
+                ganzhiMonth: monthStem + monthBranch,
+                ganzhiYear,
+                gregorianYear,
+                startDate,
+                endDate,
+                currentDaYun,
+                currentLiuNian,
+                currentLiuYue,
+            };
+            const text = (0, listTextRenderer_1.renderBaziLiuRiList)(liuRiList, options);
+            return { content: [{ type: "text", text }] };
+        }
+        // === ZiWei List Tool Handlers ===
+        if (name === "ziwei_daxian") {
+            const validated = ZiweiDaXianListSchema.parse(args);
+            // Calculate ZiWei chart
+            const result = ziweiService.calculate({
+                year: validated.year,
+                month: validated.month,
+                day: validated.day,
+                hour: validated.hour,
+                gender: validated.gender,
+            });
+            if (!result.decades || result.decades.length === 0) {
+                throw new Error("Failed to calculate ZiWei decades");
+            }
+            // Determine direction
+            const yangStems = ['甲', '丙', '戊', '庚', '壬'];
+            const yearStem = result.basicInfo?.fourPillars?.year?.stem || '';
+            const isYang = yangStems.includes(yearStem);
+            const isMale = validated.gender === 'male';
+            const direction = ((isYang && isMale) || (!isYang && !isMale)) ? '顺行' : '逆行';
+            // Find Ming Gong stars
+            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) || [];
+            // Find Shen Gong
+            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,
+                mingGong: mingGongPalace?.name || '命宮',
+                mingGongStars,
+                shenGong: shenGongPalace?.name,
+                shenGongStars,
+                palaces: result.palaces, // 传入完整宫位数据
+                mutagenInfo: result.mutagenInfo, // 传入四化信息
+                direction,
+            };
+            const text = (0, listTextRenderer_1.renderZiweiDaXianList)(result.decades.slice(0, validated.count), options);
+            return { content: [{ type: "text", text }] };
+        }
+        if (name === "ziwei_xiaoxian") {
+            const validated = ZiweiXiaoXianListSchema.parse(args);
+            const result = ziweiService.calculate({
+                year: validated.year,
+                month: validated.month,
+                day: validated.day,
+                hour: validated.hour,
+                gender: validated.gender,
+            });
+            if (!result.palaces) {
+                throw new Error("Failed to calculate ZiWei chart");
+            }
+            const minorLimitList = ziweiService.getMinorLimitRange(validated.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;
+            let currentDecade;
+            if (result.decades && result.decades.length > 0) {
+                const matchedDecade = result.decades.find(d => currentAge >= d.startAge && currentAge <= d.endAge);
+                if (matchedDecade) {
+                    currentDecade = {
+                        palaceName: matchedDecade.palaceName || result.palaces?.[matchedDecade.palaceIndex]?.name || '未知',
+                        startAge: matchedDecade.startAge,
+                        endAge: matchedDecade.endAge,
+                    };
+                }
+            }
+            const options = {
+                name: validated.name,
+                birthYear: validated.year,
+                birthMonth: validated.month,
+                birthDay: validated.day,
+                birthHour: validated.hour,
+                birthMinute: validated.minute,
+                gender: validated.gender,
+                mingGong: mingGongPalace?.name || '命宮',
+                mingGongStars,
+                palaces: result.palaces,
+                mutagenInfo: result.mutagenInfo,
+                startAge: validated.startAge,
+                endAge: validated.endAge,
+                currentDecade,
+                decades: result.decades,
+            };
+            const text = (0, listTextRenderer_1.renderZiweiXiaoXianList)(minorLimitList, options);
+            return { content: [{ type: "text", text }] };
+        }
+        if (name === "ziwei_liunian") {
+            const validated = ZiweiLiuNianListSchema.parse(args);
+            // Calculate ZiWei chart
+            const result = ziweiService.calculate({
+                year: validated.year,
+                month: validated.month,
+                day: validated.day,
+                hour: validated.hour,
+                gender: validated.gender,
+            });
+            if (!result.palaces) {
+                throw new Error("Failed to calculate ZiWei chart");
+            }
+            // 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);
+                if (yearly) {
+                    yearlyList.push(yearly);
+                }
+            }
+            // Find Ming Gong
+            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,
+                mingGong: mingGongPalace?.name || '命宮',
+                mingGongStars,
+                palaces: result.palaces, // 传入完整宫位数据
+                mutagenInfo: result.mutagenInfo, // 传入四化信息
+                startYear: validated.startYear,
+                endYear: validated.endYear,
+                decades: result.decades, // 传入大限列表用于匹配所属大限
+            };
+            const text = (0, listTextRenderer_1.renderZiweiLiuNianList)(yearlyList, options);
+            return { content: [{ type: "text", text }] };
+        }
+        if (name === "ziwei_liuyue") {
+            const validated = ZiweiLiuYueListSchema.parse(args);
+            // Calculate ZiWei chart
+            const result = ziweiService.calculate({
+                year: validated.year,
+                month: validated.month,
+                day: validated.day,
+                hour: validated.hour,
+                gender: validated.gender,
+            });
+            // Get yearly months (农历月)
+            const monthlyList = ziweiService.getYearlyMonths(validated.lunarYear);
+            // Find Ming Gong
+            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) || [];
+            // Check for leap month in this lunar year
+            const lunar = lunar_javascript_1.Lunar.fromYmd(validated.lunarYear, 1, 1);
+            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;
+            // Find current decade (大限)
+            let currentDecade;
+            if (result.decades && result.decades.length > 0) {
+                const matchedDecade = result.decades.find(d => targetAge >= d.startAge && targetAge <= d.endAge);
+                if (matchedDecade) {
+                    currentDecade = {
+                        palaceName: matchedDecade.palaceName || result.palaces?.[matchedDecade.palaceIndex]?.name || '未知',
+                        startAge: matchedDecade.startAge,
+                        endAge: matchedDecade.endAge,
+                    };
+                }
+            }
+            // Calculate current yearly (流年)
+            const yearlyInfo = YearlyCalculator_1.YearlyCalculator.calculate(validated.lunarYear, validated.year, result.palaces);
+            let currentYearly;
+            if (yearlyInfo) {
+                const { stem: yearStem, branch: yearBranch } = getYearStemBranch(validated.lunarYear);
+                currentYearly = {
+                    year: validated.lunarYear,
+                    age: targetAge,
+                    palaceName: result.palaces?.[yearlyInfo.palaceIndex]?.name || '未知',
+                    heavenlyStem: yearStem,
+                    earthlyBranch: yearBranch,
+                };
+            }
+            // Calculate current minor limit (小限)
+            const minorLimitInfo = ziweiService.getMinorLimitInfo(validated.year, validated.lunarYear);
+            let currentMinorLimit;
+            if (minorLimitInfo) {
+                currentMinorLimit = {
+                    age: minorLimitInfo.age,
+                    palaceName: result.palaces?.[minorLimitInfo.palaceIndex]?.name || '未知',
+                    heavenlyStem: minorLimitInfo.heavenlyStem,
+                    earthlyBranch: minorLimitInfo.earthlyBranch,
+                };
+            }
+            // 添加小限四化到 mutagenInfo
+            const enhancedMutagenInfo = { ...result.mutagenInfo };
+            if (minorLimitInfo?.heavenlyStem) {
+                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,
+                mingGong: mingGongPalace?.name || '命宮',
+                mingGongStars,
+                palaces: result.palaces,
+                mutagenInfo: enhancedMutagenInfo,
+                lunarYear: validated.lunarYear,
+                gregorianYear: validated.lunarYear,
+                leapMonth: typeof leapMonth === 'number' ? leapMonth : undefined,
+                currentDecade,
+                currentMinorLimit,
+                currentYearly,
+            };
+            const text = (0, listTextRenderer_1.renderZiweiLiuYueList)(monthlyList, options);
+            return { content: [{ type: "text", text }] };
+        }
+        if (name === "ziwei_liuri") {
+            const validated = ZiweiLiuRiListSchema.parse(args);
+            // Calculate ZiWei chart
+            const result = ziweiService.calculate({
+                year: validated.year,
+                month: validated.month,
+                day: validated.day,
+                hour: validated.hour,
+                gender: validated.gender,
+            });
+            // Handle leap month (negative number)
+            const isLeapMonth = validated.lunarMonth < 0;
+            const actualMonth = Math.abs(validated.lunarMonth);
+            // Get lunar month boundaries
+            const monthParam = isLeapMonth ? -actualMonth : actualMonth;
+            const lunarFirstDay = lunar_javascript_1.Lunar.fromYmd(validated.lunarYear, monthParam, 1);
+            // Find last day of the month
+            let lastDayNum = 29;
+            try {
+                lunar_javascript_1.Lunar.fromYmd(validated.lunarYear, monthParam, 30);
+                lastDayNum = 30;
+            }
+            catch {
+                // Month only has 29 days
+            }
+            const lunarLastDay = lunar_javascript_1.Lunar.fromYmd(validated.lunarYear, monthParam, lastDayNum);
+            // Convert to solar dates
+            const firstSolar = lunarFirstDay.getSolar();
+            const lastSolar = lunarLastDay.getSolar();
+            const startDate = new Date(firstSolar.getYear(), firstSolar.getMonth() - 1, firstSolar.getDay());
+            const endDate = new Date(lastSolar.getYear(), lastSolar.getMonth() - 1, lastSolar.getDay());
+            // Build daily list
+            const dailyList = [];
+            for (let day = 1; day <= lastDayNum; day++) {
+                try {
+                    const lunarDay = lunar_javascript_1.Lunar.fromYmd(validated.lunarYear, monthParam, day);
+                    const solarDay = lunarDay.getSolar();
+                    const solarDate = new Date(solarDay.getYear(), solarDay.getMonth() - 1, solarDay.getDay());
+                    // Get daily info from calculator
+                    const dailyInfo = ziweiService.getDailyInfo(solarDay.getYear(), solarDay.getMonth(), solarDay.getDay());
+                    dailyList.push({
+                        lunarMonth: actualMonth,
+                        lunarDay: day,
+                        isLeapMonth,
+                        gregorianDate: solarDate,
+                        ganzhi: dailyInfo ? `${dailyInfo.heavenlyStem}${dailyInfo.earthlyBranch}` : '',
+                        palaceIndex: dailyInfo?.palaceIndex || 0,
+                    });
+                }
+                catch (e) {
+                    // Skip invalid dates
+                }
+            }
+            // Find Ming Gong
+            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) || [];
+            // Get monthly palace
+            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;
+            // Find current decade (大限)
+            let currentDecade;
+            if (result.decades && result.decades.length > 0) {
+                const matchedDecade = result.decades.find(d => targetAge >= d.startAge && targetAge <= d.endAge);
+                if (matchedDecade) {
+                    currentDecade = {
+                        palaceName: matchedDecade.palaceName || result.palaces?.[matchedDecade.palaceIndex]?.name || '未知',
+                        startAge: matchedDecade.startAge,
+                        endAge: matchedDecade.endAge,
+                    };
+                }
+            }
+            // Calculate current yearly (流年)
+            const yearlyInfo = YearlyCalculator_1.YearlyCalculator.calculate(validated.lunarYear, validated.year, result.palaces);
+            let currentYearly;
+            if (yearlyInfo) {
+                const { stem: yearStem, branch: yearBranch } = getYearStemBranch(validated.lunarYear);
+                currentYearly = {
+                    year: validated.lunarYear,
+                    age: targetAge,
+                    palaceName: result.palaces?.[yearlyInfo.palaceIndex]?.name || '未知',
+                    heavenlyStem: yearStem,
+                    earthlyBranch: yearBranch,
+                };
+            }
+            // Current monthly info (流月)
+            let currentMonthly;
+            if (monthlyInfo) {
+                currentMonthly = {
+                    month: actualMonth,
+                    palaceName: result.palaces?.[monthlyInfo.palaceIndex]?.name || '未知',
+                    heavenlyStem: monthlyInfo.heavenlyStem,
+                    earthlyBranch: monthlyInfo.earthlyBranch,
+                };
+            }
+            // Calculate current minor limit (小限)
+            const minorLimitInfo = ziweiService.getMinorLimitInfo(validated.year, validated.lunarYear);
+            let currentMinorLimit;
+            if (minorLimitInfo) {
+                currentMinorLimit = {
+                    age: minorLimitInfo.age,
+                    palaceName: result.palaces?.[minorLimitInfo.palaceIndex]?.name || '未知',
+                    heavenlyStem: minorLimitInfo.heavenlyStem,
+                    earthlyBranch: minorLimitInfo.earthlyBranch,
+                };
+            }
+            // 计算小限四化和流月四化
+            const enhancedMutagenInfo = { ...result.mutagenInfo };
+            if (minorLimitInfo?.heavenlyStem) {
+                enhancedMutagenInfo.minorLimit = MutagenCore_1.MutagenCore.getMutagen(minorLimitInfo.heavenlyStem) || undefined;
+            }
+            if (monthlyInfo?.heavenlyStem) {
+                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,
+                mingGong: mingGongPalace?.name || '命宮',
+                mingGongStars,
+                palaces: result.palaces,
+                mutagenInfo: enhancedMutagenInfo,
+                lunarYear: validated.lunarYear,
+                lunarMonth: actualMonth,
+                isLeapMonth,
+                gregorianStartDate: startDate,
+                gregorianEndDate: endDate,
+                monthlyPalace,
+                currentDecade,
+                currentMinorLimit,
+                currentYearly,
+                currentMonthly,
+            };
+            const text = (0, listTextRenderer_1.renderZiweiLiuRiList)(dailyList, options);
+            return { content: [{ type: "text", text }] };
+        }
+        throw new Error(`Unknown tool: ${name}`);
+    }
+    catch (error) {
+        logger.error(`Tool ${name} failed`, error);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error: ${errorMessage}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// ============================================
+// Start Server
+// ============================================
+async function main() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    logger.info("Mingpan MCP server started (v0.1.1)");
+}
+main().catch((error) => {
+    logger.error("Server failed to start", error);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map