cn-time-parser 1.0.0

package/AGENTS.md

@@ -0,0 +1,23 @@
+# Project Instructions
+
+This file provides context for AI assistants working on this project.
+
+## Project Type: Node.js
+
+### Commands
+- Install: `npm install`
+- Test: `npm test`
+- Build: `npm run build`
+- Start: `npm start`
+
+
+## Guidelines
+
+- Follow existing code style and patterns
+- Write tests for new functionality
+- Keep changes focused and atomic
+- Document public APIs
+
+## Important Notes
+
+<!-- Add project-specific notes here -->

package/INSTALL.md

@@ -0,0 +1,129 @@
+# 安装和使用指南
+
+## 本地运行（无需安装）
+
+在项目目录下直接使用 Node.js 运行：
+
+```bash
+cd /path/to/cn-time-parser
+npm install                    # 首次使用前安装依赖
+node scripts/parse-time.js -q "今天"
+node scripts/parse-time.js "农历二月二十五"
+```
+
+也可通过 npm scripts 快速启动：
+
+```bash
+npm start -- --query "今天"   # run start 脚本
+npm test                       # 运行测试（查询"今天"）
+npm run examples               # 显示使用示例
+```
+
+## 全局安装
+
+### 方式一：npm link（开发时推荐）
+
+将项目链接到全局，本地修改即时生效：
+
+```bash
+cd /path/to/cn-time-parser
+npm link
+```
+
+之后可直接使用 `cn-time-parser` 命令。解除链接：
+
+```bash
+npm unlink -g cn-time-parser
+```
+
+### 方式二：npm install -g（正式安装）
+
+```bash
+cd /path/to/cn-time-parser
+npm install -g .
+```
+
+### 验证安装
+
+```bash
+cn-time-parser --version
+cn-time-parser --help
+cn-time-parser --examples
+```
+
+## 使用方法
+
+### 基础用法
+```bash
+# 使用 --query 参数
+cn-time-parser --query "今天"
+
+# 使用 -q 快捷参数
+cn-time-parser -q "明天"
+
+# 直接传入位置参数
+cn-time-parser "农历二月二十五"
+```
+
+### 输出格式
+```bash
+# JSON格式（默认）
+cn-time-parser --query "今天"
+
+# 文本格式
+cn-time-parser --query "今天" --format text
+
+# 简单格式（仅日期）
+cn-time-parser --query "今天" --format simple
+```
+
+### 其他选项
+```bash
+# 显示示例
+cn-time-parser --examples
+
+# 显示帮助
+cn-time-parser --help
+
+# 详细模式
+cn-time-parser --query "今天" -v
+
+# 指定年份（用于农历转换）
+cn-time-parser --query "农历二月" --year 2025
+
+# 显示版本号
+cn-time-parser --version
+```
+
+## 常用示例
+
+```bash
+# 查询今天
+cn-time-parser "今天"
+
+# 查询农历日期
+cn-time-parser "农历正月十五"
+
+# 查询节日（支持今年/去年/明年）
+cn-time-parser "今年春节"
+cn-time-parser "去年五一"
+cn-time-parser "明年国庆"
+
+# 文本格式输出
+cn-time-parser "明年农历八月十五" --format text
+
+# 简单格式（仅日期）
+cn-time-parser "明天" --format simple
+```
+
+## 卸载
+
+### 全局安装
+```bash
+npm uninstall -g cn-time-parser
+```
+
+### npm link 解除
+```bash
+npm unlink -g cn-time-parser
+```

package/README.md

