Skill: youjwxyz/cron-expression-helper (version 1.0.0)

--- name: cron-expression-helper description: 创建、验证和展示cron表达式的工具。当用户需要创建cron表达式、验证cron语法、查看cron表达式的下一次执行时间、或生成最近10个符合cron表达式的时间点时使用。支持标准cron格式（5字段：分钟 小时 日 月 星期）和扩展格式。 --- # Cron表达式助手 这个skill帮助用户创建、验证和展示cron表达式。它提供交互式cron表达式创建、语法验证、以及展示最近10个符合cron表达式的时间点。 ## 核心功能 1. **创建cron表达式** - 通过交互式问答帮助用户构建cron表达式 2. **验证cron语法** - 检查cron表达式的语法正确性 3. **展示执行时间** - 显示cron表达式最近10次执行时间 4. **解释cron表达式** - 用自然语言解释cron表达式的含义 ## 使用方法 ### 1. 创建cron表达式 使用交互式问答模式创建cron表达式： ```bash python scripts/create_cron.py --interactive ``` 或者直接指定参数： ```bash python scripts/create_cron.py --minute "*/5" --hour "9-17" --day "*" --month "*" --weekday "1-5" ``` ### 2. 验证和展示cron表达式 验证cron表达式并展示最近10次执行时间： ```bash python scripts/show_cron.py "*/5 9-17 * * 1-5" ``` 指定显示数量： ```bash python scripts/show_cron.py "0 0 * * *" --count 20 ``` ### 3. 解释cron表达式 用自然语言解释cron表达式的含义： ```bash python scripts/explain_cron.py "0 0 * * 0" ``` 查看所有示例： ```bash python scripts/explain_cron.py --examples ``` ### 4. 在OpenClaw中直接使用 你也可以在OpenClaw会话中直接运行这些命令： ```bash exec python scripts/create_cron.py --interactive exec python scripts/show_cron.py "0 9 * * 1-5" exec python scripts/explain_cron.py "*/5 * * * *" ``` ## Cron表达式格式 标准cron表达式包含5个字段，用空格分隔： ``` 分钟 小时 日 月 星期 ``` 字段取值范围： - **分钟**：0-59 - **小时**：0-23 - **日**：1-31 - **月**：1-12 或 JAN-DEC - **星期**：0-6 或 SUN-SAT（0和7都表示周日） 特殊字符： - `*` - 任何值 - `,` - 值列表分隔符（例如：`1,3,5`） - `-` - 范围（例如：`1-5`） - `/` - 步长（例如：`*/5` 每5个单位） - `?` - 仅在日和星期字段使用，表示"无特定值" ## 示例 1. **每天午夜执行**：`0 0 * * *` 2. **工作日每5分钟执行**：`*/5 9-17 * * 1-5` 3. **每月1号上午9点执行**：`0 9 1 * *` 4. **每周日午夜执行**：`0 0 * * 0` ## 脚本说明 ### create_cron.py 交互式创建cron表达式。通过问答方式收集每个字段的值，生成完整的cron表达式。 ### show_cron.py 验证cron表达式并展示最近10次执行时间。如果表达式无效，会显示错误信息。 ### explain_cron.py 用自然语言解释cron表达式的含义，帮助用户理解表达式的执行计划。 ## 注意事项 1. 日和星期字段有冲突时，cron解析器通常只使用其中一个 2. 月份名称（JAN-DEC）和星期名称（SUN-SAT）不区分大小写 3. 使用`?`字符可以避免日和星期字段的冲突 4. 时区基于系统时区，展示的时间会转换为用户本地时间 ## 常见用例 - 设置定时任务 - 验证cron表达式语法 - 理解现有cron表达式的执行计划 - 调试定时任务调度问题

path: README.md
content: # Cron表达式助手 Skill

这是一个OpenClaw skill，用于创建、验证和展示cron表达式。

## 功能特性

