cn-time-parser 1.0.1 → 1.1.1

package/.trae/skills/cn-time-parser/SKILL.md

@@ -0,0 +1,131 @@
+---
+name: "cn-time-parser"
+description: "智能识别中文时间关键词并转换为具体日期和时间戳；使用lunisolar模块处理农历计算，chinese-workday模块处理节日和工作日判断；支持解析复杂农历日期和判断节假日；当用户需要解析自然语言中的时间信息、计算特定日期、处理农历节日转换时使用"
+---
+
+# 时间解析器
+
+## 任务目标
+- 本Skill用于：解析中文自然语言中的时间关键词，转换为具体的日期和时间戳
+- 能力包含：识别常见中文时间关键词（今天、昨天、明天、前天、今年、去年等）、处理传统农历节日、解析具体农历日期（如农历二月二十五）、判断工作日和节假日、计算特定日期的时间戳
+- 触发条件：用户提问中包含时间相关关键词，需要获取具体日期或时间戳
+
+## 前置准备
+- 依赖说明：需要安装Node.js环境，以及dayjs、lunisolar和chinese-workday模块
+- 准备命令：在使用前执行 `npm install`
+
+## 全局安装（可选）
+### 安装为全局命令
+```bash
+npm install -g .
+```
+
+### 使用 npm link（开发时推荐）
+```bash
+npm link
+```
+链接后本地修改即时生效，无需重复安装。卸载链接：`npm unlink -g cn-time-parser`
+
+### 全局使用
+安装/链接后可以直接在任何位置使用：
+```bash
+cn-time-parser -q "今天"
+cn-time-parser "农历二月二十五"
+cn-time-parser --help
+```
+
+## 操作步骤
+- 标准流程：
+  1. 分析用户提问，提取时间关键词
+  2. 调用脚本处理时间关键词：
+     - 脚本调用示例：`cn-time-parser --query "今天"`
+  3. 根据返回的具体日期进行后续操作
+- 可选分支：
+  - 当检测到农历节日关键词时：使用lunisolar模块进行农历转换
+  - 当需要判断节假日时：使用chinese-workday模块获取节日信息和工作日判断
+  - 当需要时间戳时：自动生成Unix时间戳
+
+## 使用示例
+- 示例1：
+  - 场景/输入：用户问"明天是什么日子"
+  - 预期产出：解析出明天的具体日期（如2026-05-09）
+  - 关键要点：根据当前系统时间计算明天
+- 示例2：
+  - 场景/输入：用户问"去年过年是哪一天"
+  - 预期产出：解析出去年春节的具体日期
+  - 关键要点：使用农历转换功能
+- 示例3：
+  - 场景/输入：用户问"黄龙的生日是农历二月二十五，明年他的生日是公历的哪一天？"
+  - 预期产出：解析出明年农历二月二十五对应的公历日期
+  - 关键要点：支持解析具体农历日期并进行年份调整
+- 示例4：
+  - 场景/输入：用户问"今年五一是不是工作日？"
+  - 预期产出：解析出五一的日期，并提供isWorkday和isHoliday字段
+  - 关键要点：使用chinese-workday模块判断节假日
+- 示例5：
+  - 场景/输入：用户问"国庆节是哪一天"
+  - 预期产出：解析出今年国庆节的日期（默认当年）
+  - 关键要点：节日名称不带年份前缀时默认使用当前年份
+- 示例6：
+  - 场景/输入：用户问"清明节"
+  - 预期产出：解析出今年清明节的日期（基于节气计算）
+  - 关键要点：清明节是节气节日，日期在4月4-5日间浮动
+- 示例7：
+  - 场景/输入：用户问"元宵节"
+  - 预期产出：解析出今年元宵节的日期（农历正月十五）
+  - 关键要点：元宵节是农历节日，通过lunisolar转换
+
+## CLI命令行使用
+### 基础调用方式
+- `cn-time-parser --query "今天"` - 使用--query参数
+- `cn-time-parser -q "明天"` - 使用-q快捷参数
+- `cn-time-parser "农历二月二十五"` - 直接传入位置参数
+
+### 输出格式选项
+- `--format json` - JSON格式输出（默认）
+- `--format text` - 文本格式输出
+- `--format simple` - 仅输出日期
+
+### 其他选项
+- `--examples` - 显示使用示例
+- `--help` - 显示帮助信息
+- `--year 2025` - 指定年份（用于农历日期转换）
+- `--verbose, -v` - 显示详细信息
+- `--version` - 显示版本号
+
+### npm脚本
+- `npm test` - 运行测试
+- `npm start` - 启动程序
+- `npm run examples` - 显示示例
+
+## JSON 输出字段说明
+成功时返回以下 JSON 结构：
+| 字段 | 说明 | 示例 |
+|---|---|---|
+| `success` | 是否解析成功 | `true` / `false` |
+| `originalQuery` | 原始输入 | `"今天"` |
+| `parsedDate` | 解析后的公历日期（YYYY-MM-DD） | `"2026-05-08"` |
+| `timestamp` | Unix 毫秒时间戳 | `1778212479463` |
+| `lunarInfo.year` | 农历年份 | `2026` |
+| `lunarInfo.month` | 农历月份 | `1` |
+| `lunarInfo.day` | 农历日 | `1` |
+| `lunarInfo.isLeapMonth` | 是否为闰月 | `false` |
+| `lunarInfo.zodiac` | 生肖 | `"马"` |
+| `lunarInfo.term` | 节气 | `"立春"` |
+| `festivalInfo` | 节日/假期名称 | `"春节"` / `"清明节"` / `"周末"` / `"工作日"` |
+| `isWorkday` | 是否为工作日 | `true` / `false` |
+| `isHoliday` | 是否为法定节假日 | `true` / `false` |
+| `matchedKeyword` | 匹配到的关键词 | `"今年五一"` |
+
+## 资源索引
+- 脚本：见 `scripts/parse-time.js`（用途与参数：解析时间关键词，支持--query参数传入用户提问；支持全局安装作为命令行工具使用）
+- 参考：见 `references/time-keywords.md`（何时读取：需要了解所有支持的时间关键词时）
+- 安装指南：见 `INSTALL.md`（何时读取：需要了解如何全局安装和使用命令行工具时）
+
+## 注意事项
+- 脚本会根据当前系统时间进行计算，确保系统时间准确
+- 农历转换基于lunisolar库，支持常见传统节日
+- 节假日和工作日判断基于chinese-workday库
+- 时间戳为毫秒级Unix时间戳
+- `lunarInfo` 中的 `zodiac` 和 `term` 字段可能为 `null`，取决于 lunisolar 库对当前日期的数据覆盖
+- `festivalInfo` 除具体节日名称外，也可能返回 `"周末"`、`"工作日"`、`"补劳动节"` 等描述