@@ -0,0 +1,178 @@
+# cn-time-parser
+
+智能识别中文自然语言中的时间关键词，转换为具体公历日期和时间戳。
+
+支持基础时间词（今天、明天、昨天等）、传统农历日期（二月二十五、闰二月等）、节日名称（春节、国庆、清明、元宵等），以及工作日/节假日判断。
+
+## 功能
+
+- **基础日期** — 今天、明天、昨天、前天、后天、大前天、大后天
+- **年份偏移** — 今年、去年、明年
+- **农历日期解析** — `农历二月二十五`、`明年农历八月十五`、`农历2024年正月十五`、`闰二月` 等
+- **节日匹配** — 春节、五一、国庆、元旦、清明、元宵，支持 `今年/去年/明年` 前缀
+- **输出信息** — 公历日期、Unix 毫秒时间戳、农历信息、生肖、节气、工作日/节假日判断
+
+## 快速开始
+
+```bash
+# 克隆项目后安装依赖
+npm install
+
+# 直接运行
+node scripts/parse-time.js -q "今天"
+node scripts/parse-time.js "农历二月二十五"
+
+# 或通过 npm scripts
+npm start -- --query "今年五一"
+npm test
+```
+
+### 全局安装
+
+**方式一：npm link（开发推荐）**
+```bash
+cd /path/to/cn-time-parser
+npm link
+cn-time-parser -q "今天"
+# 解除：npm unlink -g cn-time-parser
+```
+
+**方式二：npm install -g**
+```bash
+cd /path/to/cn-time-parser
+npm install -g .
+```
+
+## CLI 用法
+
+```
+node scripts/parse-time.js [选项] [查询...]
+```
+
+### 传入查询
+
+方式 | 示例
+---|---
+`--query` / `-q` | `--query "今天"` / `-q "明天"`
+位置参数 | `"农历二月二十五"` / `"今年五一"`
+
+### 选项
+
+选项 | 说明
+---|---
+`--format <type>` | 输出格式：`json`（默认）、`text`、`simple`
+`--year <int>` | 指定年份（用于农历转换）
+`--verbose` / `-v` | 显示详细信息
+`--examples` | 显示使用示例
+`--version` | 显示版本号
+`--help` | 显示帮助
+
+### 输出格式
+
+```bash
+# JSON（默认）
+node scripts/parse-time.js -q "今年五一"
+
+# 文本
+node scripts/parse-time.js -q "明天" --format text
+
+# 仅日期
+node scripts/parse-time.js -q "后天" --format simple
+```
+
+## 支持的时间表达式
+
+### 基础时间词
+
+`今天` `昨天` `明天` `前天` `后天` `大前天` `大后天`
+
+### 年份偏移
+
+`今年` `去年` `明年`
+
+### 农历日期
+
+- `农历二月二十五` — 默认为当前年份
+- `明年农历八月十五` — 支持年份偏移
+- `农历2025年正月十五` — 指定公历年份
+- `农历闰二月初五` — 支持闰月
+
+### 节日名称
+
+以下节日可直接查询，不带年份前缀时默认今年：
+
+节日 | 可用的输入关键词
+---|---
+春节 | `春节` `过年` `今年春节` `去年春节` `明年春节`
+元宵节 | `元宵` `元宵节` `今年元宵` `去年元宵` `明年元宵`
+清明节 | `清明` `清明节` `今年清明` `去年清明` `明年清明`
+劳动节 | `五一` `劳动节` `今年五一` `去年五一` `明年五一`
+国庆节 | `十一` `国庆` `国庆节` `今年国庆` `去年国庆` `明年国庆`
+元旦 | `元旦` `今年元旦` `去年元旦` `明年元旦`
+
+## 输出字段
+
+```json
+{
+  "success": true,
+  "originalQuery": "今年五一",
+  "parsedDate": "2026-05-01",
+  "timestamp": 1777564800000,
+  "lunarInfo": {
+    "year": 2026,
+    "month": 3,
+    "day": 14,
+    "isLeapMonth": false,
+    "zodiac": "马",
+    "term": null
+  },
+  "festivalInfo": "劳动节",
+  "isWorkday": false,
+  "isHoliday": true,
+  "matchedKeyword": "今年五一"
+}
+```
+
+字段 | 说明
+---|---
+`success` | 是否解析成功
+`originalQuery` | 原始输入
+`parsedDate` | 公历日期 `YYYY-MM-DD`
+`timestamp` | Unix 毫秒时间戳
+`lunarInfo.*` | 农历年／月／日／是否闰月／生肖／节气
+`festivalInfo` | 节日名称（可能为 `"工作日"` `"周末"` 等）
+`isWorkday` | 是否工作日
+`isHoliday` | 是否法定节假日
+`matchedKeyword` | 匹配到的关键词
+
+## 示例
+
+```bash
+# 基础日期
+cn-time-parser "今天"
+cn-time-parser "明天" --format simple
+
+# 农历
+cn-time-parser "农历正月十五"
+cn-time-parser "明年农历八月十五" --format text
+
+# 节日
+cn-time-parser "春节"
+cn-time-parser "去年五一"
+cn-time-parser "清明节"
+cn-time-parser "元宵节"
+
+# 指定年份
+cn-time-parser "农历二月" --year 2025
+```
+
+## 依赖
+
+- [dayjs](https://day.js.org/) — 日期处理
+- [lunisolar](https://github.com/magiclav/Lunisolar) — 农历/公历转换
+- [chinese-workday](https://github.com/nicedoc/chinese-workday) — 中国节假日判断
+- [argparse](https://github.com/nodeca/argparse) — CLI 参数解析
+
+## 许可证
+
+MIT

package/SKILL.md

@@ -0,0 +1,140 @@
+---
+name: cn-time-parser
+description: 智能识别中文时间关键词并转换为具体日期和时间戳；使用lunisolar模块处理农历计算，chinese-workday模块处理节日和工作日判断；支持解析复杂农历日期和判断节假日；当用户需要解析自然语言中的时间信息、计算特定日期、处理农历节日转换时使用
+---
+
+# 时间解析器
+
+## 任务目标
+- 本Skill用于：解析中文自然语言中的时间关键词，转换为具体的日期和时间戳
+- 能力包含：识别常见中文时间关键词（今天、昨天、明天、前天、今年、去年等）、处理传统农历节日、解析具体农历日期（如农历二月二十五）、判断工作日和节假日、计算特定日期的时间戳
+- 触发条件：用户提问中包含时间相关关键词，需要获取具体日期或时间戳
+
+## 前置准备
+- 依赖说明：需要安装Node.js环境，以及dayjs、lunisolar和chinese-workday模块
+- 准备命令：在使用前执行 `cd /path/to/cn-time-parser && npm install`
+
+## 全局安装（可选）
+### 安装为全局命令
+```bash
+cd /path/to/cn-time-parser
+npm install -g .
+```
+
+### 使用 npm link（开发时推荐）
+```bash
+cd /path/to/cn-time-parser
+npm link
+```
+链接后本地修改即时生效，无需重复安装。卸载链接：`npm unlink -g cn-time-parser`
+
+### 全局使用
+安装/链接后可以直接在任何位置使用：
+```bash
+cn-time-parser -q "今天"
+cn-time-parser "农历二月二十五"
+cn-time-parser --help
+```
+
+### 卸载
+```bash
+npm uninstall -g cn-time-parser
+```
+
+详细的安装和使用说明请参考 [INSTALL.md](INSTALL.md)
+
+## 操作步骤
+- 标准流程：
+  1. 分析用户提问，提取时间关键词
+  2. 调用脚本处理时间关键词：
+     - 脚本调用示例：`node scripts/parse-time.js --query "今天的天气怎么样"`
+  3. 根据返回的具体日期进行后续操作
+- 可选分支：
+  - 当检测到农历节日关键词时：使用lunisolar模块进行农历转换
+  - 当需要判断节假日时：使用chinese-workday模块获取节日信息和工作日判断
+  - 当需要时间戳时：自动生成Unix时间戳
+
+## 使用示例
+- 示例1：
+  - 场景/输入：用户问"明天是什么日子"
+  - 预期产出：解析出明天的具体日期（如2023-10-05）
+  - 关键要点：根据当前系统时间计算明天
+- 示例2：
+  - 场景/输入：用户问"去年过年是哪一天"
+  - 预期产出：解析出去年春节的具体日期
+  - 关键要点：使用农历转换功能
+- 示例3：
+  - 场景/输入：用户问"黄龙的生日是农历二月二十五，明年他的生日是公历的哪一天？"
+  - 预期产出：解析出明年农历二月二十五对应的公历日期
+  - 关键要点：支持解析具体农历日期并进行年份调整
+- 示例4：
+  - 场景/输入：用户问"今年五一是不是工作日？"
+  - 预期产出：解析出五一的日期，并提供isWorkday和isHoliday字段
+  - 关键要点：使用chinese-workday模块判断节假日
+- 示例5：
+  - 场景/输入：用户问"国庆节是哪一天"
+  - 预期产出：解析出今年国庆节的日期（默认当年）
+  - 关键要点：节日名称不带年份前缀时默认使用当前年份
+- 示例6：
+  - 场景/输入：用户问"清明节"
+  - 预期产出：解析出今年清明节的日期（基于节气计算）
+  - 关键要点：清明节是节气节日，日期在4月4-5日间浮动
+- 示例7：
+  - 场景/输入：用户问"元宵节"
+  - 预期产出：解析出今年元宵节的日期（农历正月十五）
+  - 关键要点：元宵节是农历节日，通过lunisolar转换
+
+## CLI命令行使用
+### 基础调用方式
+- `node scripts/parse-time.js --query "今天"` - 使用--query参数
+- `node scripts/parse-time.js -q "明天"` - 使用-q快捷参数
+- `node scripts/parse-time.js "农历二月二十五"` - 直接传入位置参数
+
+### 输出格式选项
+- `--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](scripts/parse-time.js)(用途与参数：解析时间关键词，支持--query参数传入用户提问；支持全局安装作为命令行工具使用)
+- 参考：见 [references/time-keywords.md](references/time-keywords.md)(何时读取：需要了解所有支持的时间关键词时)
+- 安装指南：见 [INSTALL.md](INSTALL.md)(何时读取：需要了解如何全局安装和使用命令行工具时)
+
+## 注意事项
+- 脚本会根据当前系统时间进行计算，确保系统时间准确
+- 农历转换基于lunisolar库，支持常见传统节日
+- 节假日和工作日判断基于chinese-workday库
+- 时间戳为毫秒级Unix时间戳
+- `lunarInfo` 中的 `zodiac` 和 `term` 字段可能为 `null`，取决于 lunisolar 库对当前日期的数据覆盖
+- `festivalInfo` 除具体节日名称外，也可能返回 `"周末"`、`"工作日"`、`"补劳动节"` 等描述

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "cn-time-parser",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "智能识别中文时间关键词并转换为具体日期和时间戳",
+  "main": "scripts/parse-time.js",
+  "bin": {
+    "cn-time-parser": "./scripts/parse-time.js"
+  },
+  "scripts": {
+    "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",
+    "argparse": "^2.0.1",
+    "chinese-workday": "^1.11.0"
+  },
+  "keywords": ["time", "parser", "chinese", "lunar"],
+  "author": "",
+  "license": "MIT"
+}

package/references/time-keywords.md

@@ -0,0 +1,133 @@
+# 支持的时间关键词列表
+
+## 概览
+本文档列出了时间解析器支持的所有时间关键词，包括基础时间关键词、节日关键词和农历日期解析。
+
+## 农历日期解析
+
+### 支持的农历日期格式
+- 农历[月份][日期] - 例如：农历二月十五、农历三月初八
+- [年份修饰]农历[月份][日期] - 例如：明年农历二月二十五、去年农历三月初五
+- 农历[年份]年[月份][日期] - 例如：农历2025年二月十五
+- 农历闰[月份][日期] - 例如：农历闰二月初五（仅当年有该闰月时有效）
+
+### 中文数字支持
+- 月份和日期支持中文数字：一、二、三...十、二十、三十
+- 也支持阿拉伯数字：1、2、3...10、20、30
+
+## 基础时间关键词
+
+### 相对日期
+- 今天 - 当前日期
+- 昨天 - 昨天的日期
+- 明天 - 明天的日期
+- 前天 - 前天的日期
+- 后天 - 后天的日期
+- 大前天 - 大前天的日期
+- 大后天 - 大后天的日期
+
+### 相对年份
+- 今年 - 今年的开始日期（1月1日）
+- 去年 - 去年的开始日期（1月1日）
+- 明年 - 明年的开始日期（1月1日）
+
+## 节日关键词
+
+### 农历节日
+- 今年春节/今年过年 - 今年春节的日期
+- 去年春节/去年过年 - 去年春节的日期
+- 明年春节/明年过年 - 明年春节的日期
+
+### 公历节日
+- 今年五一 - 今年五一国际劳动节（5月1日）
+- 去年五一 - 去年五一国际劳动节
+- 明年五一 - 明年五一国际劳动节
+- 今年十一/今年国庆 - 今年国庆节（10月1日）
+- 去年十一/去年国庆 - 去年国庆节
+- 明年十一/明年国庆 - 明年国庆节
+- 今年元旦 - 今年元旦（1月1日）
+- 去年元旦 - 去年元旦
+- 明年元旦 - 明年元旦
+
+## 使用示例
+
+### 基础时间关键词示例
+```
+输入："今天天气怎么样？"
+匹配关键词："今天"
+输出：当前日期
+
+输入："明天有什么安排？"
+匹配关键词："明天"
+输出：明天的日期
+```
+
+### 节日关键词示例
+```
+输入："今年春节是哪一天？"
+匹配关键词："今年春节"
+输出：今年春节的具体日期
+
+输入："去年十一放假几天？"
+匹配关键词："去年十一"
+输出：去年国庆节的日期（10月1日）
+```
+
+### 农历日期示例
+```
+输入："黄龙的生日是农历二月二十五，明年他的生日是公历的哪一天？"
+匹配关键词："明年农历二月二十五"
+输出：明年农历二月二十五对应的公历日期
+
+输入："农历三月十五是什么日子？"
+匹配关键词："农历三月十五"
+输出：今年农历三月十五对应的公历日期
+
+输入："农历2024年八月十五"
+匹配关键词："农历2024年八月十五"
+输出：2024年农历八月十五对应的公历日期（中秋节）
+```
+
+## 输出格式说明
+
+### 成功时的输出格式
+```json
+{
+  "success": true,
+  "originalQuery": "用户的原始提问",
+  "parsedDate": "YYYY-MM-DD格式的日期",
+  "timestamp": 1234567890123,
+  "lunarInfo": {
+    "year": 农历年,
+    "month": 农历月,
+    "day": 农历日,
+    "isLeapMonth": 是否闰月,
+    "zodiac": "生肖",
+    "term": "节气"
+  },
+  "festivalInfo": "节日名称（如春节、劳动节、国庆节等）",
+  "isWorkday": true/false,
+  "isHoliday": true/false,
+  "matchedKeyword": "匹配到的关键词"
+}
+```
+
+### 新增字段说明
+- `festivalInfo`: 使用 chinese-workday 模块获取的节日信息
+- `isWorkday`: 是否为工作日（使用 chinese-workday 判断）
+- `isHoliday`: 是否为节假日（使用 chinese-workday 判断）
+
+### 失败时的输出格式
+```json
+{
+  "success": false,
+  "error": "错误信息",
+  "originalQuery": "用户的原始提问"
+}
+```
+
+## 注意事项
+1. 时间解析基于当前系统时间，请确保系统时间准确
+2. 农历转换使用lunisolar库，支持大部分常见农历日期
+3. 如果未匹配到任何关键词，将返回success: false
+4. 时间戳为毫秒级Unix时间戳

package/scripts/parse-time.js

@@ -0,0 +1,562 @@
+#!/usr/bin/env node
+
+import { fileURLToPath } from 'url';
+import { resolve } from 'path';
+import { realpathSync } from 'fs';
+import dayjs from 'dayjs';
+import lunisolar from 'lunisolar';
+import { ArgumentParser } from 'argparse';
+import * as chineseWorkday from 'chinese-workday';
+
+const { isWorkday, isHoliday, getFestival } = chineseWorkday;
+
+const parser = new ArgumentParser({
+  description: '中文时间解析器 - 智能识别中文时间关键词并转换为具体日期',
+  add_help: true
+});
+
+// 主参数
+parser.add_argument('--query', { 
+  help: '包含时间关键词的用户提问', 
+  required: false 
+});
+
+// 快捷参数
+parser.add_argument('-q', '--q', { 
+  help: '快捷方式：包含时间关键词的用户提问', 
+  required: false,
+  dest: 'query_short' 
+});
+
+// 位置参数（直接传入查询）
+parser.add_argument('positional_query', { 
+  help: '直接传入的时间查询（可选）', 
+  nargs: '*',
+  default: []
+});
+
+// 输出格式选项
+parser.add_argument('--format', { 
+  help: '输出格式：json(默认)、text、simple', 
+  choices: ['json', 'text', 'simple'],
+  default: 'json'
+});
+
+// 其他选项
+parser.add_argument('--year', { 
+  help: '指定年份（用于农历日期转换）', 
+  type: 'int'
+});
+
+parser.add_argument('--verbose', '-v', { 
+  help: '显示详细信息', 
+  action: 'store_true'
+});
+
+parser.add_argument('--examples', { 
+  help: '显示使用示例', 
+  action: 'store_true'
+});
+
+parser.add_argument('--version', { 
+  help: '显示版本号', 
+  action: 'store_true'
+});
+
+const args = parser.parse_args();
+
+// 显示版本号
+if (args.version) {
+  console.log('cn-time-parser v1.0.0');
+  process.exit(0);
+}
+
+// 显示示例
+if (args.examples) {
+  console.log(`
+=== 使用示例 ===
+
+1. 基础用法：
+   node scripts/parse-time.js --query "今天"
+   node scripts/parse-time.js --q "明天"
+   node scripts/parse-time.js "农历二月二十五"
+
+2. 农历日期：
+   node scripts/parse-time.js --query "农历正月十五"
+   node scripts/parse-time.js --query "明年农历八月十五"
+   node scripts/parse-time.js --query "农历2025年九月初九"
+
+3. 节日查询：
+   node scripts/parse-time.js --query "今年春节"
+   node scripts/parse-time.js --query "明年五一"
+   node scripts/parse-time.js --query "去年国庆"
+
+4. 输出格式：
+   node scripts/parse-time.js --query "今天" --format text
+   node scripts/parse-time.js --query "今天" --format simple
+
+5. 其他选项：
+   node scripts/parse-time.js --query "农历二月" --year 2025
+   node scripts/parse-time.js --query "今天" -v
+`);
+  process.exit(0);
+}
+
+// 确定最终的查询字符串
+let query = args.query || args.query_short;
+if (!query && args.positional_query.length > 0) {
+  query = args.positional_query.join(' ');
+}
+
+if (!query) {
+  console.error('错误：请提供查询内容！使用 --examples 查看示例。');
+  parser.print_help();
+  process.exit(1);
+}
+
+// 中文数字映射
+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 = [
+    // 带年份的模式：农历2024年二月二十五（优先级最高）
+    {
+      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
+          });
+          
+          // 从原始query中提取匹配的关键词，保持"正月"的原貌
+          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 = {
+  '元旦': '元旦',
+  '春节': '春节',
+  '过年': '春节',
+  '五一': '劳动节',
+  '劳动节': '劳动节',
+  '国庆': '国庆节',
+  '国庆节': '国庆节',
+  '十一': '国庆节',
+  '清明': '清明节',
+  '清明节': '清明节',
+  '元宵': '元宵节',
+  '元宵节': '元宵节'
+};
+
+// 已知节日的固定日期映射（作为备用）
+const fixedFestivalDates = {
+  '元旦': (year) => dayjs(`${year}-01-01`),
+  '劳动节': (year) => dayjs(`${year}-05-01`),
+  '国庆节': (year) => dayjs(`${year}-10-01`),
+  '春节': (year) => getSpringFestival(year),
+  '清明节': (year) => getQingmingDate(year),
+  '元宵节': (year) => getLanternFestival(year)
+};
+
+// 获取节日日期
+function getFestivalDate(year, festivalName) {
+  // 标准化节日名称
+  const normalizedName = festivalNameMap[festivalName] || festivalName;
+  
+  // 对于有固定日期的节日，直接返回
+  if (fixedFestivalDates[normalizedName]) {
+    return fixedFestivalDates[normalizedName](year);
+  }
+  
+  // 备用方法
+  return getSpringFestival(year);
+}
+
+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) {
+      if (args.verbose) console.error('获取农历信息时出错:', e);
+    }
+    
+    // 获取节日和工作日信息
+    try {
+      result.festivalInfo = getFestival(date.toDate());
+      result.isWorkday = isWorkday(date.toDate());
+      result.isHoliday = isHoliday(date.toDate());
+    } catch (e) {
+      if (args.verbose) 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) {
+          if (args.verbose) console.error('获取农历信息时出错:', e);
+        }
+        
+        // 获取节日和工作日信息
+        try {
+          result.festivalInfo = getFestival(date.toDate());
+          result.isWorkday = isWorkday(date.toDate());
+          result.isHoliday = isHoliday(date.toDate());
+        } catch (e) {
+          if (args.verbose) console.error('获取节日信息时出错:', e);
+        }
+        
+        break;
+      } catch (error) {
+        if (args.verbose) console.error('处理时间关键词时出错:', error);
+      }
+    }
+  }
+
+  return result;
+}
+
+// 获取春节日期（农历正月初一）- 备用方法
+function getSpringFestival(year) {
+  try {
+    // 农历正月初一 - 使用正确的lunisolar API
+    const lunarNewYear = lunisolar.fromLunar({
+      year: year,
+      month: 1,
+      day: 1,
+      isLeapMonth: false
+    });
+    return dayjs(lunarNewYear.toDate());
+  } catch (error) {
+    if (args.verbose) console.error('获取春节日期时出错:', error);
+    // 如果获取失败，返回一个近似值（通常春节在1月或2月）
+    return dayjs(`${year}-02-01`);
+  }
+}
+
+// 获取清明节日期（清明节气当日，4月4日或5日）
+function getQingmingDate(year) {
+  try {
+    // 扫描4月1-10日，找到清明节气所在日期
+    for (let d = 1; d <= 10; d++) {
+      const date = new Date(year, 3, d); // month 3 = April
+      const ls = lunisolar(date);
+      if (ls.solarTerm && ls.solarTerm.name === '清明') {
+        return dayjs(date);
+      }
+    }
+    // 兜底：返回4月5日
+    return dayjs(`${year}-04-05`);
+  } catch (error) {
+    if (args.verbose) console.error('获取清明节日期时出错:', 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) {
+    if (args.verbose) console.error('获取元宵节日期时出错:', error);
+    // 兜底：元宵节通常在公历2月
+    return dayjs(`${year}-02-15`);
+  }
+}
+
+// 格式化输出
+function formatOutput(result, format) {
+  switch (format) {
+    case 'text':
+      if (result.success) {
+        let output = `查询: ${result.originalQuery}\n`;
+        output += `匹配: ${result.matchedKeyword}\n`;
+        output += `日期: ${result.parsedDate}\n`;
+        output += `时间戳: ${result.timestamp}\n`;
+        if (result.festivalInfo) {
+          output += `节日: ${result.festivalInfo}\n`;
+        }
+        output += `工作日: ${result.isWorkday ? '是' : '否'}\n`;
+        output += `节假日: ${result.isHoliday ? '是' : '否'}`;
+        return output;
+      } else {
+        return `无法解析查询: ${result.originalQuery}`;
+      }
+    
+    case 'simple':
+      if (result.success) {
+        return result.parsedDate;
+      } else {
+        return '解析失败';
+      }
+    
+    default: // json
+      return JSON.stringify(result, null, 2);
+  }
+}
+
+// 主函数
+function main() {
+  try {
+    const result = parseTimeQuery(query, { year: args.year });
+    const output = formatOutput(result, args.format);
+    console.log(output);
+    
+    if (!result.success) {
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error('解析时间时出错:', error);
+    console.log(JSON.stringify({
+      success: false,
+      error: error.message,
+      originalQuery: query
+    }, null, 2));
+    process.exit(1);
+  }
+}
+
+// 导出函数供其他模块使用
+export { parseTimeQuery };
+
+// 仅在直接运行时执行主函数
+if (process.argv[1]) {
+  const _metaPath = realpathSync(fileURLToPath(import.meta.url));
+  const _argvPath = realpathSync(resolve(process.argv[1]));
+  if (_metaPath === _argvPath) main();
+}