- 🎯 **交互式创建** - 通过问答方式帮助用户构建cron表达式
- ✅ **语法验证** - 检查cron表达式的语法正确性
- ⏰ **时间展示** - 显示cron表达式最近10次执行时间
- 📝 **自然语言解释** - 用中文解释cron表达式的含义

## 安装

1. 将整个`cron-expression-helper`文件夹复制到OpenClaw的skills目录：
   ```
   C:\Users\<用户名>\.openclaw\workspace\skills\
   ```

2. 确保Python已安装（需要Python 3.6+）

## 使用方法

### 1. 创建cron表达式

```bash
# 交互式创建
python scripts/create_cron.py --interactive

# 直接创建
python scripts/create_cron.py --minute "*/5" --hour "9-17" --day "*" --month "*" --weekday "1-5"
```

### 2. 验证和展示cron表达式

```bash
# 验证并展示最近10次执行时间
python scripts/show_cron.py "*/5 9-17 * * 1-5"

# 指定显示数量
python scripts/show_cron.py "0 0 * * *" --count 20
```

### 3. 解释cron表达式

```bash
# 解释cron表达式的含义
python scripts/explain_cron.py "0 0 * * 0"

# 查看示例
python scripts/explain_cron.py --examples
```

## 在OpenClaw中使用

当用户需要创建或理解cron表达式时，Claude会自动加载这个skill。你可以：

1. 直接运行脚本：
   ```bash
   exec python scripts/create_cron.py --interactive
   ```

2. 或者让Claude使用skill的知识来帮助用户：
   - "帮我创建一个每天上午9点执行的cron表达式"
   - "解释这个cron表达式：*/5 9-17 * * 1-5"
   - "显示这个cron表达式最近10次执行时间：0 0 * * 0"

## 脚本说明

### create_cron.py
交互式创建cron表达式。通过问答方式收集每个字段的值，生成完整的cron表达式。

### show_cron.py
验证cron表达式并展示执行时间。如果表达式无效，会显示错误信息。

### explain_cron.py
用自然语言解释cron表达式的含义，帮助用户理解表达式的执行计划。

## Cron表达式格式

标准cron表达式包含5个字段：

```
分钟 小时 日 月 星期
```

示例：
- `0 0 * * *` - 每天午夜执行
- `0 9 * * 1-5` - 工作日上午9点执行
- `*/5 * * * *` - 每5分钟执行

## 依赖

脚本本身不需要额外依赖。如果需要更准确的cron时间计算，可以安装：

```bash
pip install croniter python-dateutil
```

## 许可证

MIT License

path: scripts/create_cron.py
content: #!/usr/bin/env python3
"""
交互式创建cron表达式的脚本
通过问答方式帮助用户构建cron表达式
"""

import argparse
import sys
from datetime import datetime

def get_field_input(field_name, field_range, examples, default="*"):
    """
    获取cron字段的输入
    """
    print(f"\n=== {field_name}字段 ===")
    print(f"取值范围: {field_range}")
    print(f"示例: {examples}")
    print(f"特殊字符: * (任何值), , (列表), - (范围), / (步长)")
    
    while True:
        value = input(f"请输入{field_name}的值 (默认: {default}): ").strip()
        if not value:
            value = default
        
        # 简单的验证
        if value == "*":
            return value
        
        # 检查是否包含有效字符
        valid_chars = set("0123456789*,-/")
        if all(c in valid_chars for c in value):
            return value
        else:
            print("错误: 包含无效字符。请只使用数字和特殊字符(*,-,/)")