package/INSTALL.md

@@ -1,54 +1,51 @@
 # 安装和使用指南
 
-## 本地运行（无需安装）
-
-在项目目录下直接使用 Node.js 运行：
+## 全局安装
 
 ```bash
-cd /path/to/cn-time-parser
-npm install                    # 首次使用前安装依赖
-node scripts/parse-time.js -q "今天"
-node scripts/parse-time.js "农历二月二十五"
+npm install -g cn-time-parser
 ```
 
-也可通过 npm scripts 快速启动：
+### 验证安装
 
 ```bash
-npm start -- --query "今天"   # run start 脚本
-npm test                       # 运行测试（查询"今天"）
-npm run examples               # 显示使用示例
+cn-time-parser --version
+cn-time-parser --help
+cn-time-parser --examples
 ```
 
-## 全局安装
+## MCP 模式
 
-### 方式一：npm link（开发时推荐）
+支持作为 MCP (Model Context Protocol) Server 使用，可集成到支持 MCP 的 AI 助手中。
 
-将项目链接到全局，本地修改即时生效：
 
-```bash
-cd /path/to/cn-time-parser
-npm link
-```
+### AI 助手配置
 
-之后可直接使用 `cn-time-parser` 命令。解除链接：
+在 AI 助手的 MCP 配置文件中添加：
 
-```bash
-npm unlink -g cn-time-parser
+```json
+{
+  "mcpServers": {
+    "cn-time-parser": {
+      "command": "cn-time-parser-mcp"
+    }
+  }
+}
 ```
 
-### 方式二：npm install -g（正式安装）
+### MCP 工具使用
 
-```bash
-cd /path/to/cn-time-parser
-npm install -g .
-```
+**工具名称：** `parse_chinese_time`
 
-### 验证安装
+**输入参数：**
+- `query` (string, 必填) - 时间关键词查询
+- `year` (number, 可选) - 指定年份
+
+**示例：**
 
-```bash
-cn-time-parser --version
-cn-time-parser --help
-cn-time-parser --examples
+```
+用户：明天是什么日子？
+AI 调用：parse_chinese_time({ query: "明天" })
 ```
 
 ## 使用方法