def create_cron_interactive():
    """
    交互式创建cron表达式
    """
    print("=" * 50)
    print("Cron表达式创建助手")
    print("=" * 50)
    print("我将通过几个问题帮助你创建cron表达式。")
    print("cron表达式格式: 分钟 小时 日 月 星期")
    print()
    
    # 获取各个字段的值
    minute = get_field_input(
        "分钟", "0-59", 
        "0 (整点), */5 (每5分钟), 0,15,30,45 (每15分钟)",
        "*"
    )
    
    hour = get_field_input(
        "小时", "0-23", 
        "0 (午夜), 9 (上午9点), 9-17 (工作时间), */2 (每2小时)",
        "*"
    )
    
    day = get_field_input(
        "日", "1-31", 
        "1 (每月1号), */2 (每2天), 1,15 (每月1号和15号)",
        "*"
    )
    
    month = get_field_input(
        "月", "1-12 或 JAN-DEC", 
        "* (每月), 1-6 (1月到6月), 1,4,7,10 (季度初)",
        "*"
    )
    
    weekday = get_field_input(
        "星期", "0-6 或 SUN-SAT (0和7都表示周日)", 
        "1-5 (周一到周五), 0 (周日), 6 (周六)",
        "*"
    )
    
    # 构建cron表达式
    cron_expr = f"{minute} {hour} {day} {month} {weekday}"
    
    print("\n" + "=" * 50)
    print("生成的cron表达式:")
    print(f"  {cron_expr}")
    print()
    print("表达式解释:")
    print(f"  分钟: {minute}")
    print(f"  小时: {hour}")
    print(f"  日: {day}")
    print(f"  月: {month}")
    print(f"  星期: {weekday}")
    print("=" * 50)
    
    return cron_expr

def create_cron_from_args(args):
    """
    从命令行参数创建cron表达式
    """
    cron_expr = f"{args.minute} {args.hour} {args.day} {args.month} {args.weekday}"
    
    print(f"生成的cron表达式: {cron_expr}")
    print()
    print("表达式解释:")
    print(f"  分钟: {args.minute}")
    print(f"  小时: {args.hour}")
    print(f"  日: {args.day}")
    print(f"  月: {args.month}")
    print(f"  星期: {args.weekday}")
    
    return cron_expr