@@ -126,4 +123,4 @@ npm uninstall -g cn-time-parser
 ### npm link 解除
 ```bash
 npm unlink -g cn-time-parser
-```
+```

package/README.md

@@ -12,17 +12,76 @@
 - **节日匹配** — 春节、五一、国庆、元旦、清明、元宵，支持 `今年/去年/明年` 前缀
 - **输出信息** — 公历日期、Unix 毫秒时间戳、农历信息、生肖、节气、工作日/节假日判断
 
+## 快速开始
 
-### 全局安装
+```bash
+# 安装依赖
+npm install -g cn-time-parser
+
+# CLI 模式
+cn-time-parser "今天"
+cn-time-parser "农历二月二十五"
+
+# MCP 模式（AI 助手集成）
+cn-time-parser-mcp
+```
+
+## MCP 模式
+
+支持作为 MCP (Model Context Protocol) Server 使用，可集成到支持 MCP 的 AI 助手中。
+
+### 安装 MCP Server
 
 ```bash
+# 全局安装
 npm install -g cn-time-parser
 ```
 
+### AI 助手配置
 
-## CLI 用法
+在 AI 助手的 MCP 配置中添加：
+
+```json
+{
+  "mcpServers": {
+    "cn-time-parser": {
+      "command": "cn-time-parser-mcp"
+    }
+  }
+}
+```
+
+### MCP 工具
+
+**工具名称：** `parse_chinese_time`
+
+**输入参数：**
 
+| 参数 | 类型 | 必填 | 说明 |
+|------|------|------|------|
+| `query` | string | 是 | 时间关键词查询，如"今天"、"农历二月二十五" |
+| `year` | number | 否 | 指定年份，默认为当前年份 |
+
+**使用示例：**
+
+```
+用户：明天是什么日子？
+AI 调用：parse_chinese_time({ query: "明天" })
+AI 返回：{
+  "success": true,
+  "originalQuery": "明天",
+  "parsedDate": "2026-05-09",
+  "timestamp": 1778294400000,
+  "festivalInfo": "周末",
+  "isWorkday": false,
+  "isHoliday": false,
+  "matchedKeyword": "明天"
+}
 ```
+
+## CLI 用法
+
+```bash
 cn-time-parser [选项] [查询...]
 ```
 
@@ -149,7 +208,8 @@ cn-time-parser "农历二月二十五" --year 2025
 - [lunisolar](https://github.com/magiclav/Lunisolar) — 农历/公历转换
 - [chinese-workday](https://github.com/nicedoc/chinese-workday) — 中国节假日判断
 - [argparse](https://github.com/nodeca/argparse) — CLI 参数解析
+- [@modelcontextprotocol/sdk](https://github.com/modelcontextprotocol/sdk) — MCP Server SDK
 
 ## 许可证
 
-MIT
+MIT

package/package.json

@@ -1,24 +1,31 @@
 {
   "name": "cn-time-parser",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "type": "module",
   "description": "智能识别中文时间关键词并转换为具体日期和时间戳",
   "main": "scripts/parse-time.js",
   "bin": {
-    "cn-time-parser": "./scripts/parse-time.js"
+    "cn-time-parser": "./scripts/parse-time.js",
+    "cn-time-parser-mcp": "./scripts/mcp-server.js"
   },
   "scripts": {
-    "test": "node scripts/parse-time.js --query '今天'",
+    "test": "node scripts/parse-time.js --query 今天",
     "start": "node scripts/parse-time.js",
     "examples": "node scripts/parse-time.js --examples"
   },
   "dependencies": {
-    "dayjs": "^1.11.10",
-    "lunisolar": "^2.0.2",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "argparse": "^2.0.1",
-    "chinese-workday": "^1.11.0"
+    "chinese-workday": "^1.11.0",
+    "dayjs": "^1.11.10",
+    "lunisolar": "^2.0.2"
   },
-  "keywords": ["time", "parser", "chinese", "lunar"],
-  "author": "",
+  "keywords": [
+    "time",
+    "parser",
+    "chinese",
+    "lunar"
+  ],
+  "author": "as3long",
   "license": "MIT"
 }

package/scripts/mcp-server.js

@@ -0,0 +1,431 @@
+#!/usr/bin/env node
+
+import { fileURLToPath } from 'url';
+import { resolve } from 'path';
+import { realpathSync } from 'fs';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+
+import dayjs from 'dayjs';
+import lunisolar from 'lunisolar';
+import * as chineseWorkday from 'chinese-workday';
+
+const { isWorkday, isHoliday, getFestival } = chineseWorkday;
+
+const chineseNumbers = {
+  '零': 0, '〇': 0, '一': 1, '二': 2, '两': 2, '三': 3, '四': 4,
+  '五': 5, '六': 6, '七': 7, '八': 8, '九': 9, '十': 10,
+  '廿': 20, '卅': 30
+};
+
+function parseChineseNumber(text) {
+  if (!text) return null;
+  if (text === '正') return 1;
+  if (/^\d+$/.test(text)) return parseInt(text);
+
+  let result = 0;
+  let temp = 0;
+
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+    if (char === '十') {
+      if (temp === 0) temp = 1;
+      result += temp * 10;
+      temp = 0;
+    } else if (char === '廿') {
+      result += 20;
+    } else if (char === '卅') {
+      result += 30;
+    } else if (chineseNumbers[char] !== undefined) {
+      temp = chineseNumbers[char];
+    }
+  }
+  result += temp;
+  return result > 0 ? result : null;
+}
+
+function parseLunarDate(query, baseYear) {
+  let processedQuery = query.replace(/正月/g, '一月');
+
+  const lunarPatterns = [
+    {
+      regex: /农历(\d{4})年?(?:闰)?(\S+?)月(\S+?)(?=$|[，。！？、；：""''（）【】\s]|日|号)/,
+      handler: (match) => {
+        const year = parseInt(match[1]);
+        const monthStr = match[2] === '正' ? '一' : match[2];
+        const month = parseChineseNumber(monthStr);
+        const day = parseChineseNumber(match[3]);
+        const isLeap = match[0].includes('闰');
+        return { year, month, day, isLeap, fullMatch: match[0] };
+      }
+    },
+    {
+      regex: /(今年|去年|明年|后年|前年).*?农历(?:闰)?(\S+?)月(\S+?)(?=$|[，。！？、；：""''（）【】\s]|日|号)/,
+      handler: (match) => {
+        const yearModifier = match[1];
+        let year = baseYear;
+        if (yearModifier === '去年') year -= 1;
+        if (yearModifier === '明年') year += 1;
+        if (yearModifier === '后年') year += 2;
+        if (yearModifier === '前年') year -= 2;
+
+        const monthStr = match[2] === '正' ? '一' : match[2];
+        const month = parseChineseNumber(monthStr);
+        const day = parseChineseNumber(match[3]);
+        const isLeap = match[0].includes('闰');
+        return { year, month, day, isLeap, fullMatch: match[0] };
+      }
+    },
+    {
+      regex: /农历(今年|去年|明年|后年|前年)(?:闰)?(\S+?)月(\S+?)(?=$|[，。！？、；：""''（）【】\s]|日|号)/,
+      handler: (match) => {
+        const yearModifier = match[1];
+        let year = baseYear;
+        if (yearModifier === '去年') year -= 1;
+        if (yearModifier === '明年') year += 1;
+        if (yearModifier === '后年') year += 2;
+        if (yearModifier === '前年') year -= 2;
+
+        const monthStr = match[2] === '正' ? '一' : match[2];
+        const month = parseChineseNumber(monthStr);
+        const day = parseChineseNumber(match[3]);
+        const isLeap = match[0].includes('闰');
+        return { year, month, day, isLeap, fullMatch: match[0] };
+      }
+    },
+    {
+      regex: /农历(?:闰)?(\S+?)月(\S+?)(?=$|[，。！？、；：""''（）【】\s]|日|号)/,
+      handler: (match) => {
+        const monthStr = match[1] === '正' ? '一' : match[1];
+        const month = parseChineseNumber(monthStr);
+        const day = parseChineseNumber(match[2]);
+        const isLeap = match[0].includes('闰');
+        return { year: baseYear, month, day, isLeap, fullMatch: match[0] };
+      }
+    }
+  ];
+
+  for (const pattern of lunarPatterns) {
+    const match = processedQuery.match(pattern.regex);
+    if (match) {
+      try {
+        const lunarData = pattern.handler(match);
+        if (lunarData && lunarData.month && lunarData.day) {
+          const lunarDate = lunisolar.fromLunar({
+            year: lunarData.year,
+            month: lunarData.month,
+            day: lunarData.day,
+            isLeapMonth: lunarData.isLeap
+          });
+
+          let matchedKeyword = lunarData.fullMatch || match[0];
+          if (query.includes('正月') && matchedKeyword.includes('一月')) {
+            matchedKeyword = matchedKeyword.replace('一月', '正月');
+          }
+
+          return {
+            date: dayjs(lunarDate.toDate()),
+            matchedKeyword: matchedKeyword,
+            lunarData: lunarData
+          };
+        }
+      } catch (error) {
+        console.error('解析农历日期时出错:', error);
+      }
+    }
+  }
+
+  return null;
+}
+
+const festivalNameMap = {
+  '元旦': '元旦',
+  '春节': '春节',
+  '过年': '春节',
+  '五一': '劳动节',
+  '劳动节': '劳动节',
+  '国庆': '国庆节',
+  '国庆节': '国庆节',
+  '十一': '国庆节',
+  '清明': '清明节',
+  '清明节': '清明节',
+  '元宵': '元宵节',
+  '元宵节': '元宵节'
+};
+
+function getFestivalDate(year, festivalName) {
+  const normalizedName = festivalNameMap[festivalName] || festivalName;
+
+  if (normalizedName === '元旦') return dayjs(`${year}-01-01`);
+  if (normalizedName === '劳动节') return dayjs(`${year}-05-01`);
+  if (normalizedName === '国庆节') return dayjs(`${year}-10-01`);
+  if (normalizedName === '春节') return getSpringFestival(year);
+  if (normalizedName === '清明节') return getQingmingDate(year);
+  if (normalizedName === '元宵节') return getLanternFestival(year);
+
+  return getSpringFestival(year);
+}
+
+function getSpringFestival(year) {
+  try {
+    const lunarNewYear = lunisolar.fromLunar({
+      year: year,
+      month: 1,
+      day: 1,
+      isLeapMonth: false
+    });
+    return dayjs(lunarNewYear.toDate());
+  } catch (error) {
+    return dayjs(`${year}-02-01`);
+  }
+}
+
+function getQingmingDate(year) {
+  try {
+    for (let d = 1; d <= 10; d++) {
+      const date = new Date(year, 3, d);
+      const ls = lunisolar(date);
+      if (ls.solarTerm && ls.solarTerm.name === '清明') {
+        return dayjs(date);
+      }
+    }
+    return dayjs(`${year}-04-05`);
+  } catch (error) {
+    return dayjs(`${year}-04-05`);
+  }
+}
+
+function getLanternFestival(year) {
+  try {
+    const lunarDate = lunisolar.fromLunar({
+      year: year,
+      month: 1,
+      day: 15,
+      isLeapMonth: false
+    });
+    return dayjs(lunarDate.toDate());
+  } catch (error) {
+    return dayjs(`${year}-02-15`);
+  }
+}
+
+function parseTimeQuery(query, options = {}) {
+  const now = dayjs();
+  const baseYear = options.year || now.year();
+
+  let result = {
+    success: false,
+    originalQuery: query,
+    parsedDate: null,
+    timestamp: null,
+    lunarInfo: null,
+    festivalInfo: null,
+    isWorkday: null,
+    isHoliday: null,
+    matchedKeyword: null
+  };
+
+  const lunarResult = parseLunarDate(query, baseYear);
+  if (lunarResult) {
+    const date = lunarResult.date;
+    result.success = true;
+    result.parsedDate = date.format('YYYY-MM-DD');
+    result.timestamp = date.valueOf();
+    result.matchedKeyword = lunarResult.matchedKeyword;
+
+    try {
+      const lunar = lunisolar(date.toDate());
+      result.lunarInfo = {
+        year: lunar.lunarYear,
+        month: lunar.lunarMonth,
+        day: lunar.lunarDay,
+        isLeapMonth: lunar.isLeapMonth,
+        zodiac: lunar.yearZodiac ? lunar.yearZodiac.name : null,
+        term: lunar.solarTerm ? lunar.solarTerm.name : null
+      };
+    } catch (e) {
+      console.error('获取农历信息时出错:', e);
+    }
+
+    try {
+      result.festivalInfo = getFestival(date.toDate());
+      result.isWorkday = isWorkday(date.toDate());
+      result.isHoliday = isHoliday(date.toDate());
+    } catch (e) {
+      console.error('获取节日信息时出错:', e);
+    }
+
+    return result;
+  }
+
+  const keywords = [
+    { regex: /今天/, handler: () => now },
+    { regex: /昨天/, handler: () => now.subtract(1, 'day') },
+    { regex: /明天/, handler: () => now.add(1, 'day') },
+    { regex: /前天/, handler: () => now.subtract(2, 'day') },
+    { regex: /后天/, handler: () => now.add(2, 'day') },
+    { regex: /大前天/, handler: () => now.subtract(3, 'day') },
+    { regex: /大后天/, handler: () => now.add(3, 'day') },
+    { regex: /今年/, handler: () => now.startOf('year') },
+    { regex: /去年/, handler: () => now.subtract(1, 'year').startOf('year') },
+    { regex: /明年/, handler: () => now.add(1, 'year').startOf('year') }
+  ];
+
+  const festivalKeywords = [
+    { regex: /今年春节|今年过年/, handler: () => getFestivalDate(baseYear, '春节') },
+    { regex: /去年春节|去年过年/, handler: () => getFestivalDate(baseYear - 1, '春节') },
+    { regex: /明年春节|明年过年/, handler: () => getFestivalDate(baseYear + 1, '春节') },
+    { regex: /今年五一/, handler: () => getFestivalDate(baseYear, '五一') },
+    { regex: /去年五一/, handler: () => getFestivalDate(baseYear - 1, '五一') },
+    { regex: /明年五一/, handler: () => getFestivalDate(baseYear + 1, '五一') },
+    { regex: /今年十一|今年国庆/, handler: () => getFestivalDate(baseYear, '国庆') },
+    { regex: /去年十一|去年国庆/, handler: () => getFestivalDate(baseYear - 1, '国庆') },
+    { regex: /明年十一|明年国庆/, handler: () => getFestivalDate(baseYear + 1, '国庆') },
+    { regex: /今年元旦/, handler: () => getFestivalDate(baseYear, '元旦') },
+    { regex: /去年元旦/, handler: () => getFestivalDate(baseYear - 1, '元旦') },
+    { regex: /明年元旦/, handler: () => getFestivalDate(baseYear + 1, '元旦') },
+    { regex: /今年清明/, handler: () => getFestivalDate(baseYear, '清明节') },
+    { regex: /去年清明/, handler: () => getFestivalDate(baseYear - 1, '清明节') },
+    { regex: /明年清明/, handler: () => getFestivalDate(baseYear + 1, '清明节') },
+    { regex: /今年元宵/, handler: () => getFestivalDate(baseYear, '元宵节') },
+    { regex: /去年元宵/, handler: () => getFestivalDate(baseYear - 1, '元宵节') },
+    { regex: /明年元宵/, handler: () => getFestivalDate(baseYear + 1, '元宵节') },
+    { regex: /春节|过年/, handler: () => getFestivalDate(baseYear, '春节') },
+    { regex: /五一|劳动节/, handler: () => getFestivalDate(baseYear, '五一') },
+    { regex: /十一|国庆节|国庆/, handler: () => getFestivalDate(baseYear, '国庆') },
+    { regex: /元旦/, handler: () => getFestivalDate(baseYear, '元旦') },
+    { regex: /清明节|清明/, handler: () => getFestivalDate(baseYear, '清明节') },
+    { regex: /元宵节|元宵/, handler: () => getFestivalDate(baseYear, '元宵节') }
+  ];
+
+  const allKeywords = [...festivalKeywords, ...keywords];
+
+  for (const keyword of allKeywords) {
+    if (keyword.regex.test(query)) {
+      try {
+        const date = keyword.handler();
+        result.success = true;
+        result.parsedDate = date.format('YYYY-MM-DD');
+        result.timestamp = date.valueOf();
+        result.matchedKeyword = query.match(keyword.regex)[0];
+
+        try {
+          const lunar = lunisolar(date.toDate());
+          result.lunarInfo = {
+            year: lunar.lunarYear,
+            month: lunar.lunarMonth,
+            day: lunar.lunarDay,
+            isLeapMonth: lunar.isLeapMonth,
+            zodiac: lunar.yearZodiac ? lunar.yearZodiac.name : null,
+            term: lunar.solarTerm ? lunar.solarTerm.name : null
+          };
+        } catch (e) {
+          console.error('获取农历信息时出错:', e);
+        }
+
+        try {
+          result.festivalInfo = getFestival(date.toDate());
+          result.isWorkday = isWorkday(date.toDate());
+          result.isHoliday = isHoliday(date.toDate());
+        } catch (e) {
+          console.error('获取节日信息时出错:', e);
+        }
+
+        break;
+      } catch (error) {
+        console.error('处理时间关键词时出错:', error);
+      }
+    }
+  }
+
+  return result;
+}
+
+class CNTimeParserServer {
+  constructor() {
+    this.server = new Server(
+      {
+        name: 'cn-time-parser',
+        version: '1.0.1',
+      },
+      {
+        capabilities: {
+          tools: {},
+        },
+      }
+    );
+
+    this.setupToolHandlers();
+  }
+
+  setupToolHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: [
+        {
+          name: 'parse_chinese_time',
+          description: '解析中文时间关键词并转换为具体日期和时间戳。支持：基础时间词（今天、明天、昨天等）、农历日期（农历二月二十五、闰二月等）、节日名称（春节、国庆、清明、元宵等）、年份偏移（今年、去年、明年）。当用户需要解析自然语言中的时间信息、计算特定日期、处理农历节日转换时使用。',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              query: {
+                type: 'string',
+                description: '包含时间关键词的查询，例如："今天"、"明天"、"农历二月二十五"、"今年五一"'
+              },
+              year: {
+                type: 'number',
+                description: '指定年份（用于农历转换），默认为当前年份',
+                default: new Date().getFullYear()
+              }
+            },
+            required: ['query']
+          }
+        }
+      ],
+    }));
+
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      try {
+        const { name, arguments: args } = request.params;
+
+        if (name === 'parse_chinese_time') {
+          const { query, year } = args;
+          const result = parseTimeQuery(query, { year });
+
+          return {
+            content: [
+              {
+                type: 'text',
+                text: JSON.stringify(result, null, 2)
+              }
+            ]
+          };
+        }
+
+        throw new Error(`Unknown tool: ${name}`);
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Error: ${error.message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    });
+  }
+
+  async start() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error('cn-time-parser MCP Server started');
+  }
+}
+
+const server = new CNTimeParserServer();
+server.start().catch(console.error);

package/scripts/parse-time.js

@@ -67,7 +67,9 @@ const args = parser.parse_args();
 
 // 显示版本号
 if (args.version) {
-  console.log('cn-time-parser v1.0.0');
+  const packageJsonPath = resolve(fileURLToPath(import.meta.url), '../../package.json');
+  const packageJson = JSON.parse(realpathSync(packageJsonPath));
+  console.log(`cn-time-parser v${packageJson.version}`);
   process.exit(0);
 }
 
@@ -77,27 +79,27 @@ if (args.examples) {
 === 使用示例 ===
 
 1. 基础用法：
-   node scripts/parse-time.js --query "今天"
-   node scripts/parse-time.js --q "明天"
-   node scripts/parse-time.js "农历二月二十五"
+   cn-time-parser "今天"
+   cn-time-parser "明天"
+   cn-time-parser "农历二月二十五"
 
 2. 农历日期：
-   node scripts/parse-time.js --query "农历正月十五"
-   node scripts/parse-time.js --query "明年农历八月十五"
-   node scripts/parse-time.js --query "农历2025年九月初九"
+   cn-time-parser "农历正月十五"
+   cn-time-parser "明年农历八月十五"
+   cn-time-parser "农历2025年九月初九"
 
 3. 节日查询：
-   node scripts/parse-time.js --query "今年春节"
-   node scripts/parse-time.js --query "明年五一"
-   node scripts/parse-time.js --query "去年国庆"
+   cn-time-parser "今年春节"
+   cn-time-parser "明年五一"
+   cn-time-parser "去年国庆"
 
 4. 输出格式：
-   node scripts/parse-time.js --query "今天" --format text
-   node scripts/parse-time.js --query "今天" --format simple
+   cn-time-parser "今天" --format text
+   cn-time-parser "今天" --format simple
 
 5. 其他选项：
-   node scripts/parse-time.js --query "农历二月" --year 2025
-   node scripts/parse-time.js --query "今天" -v
+   cn-time-parser "农历二月" --year 2025
+   cn-time-parser "今天" -v
 `);
   process.exit(0);
 }