def main():
    parser = argparse.ArgumentParser(description="创建cron表达式")
    parser.add_argument("--minute", default="*", help="分钟字段 (0-59)")
    parser.add_argument("--hour", default="*", help="小时字段 (0-23)")
    parser.add_argument("--day", default="*", help="日字段 (1-31)")
    parser.add_argument("--month", default="*", help="月字段 (1-12 或 JAN-DEC)")
    parser.add_argument("--weekday", default="*", help="星期字段 (0-6 或 SUN-SAT)")
    parser.add_argument("--interactive", action="store_true", help="使用交互模式")
    
    args = parser.parse_args()
    
    if args.interactive or (len(sys.argv) == 1):
        cron_expr = create_cron_interactive()
    else:
        cron_expr = create_cron_from_args(args)
    
    # 询问是否保存到文件
    save = input("\n是否将cron表达式保存到文件? (y/N): ").strip().lower()
    if save == 'y':
        filename = input("请输入文件名 (默认: cron_expression.txt): ").strip()
        if not filename:
            filename = "cron_expression.txt"
        
        with open(filename, 'w', encoding='utf-8') as f:
            f.write(f"# 生成的cron表达式\n")
            f.write(f"# 生成时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
            f.write(f"{cron_expr}\n")
            f.write(f"\n# 解释:\n")
            f.write(f"# 分钟: {args.minute if not args.interactive else '交互式输入'}\n")
            f.write(f"# 小时: {args.hour if not args.interactive else '交互式输入'}\n")
            f.write(f"# 日: {args.day if not args.interactive else '交互式输入'}\n")
            f.write(f"# 月: {args.month if not args.interactive else '交互式输入'}\n")
            f.write(f"# 星期: {args.weekday if not args.interactive else '交互式输入'}\n")
        
        print(f"Cron表达式已保存到 {filename}")

if __name__ == "__main__":
    main()

path: scripts/explain_cron.py
content: #!/usr/bin/env python3
"""
解释cron表达式的脚本
将cron表达式转换为自然语言描述
"""

import argparse
import sys

def parse_cron_field(field: str, field_name: str, ranges: dict) -> str:
    """
    解析单个cron字段并返回自然语言描述
    """
    if field == "*":
        return f"任何{field_name}"
    
    # 处理步长
    if "/" in field:
        base, step = field.split("/", 1)
        if base == "*":
            return f"每{step}个{field_name}"
        else:
            base_desc = parse_cron_field(base, field_name, ranges)
            return f"{base_desc}开始，每{step}个{field_name}"
    
    # 处理列表
    if "," in field:
        items = field.split(",")
        descriptions = [parse_cron_field(item, field_name, ranges) for item in items]
        return f"{field_name}为 {'、'.join(descriptions)}"
    
    # 处理范围
    if "-" in field:
        start, end = field.split("-", 1)
        
        # 尝试转换为名称（对于月份和星期）
        if field_name == "月" and ranges.get("month_names"):
            try:
                start_name = ranges["month_names"].get(int(start), start)
                end_name = ranges["month_names"].get(int(end), end)
                return f"从{start_name}到{end_name}"
            except:
                pass
        
        if field_name == "星期" and ranges.get("weekday_names"):
            try:
                start_name = ranges["weekday_names"].get(int(start), start)
                end_name = ranges["weekday_names"].get(int(end), end)
                return f"从{start_name}到{end_name}"
            except:
                pass
        
        return f"从{start}到{end}"
    
    # 单个值
    if field_name == "月" and ranges.get("month_names"):
        try:
            return ranges["month_names"].get(int(field), field)
        except:
            pass
    
    if field_name == "星期" and ranges.get("weekday_names"):
        try:
            return ranges["weekday_names"].get(int(field), field)
        except:
            pass
    
    return field

def explain_cron_expression(cron_expr: str) -> str:
    """
    将cron表达式转换为自然语言描述
    """
    parts = cron_expr.strip().split()
    if len(parts) != 5:
        return "无效的cron表达式：必须是5个字段"
    
    minute, hour, day, month, weekday = parts
    
    # 定义字段名称和范围
    field_defs = [
        {
            "field": minute,
            "name": "分钟",
            "ranges": {}
        },
        {
            "field": hour,
            "name": "小时",
            "ranges": {}
        },
        {
            "field": day,
            "name": "日",
            "ranges": {}
        },
        {
            "field": month,
            "name": "月",
            "ranges": {
                "month_names": {
                    1: "一月", 2: "二月", 3: "三月", 4: "四月",
                    5: "五月", 6: "六月", 7: "七月", 8: "八月",
                    9: "九月", 10: "十月", 11: "十一月", 12: "十二月"
                }
            }
        },
        {
            "field": weekday,
            "name": "星期",
            "ranges": {
                "weekday_names": {
                    0: "周日", 1: "周一", 2: "周二", 3: "周三",
                    4: "周四", 5: "周五", 6: "周六", 7: "周日"
                }
            }
        }
    ]
    
    # 解析每个字段
    descriptions = []
    for field_def in field_defs:
        desc = parse_cron_field(field_def["field"], field_def["name"], field_def["ranges"])
        descriptions.append(desc)
    
    # 构建完整的描述
    minute_desc, hour_desc, day_desc, month_desc, weekday_desc = descriptions
    
    # 特殊情况处理
    result_parts = []
    
    # 处理分钟
    if minute == "0":
        result_parts.append("整点")
    elif minute == "*":
        result_parts.append("每分钟")
    elif "/" in minute and minute.split("/")[0] == "*":
        step = minute.split("/")[1]
        result_parts.append(f"每{step}分钟")
    else:
        result_parts.append(f"在分钟{minute_desc}")
    
    # 处理小时
    if hour == "*":
        result_parts.append("每小时")
    elif hour == "0":
        result_parts.append("午夜")
    else:
        result_parts.append(f"在{hour_desc}点")
    
    # 处理日
    if day == "*":
        result_parts.append("每天")
    else:
        result_parts.append(f"在{day_desc}号")
    
    # 处理月
    if month == "*":
        result_parts.append("每月")
    else:
        result_parts.append(f"在{month_desc}")
    
    # 处理星期
    if weekday == "*":
        result_parts.append("任何星期")
    else:
        result_parts.append(f"在{weekday_desc}")
    
    # 构建最终描述
    description = "，".join(result_parts) + "执行"
    
    # 简化常见模式
    if cron_expr == "0 0 * * *":
        return "每天午夜执行"
    elif cron_expr == "0 * * * *":
        return "每小时整点执行"
    elif cron_expr == "* * * * *":
        return "每分钟执行"
    elif cron_expr == "0 0 * * 0":
        return "每周日午夜执行"
    elif cron_expr == "0 9 * * 1-5":
        return "工作日（周一到周五）上午9点执行"
    elif cron_expr == "*/5 * * * *":
        return "每5分钟执行"
    elif cron_expr == "0 */2 * * *":
        return "每2小时整点执行"
    
    return description

def validate_cron_expression(cron_expr: str) -> bool:
    """
    简单的cron表达式验证
    """
    parts = cron_expr.strip().split()
    if len(parts) != 5:
        return False
    
    # 检查是否包含有效字符
    valid_chars = set("0123456789*,-/")
    for part in parts:
        if not all(c in valid_chars for c in part):
            return False
    
    return True

def main():
    parser = argparse.ArgumentParser(description="解释cron表达式")
    parser.add_argument("cron_expr", nargs="?", help="cron表达式 (例如: '*/5 9-17 * * 1-5')")
    parser.add_argument("--examples", action="store_true", help="显示示例")
    
    args = parser.parse_args()
    
    # 显示示例
    if args.examples:
        print("Cron表达式示例:")
        print("=" * 50)
        examples = [
            ("* * * * *", "每分钟执行"),
            ("0 * * * *", "每小时整点执行"),
            ("0 0 * * *", "每天午夜执行"),
            ("0 9 * * 1-5", "工作日（周一到周五）上午9点执行"),
            ("0 0 * * 0", "每周日午夜执行"),
            ("*/5 * * * *", "每5分钟执行"),
            ("0 */2 * * *", "每2小时整点执行"),
            ("0 0 1 * *", "每月1号午夜执行"),
            ("0 12 * * 6", "每周六中午12点执行"),
            ("0 9-17 * * 1-5", "工作日每小时整点执行，从9点到17点"),
        ]
        
        for expr, desc in examples:
            print(f"{expr:20} → {desc}")
        
        print("=" * 50)
        return
    
    # 如果没有提供cron表达式，则提示输入
    if not args.cron_expr:
        args.cron_expr = input("请输入cron表达式: ").strip()
    
    print("=" * 50)
    print(f"Cron表达式: {args.cron_expr}")
    print("=" * 50)
    
    # 验证cron表达式
    if not validate_cron_expression(args.cron_expr):
        print("❌ 无效的cron表达式!")
        print("请检查表达式格式:")
        print("  格式: 分钟 小时 日 月 星期")
        print("  示例: */5 9-17 * * 1-5")
        sys.exit(1)
    
    # 解释cron表达式
    explanation = explain_cron_expression(args.cron_expr)
    
    print("表达式解释:")
    print(f"  {explanation}")
    print()
    
    # 显示字段详情
    parts = args.cron_expr.strip().split()
    minute, hour, day, month, weekday = parts
    
    print("字段详情:")
    print(f"  分钟 ({minute}): 控制任务在每小时的第几分钟执行 (0-59)")
    print(f"  小时 ({hour}): 控制任务在一天中的第几小时执行 (0-23)")
    print(f"  日 ({day}): 控制任务在每月的第几天执行 (1-31)")
    print(f"  月 ({month}): 控制任务在每年的第几月执行 (1-12)")
    print(f"  星期 ({weekday}): 控制任务在每周的第几天执行 (0-6, 0=周日)")
    print()
    
    print("提示:")
    print("  * 使用 '*' 表示任何值")
    print("  * 使用 ',' 分隔多个值 (例如: '1,3,5')")
    print("  * 使用 '-' 表示范围 (例如: '1-5')")
    print("  * 使用 '/' 表示步长 (例如: '*/5' 每5个单位)")
    print("  * 使用 '?' 仅在日和星期字段，表示无特定值")
    print("=" * 50)

if __name__ == "__main__":
    main()

path: scripts/requirements.txt
content: # 可选依赖，用于更准确的cron计算
# croniter==1.3.8
# python-dateutil==2.8.2

# 基本依赖（脚本本身不需要额外依赖）

path: scripts/show_cron.py
content: #!/usr/bin/env python3
"""
验证cron表达式并展示最近10次执行时间的脚本
"""

import argparse
import sys
from datetime import datetime, timedelta
from typing import List, Optional
import re

class CronParser:
    """简单的cron表达式解析器"""
    
    @staticmethod
    def validate_cron_expression(cron_expr: str) -> bool:
        """
        验证cron表达式的基本语法
        """
        parts = cron_expr.strip().split()
        if len(parts) != 5:
            return False
        
        # 检查每个部分的基本格式
        for part in parts:
            if not CronParser._validate_part(part):
                return False
        
        return True
    
    @staticmethod
    def _validate_part(part: str) -> bool:
        """验证单个cron字段"""
        if part == "*":
            return True
        
        # 检查是否包含有效字符
        valid_chars = set("0123456789*,-/")
        if not all(c in valid_chars for c in part):
            return False
        
        # 简单的模式检查
        patterns = part.split(',')
        for pattern in patterns:
            if '/' in pattern:
                range_part, step_part = pattern.split('/', 1)
                if not step_part.isdigit():
                    return False
                if range_part != '*' and not CronParser._validate_range(range_part):
                    return False
            elif '-' in pattern:
                if not CronParser._validate_range(pattern):
                    return False
            elif pattern != '*' and not pattern.isdigit():
                return False
        
        return True
    
    @staticmethod
    def _validate_range(range_str: str) -> bool:
        """验证范围格式"""
        if '-' not in range_str:
            return False
        
        start, end = range_str.split('-', 1)
        return start.isdigit() and end.isdigit() and int(start) <= int(end)

def get_next_cron_times(cron_expr: str, count: int = 10) -> List[datetime]:
    """
    获取cron表达式接下来的执行时间
    注意：这是一个简化的实现，实际应用中应该使用croniter库
    """
    # 这里使用一个简化的实现
    # 实际项目中应该使用croniter库：pip install croniter
    times = []
    now = datetime.now()
    
    # 简化的逻辑：假设是每分钟执行一次的表达式
    # 实际应该根据cron表达式计算
    if cron_expr == "* * * * *":
        for i in range(count):
            times.append(now + timedelta(minutes=i))
    elif cron_expr == "0 * * * *":
        for i in range(count):
            next_hour = now.replace(minute=0, second=0, microsecond=0) + timedelta(hours=i)
            if next_hour > now:
                times.append(next_hour)
    elif cron_expr == "0 0 * * *":
        for i in range(count):
            next_day = now.replace(hour=0, minute=0, second=0, microsecond=0) + timedelta(days=i)
            if next_day > now:
                times.append(next_day)
    else:
        # 对于其他表达式，使用一个简化的近似
        # 实际项目中应该使用croniter库
        for i in range(count):
            times.append(now + timedelta(hours=i))
    
    return times[:count]

def explain_cron_expression(cron_expr: str) -> str:
    """
    用自然语言解释cron表达式
    """
    parts = cron_expr.strip().split()
    if len(parts) != 5:
        return "无效的cron表达式：必须是5个字段"
    
    minute, hour, day, month, weekday = parts
    
    explanations = []
    
    # 解释分钟
    if minute == "*":
        explanations.append("每分钟")
    elif minute == "0":
        explanations.append("整点")
    elif "/" in minute:
        step = minute.split("/")[1]
        explanations.append(f"每{step}分钟")
    else:
        explanations.append(f"在分钟 {minute}")
    
    # 解释小时
    if hour == "*":
        explanations.append("每小时")
    elif hour == "0":
        explanations.append("午夜")
    elif "-" in hour:
        start, end = hour.split("-")
        explanations.append(f"从{start}点到{end}点")
    else:
        explanations.append(f"在{hour}点")
    
    # 解释日
    if day == "*":
        explanations.append("每天")
    elif day == "1":
        explanations.append("每月1号")
    else:
        explanations.append(f"在{day}号")
    
    # 解释月
    if month == "*":
        explanations.append("每月")
    elif "-" in month:
        start, end = month.split("-")
        explanations.append(f"从{start}月到{end}月")
    else:
        explanations.append(f"在{month}月")
    
    # 解释星期
    if weekday == "*":
        explanations.append("每周任何一天")
    elif weekday == "0" or weekday == "7":
        explanations.append("周日")
    elif weekday == "1-5":
        explanations.append("工作日（周一到周五）")
    elif weekday == "6":
        explanations.append("周六")
    else:
        explanations.append(f"在星期{weekday}")
    
    return "，".join(explanations) + "执行"

def main():
    parser = argparse.ArgumentParser(description="验证和展示cron表达式")
    parser.add_argument("cron_expr", nargs="?", help="cron表达式 (例如: '*/5 9-17 * * 1-5')")
    parser.add_argument("--count", type=int, default=10, help="显示的执行时间数量 (默认: 10)")
    parser.add_argument("--explain", action="store_true", help="解释cron表达式的含义")
    
    args = parser.parse_args()
    
    # 如果没有提供cron表达式，则提示输入
    if not args.cron_expr:
        args.cron_expr = input("请输入cron表达式: ").strip()
    
    print("=" * 50)
    print(f"Cron表达式: {args.cron_expr}")
    print("=" * 50)
    
    # 验证cron表达式
    if not CronParser.validate_cron_expression(args.cron_expr):
        print("无效的cron表达式!")
        print("请检查表达式格式:")
        print("  格式: 分钟 小时 日 月 星期")
        print("  示例: */5 9-17 * * 1-5")
        sys.exit(1)
    
    print("有效的cron表达式")
    print()
    
    # 解释cron表达式
    explanation = explain_cron_expression(args.cron_expr)
    print("表达式解释:")
    print(f"  {explanation}")
    print()
    
    # 获取并显示执行时间
    print(f"最近{args.count}次执行时间:")
    print("-" * 30)
    
    try:
        next_times = get_next_cron_times(args.cron_expr, args.count)
        
        if not next_times:
            print("无法计算执行时间")
            print("提示: 安装croniter库以获得更准确的计算")
            print("      pip install croniter")
        else:
            for i, time in enumerate(next_times, 1):
                time_str = time.strftime("%Y-%m-%d %H:%M:%S")
                day_of_week = time.strftime("%A")
                print(f"{i:2d}. {time_str} ({day_of_week})")
    
    except Exception as e:
        print(f"计算执行时间时出错: {e}")
        print("提示: 安装croniter库以获得更准确的计算")
        print("      pip install croniter")
    
    print()
    print("=" * 50)
    print("提示: 要获得更准确的执行时间计算，请安装croniter库:")
    print("      pip install croniter")
    print("=" * 50)

if __name__ == "__main__":
    main()

Security scan verdicts — ClawScan: clean | static analysis:  | VirusTotal: suspicious | SkillSpector: suspicious (CRITICAL)