chore: migrate project into clean repository

apps/arcs-mini/mcp-tools/mcp_tool_alarm.c

@@ -0,0 +1,941 @@
+#define TAG "alarm_control"
+
+#include <string.h>
+#include <stdio.h>
+#include <time.h>
+#include <sys/time.h>
+#include <stdbool.h>
+
+#include "cJSON.h"
+#include "lisa_log.h"
+#include "lisa_mem.h"
+#include "listen_system.h"
+
+#include "mcp.h"
+#include "alarm_next.h"
+#include "service_alarm.h"
+
+#define ALARM_CTRL_FAIL(_msg)                            \
+    do {                                                 \
+        snprintf(result_text, text_len, "%s", (_msg));   \
+        return -1;                                       \
+    } while (0)
+
+typedef struct {
+    uint64_t cloud_id;             // cloud alarm id
+    const char *action;            // CREATE / DELETE / UPDATE / QUERY
+    const char *alarm_type;        // ONCE / DAILY / WEEKLY / WORKDAY / WEEKEND / MONTHLY / YEARLY
+    const char *holiday_name;      // 节日名称
+    const char *calendar_type;     // GREGORIAN / LUNAR
+    const char *time_str;          // HH:mm:ss
+    const char *date_str;          // YYYY-MM-DD
+    const char *lunar_date_str;    // MM-DD (LUNAR)
+    int day_of_week;               // 1-7
+    int day_of_month;              // 1-31
+    int month_of_year;             // 1-12
+    const char *text;              // 提醒文本
+    cJSON *search_keywords;        // array of strings
+} alarm_control_params_t;
+
+
+/* ==================== 参数解析工具 ==================== */
+
+static void alarm_control_params_init(alarm_control_params_t *params)
+{
+    if (!params) {
+        return;
+    }
+    memset(params, 0, sizeof(*params));
+    params->cloud_id = 0;
+    params->day_of_week = -1;
+    params->day_of_month = -1;
+    params->month_of_year = -1;
+}
+
+static void alarm_control_params_parse(cJSON *args, alarm_control_params_t *params)
+{
+    if (!args || !params) {
+        return;
+    }
+
+    cJSON *pval = NULL;
+
+    pval = mcp_tool_call_args_get(args, "id");
+    if (pval && cJSON_IsNumber(pval)) {
+        params->cloud_id = (uint64_t)pval->valuedouble;
+    }
+
+    pval = mcp_tool_call_args_get(args, "action");
+    if (pval && cJSON_IsString(pval) && pval->valuestring[0] != '\0') {
+        params->action = pval->valuestring;
+    }
+
+    pval = mcp_tool_call_args_get(args, "alarm_type");
+    if (pval && cJSON_IsString(pval) && pval->valuestring[0] != '\0') {
+        params->alarm_type = pval->valuestring;
+    }
+
+    pval = mcp_tool_call_args_get(args, "holiday_name");
+    if (pval && cJSON_IsString(pval) && pval->valuestring[0] != '\0') {
+        params->holiday_name = pval->valuestring;
+    }
+
+    pval = mcp_tool_call_args_get(args, "calendar_type");
+    if (pval && cJSON_IsString(pval) && pval->valuestring[0] != '\0') {
+        params->calendar_type = pval->valuestring;
+    }
+
+    pval = mcp_tool_call_args_get(args, "time");
+    if (pval && cJSON_IsString(pval) && pval->valuestring[0] != '\0') {
+        params->time_str = pval->valuestring;
+    }
+
+    pval = mcp_tool_call_args_get(args, "date");
+    if (pval && cJSON_IsString(pval) && pval->valuestring[0] != '\0') {
+        params->date_str = pval->valuestring;
+    }
+
+    pval = mcp_tool_call_args_get(args, "lunar_date");
+    if (pval && cJSON_IsString(pval) && pval->valuestring[0] != '\0') {
+        params->lunar_date_str = pval->valuestring;
+    }
+
+    pval = mcp_tool_call_args_get(args, "day_of_week");
+    if (pval && cJSON_IsNumber(pval)) {
+        params->day_of_week = pval->valueint;
+    }
+
+    pval = mcp_tool_call_args_get(args, "day_of_month");
+    if (pval && cJSON_IsNumber(pval)) {
+        params->day_of_month = pval->valueint;
+    }
+
+    pval = mcp_tool_call_args_get(args, "month_of_year");
+    if (pval && cJSON_IsNumber(pval)) {
+        params->month_of_year = pval->valueint;
+    }
+
+    pval = mcp_tool_call_args_get(args, "text");
+    if (pval && cJSON_IsString(pval)) {
+        params->text = pval->valuestring;
+    }
+
+    pval = mcp_tool_call_args_get(args, "search_keywords");
+    if (pval && cJSON_IsArray(pval)) {
+        params->search_keywords = pval;
+    }
+}
+
+
+static alarm_calendar_t parse_calendar_type(const char *calendar_type)
+{
+    if (calendar_type && strcmp(calendar_type, "LUNAR") == 0) {
+        return ALARM_CAL_LUNAR;
+    }
+    return ALARM_CAL_GREGORIAN;
+}
+
+static alarm_trigger_type_t parse_trigger_type(const char *alarm_type, const char *holiday_name)
+{
+    if (holiday_name && holiday_name[0] != '\0') {
+        return ALARM_TRIG_HOLIDAY;
+    }
+    if (!alarm_type) {
+        return ALARM_TRIG_ONCE;
+    }
+    if (strcmp(alarm_type, "ONCE") == 0) {
+        return ALARM_TRIG_ONCE;
+    }
+    if (strcmp(alarm_type, "DAILY") == 0) {
+        return ALARM_TRIG_DAILY;
+    }
+    if (strcmp(alarm_type, "WEEKLY") == 0) {
+        return ALARM_TRIG_WEEKLY;
+    }
+    if (strcmp(alarm_type, "WORKDAY") == 0) {
+        return ALARM_TRIG_WORKDAY;
+    }
+    if (strcmp(alarm_type, "WEEKEND") == 0) {
+        return ALARM_TRIG_WEEKEND;
+    }
+    if (strcmp(alarm_type, "MONTHLY") == 0) {
+        return ALARM_TRIG_MONTHLY;
+    }
+    if (strcmp(alarm_type, "YEARLY") == 0) {
+        return ALARM_TRIG_YEARLY;
+    }
+    return ALARM_TRIG_ONCE;
+}
+
+static bool parse_time_hms(const char *time_str, uint8_t *hour, uint8_t *minute, uint8_t *second)
+{
+    int h = -1, m = -1, s = -1;
+    if (!time_str || !hour || !minute || !second) {
+        return false;
+    }
+
+    if (sscanf(time_str, "%d:%d:%d", &h, &m, &s) == 3) {
+        // ok
+    } else if (sscanf(time_str, "%d:%d", &h, &m) == 2) {
+        s = 0;
+    } else {
+        return false;
+    }
+
+    if (h < 0 || h > 23 || m < 0 || m > 59 || s < 0 || s > 59) {
+        return false;
+    }
+
+    *hour = (uint8_t)h;
+    *minute = (uint8_t)m;
+    *second = (uint8_t)s;
+    return true;
+}
+
+static bool parse_date_ymd(const char *date_str, uint16_t *year, uint8_t *month, uint8_t *day)
+{
+    int y = -1, m = -1, d = -1;
+    if (!date_str || !year || !month || !day) {
+        return false;
+    }
+    if (sscanf(date_str, "%d-%d-%d", &y, &m, &d) != 3) {
+        return false;
+    }
+    if (y < 1970 || m < 1 || m > 12 || d < 1 || d > 31) {
+        return false;
+    }
+    *year = (uint16_t)y;
+    *month = (uint8_t)m;
+    *day = (uint8_t)d;
+    return true;
+}
+
+static bool parse_lunar_md(const char *lunar_date_str, uint8_t *month, uint8_t *day)
+{
+    int m = -1, d = -1;
+    if (!lunar_date_str || !month || !day) {
+        return false;
+    }
+    if (sscanf(lunar_date_str, "%d-%d", &m, &d) != 2) {
+        return false;
+    }
+    if (m < 1 || m > 12 || d < 1 || d > 31) {
+        return false;
+    }
+    *month = (uint8_t)m;
+    *day = (uint8_t)d;
+    return true;
+}
+
+static void alarm_fill_keywords(const cJSON *arr, alarm_object_t *alarm)
+{
+    if (!arr || !alarm) {
+        return;
+    }
+
+    uint8_t count = 0;
+    cJSON *item = NULL;
+    cJSON_ArrayForEach(item, arr) {
+        if (!cJSON_IsString(item) || !item->valuestring) {
+            continue;
+        }
+        if (count >= ALARM_KEYWORD_MAX) {
+            break;
+        }
+        strncpy(alarm->keywords[count], item->valuestring, ALARM_KEYWORD_LEN - 1);
+        alarm->keywords[count][ALARM_KEYWORD_LEN - 1] = '\0';
+        count++;
+    }
+    alarm->keyword_count = count;
+}
+
+/* ==================== 闹钟日期处理工具 ==================== */
+
+static void normalize_tm(struct tm *tmv);
+
+static int get_current_tm(struct tm *out_tm)
+{
+    if (!out_tm) {
+        return -1;
+    }
+
+    struct timeval tv;
+    if (ls_sys_get_time(&tv) != 0) {
+        if (gettimeofday(&tv, NULL) != 0) {
+            return -1;
+        }
+    }
+
+    long int ts = (long int)tv.tv_sec;
+    if (!ls_sys_get_tmtime(&ts, out_tm)) {
+        return -1;
+    }
+
+    // ls_sys_get_tmtime uses year base 1970 and does not set tm_wday.
+    // Normalize via mktime with a 1900-based year offset, then convert back.
+    normalize_tm(out_tm);
+
+    return 0;
+}
+
+static void normalize_tm(struct tm *tmv)
+{
+    if (!tmv) {
+        return;
+    }
+
+    struct tm tmp = *tmv;
+    tmp.tm_year += 70; // 1970-based -> 1900-based
+    mktime(&tmp);
+    tmv->tm_year = tmp.tm_year - 70;
+    tmv->tm_mon = tmp.tm_mon;
+    tmv->tm_mday = tmp.tm_mday;
+    tmv->tm_hour = tmp.tm_hour;
+    tmv->tm_min = tmp.tm_min;
+    tmv->tm_sec = tmp.tm_sec;
+    tmv->tm_wday = tmp.tm_wday;
+    tmv->tm_yday = tmp.tm_yday;
+    tmv->tm_isdst = tmp.tm_isdst;
+}
+
+static int days_in_month(int year, int month)
+{
+    static const uint8_t days[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+    if (month < 1 || month > 12) {
+        return 30;
+    }
+    if (month == 2) {
+        bool leap = ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0));
+        return leap ? 29 : 28;
+    }
+    return days[month - 1];
+}
+
+static void set_date_from_tm(alarm_object_t *alarm, const struct tm *tmv)
+{
+    if (!alarm || !tmv) {
+        return;
+    }
+    alarm->trigger.year = (uint16_t)(tmv->tm_year + 1970);
+    alarm->trigger.month = (uint8_t)(tmv->tm_mon + 1);
+    alarm->trigger.day = (uint8_t)tmv->tm_mday;
+}
+
+static int calc_tm_seconds(const struct tm *tmv)
+{
+    if (!tmv) {
+        return 0;
+    }
+    return tmv->tm_hour * 3600 + tmv->tm_min * 60 + tmv->tm_sec;
+}
+
+static int calc_alarm_seconds(const alarm_object_t *alarm)
+{
+    if (!alarm) {
+        return 0;
+    }
+    return alarm->trigger.hour * 3600 +
+           alarm->trigger.minute * 60 +
+           alarm->trigger.second;
+}
+
+static int set_nearest_date_from_workday_rule(alarm_object_t *alarm, struct tm *tmv, bool want_workday)
+{
+    int now_sec = calc_tm_seconds(tmv);
+    int alarm_sec = calc_alarm_seconds(alarm);
+
+    LISA_LOGI(TAG, "workday calc start: want=%s now=%04d-%02d-%02d %02d:%02d:%02d alarm=%02u:%02u:%02u",
+              want_workday ? "workday" : "weekend",
+              tmv->tm_year + 1970, tmv->tm_mon + 1, tmv->tm_mday,
+              tmv->tm_hour, tmv->tm_min, tmv->tm_sec,
+              alarm->trigger.hour, alarm->trigger.minute, alarm->trigger.second);
+
+    for (int i = 0; i < 370; i++) {
+        // 查询日期是否工作日
+        char date_str[16] = {0};
+        snprintf(date_str, sizeof(date_str), "%02d-%02d", tmv->tm_mon + 1, tmv->tm_mday);
+        bool is_work_day = false;
+        if (listenai_date_is_workday(date_str, &is_work_day) != 0) {
+            LISA_LOGE(TAG, "workday query failed, date=%s", date_str);
+            return -6;
+        }
+        bool match = want_workday ? is_work_day : !is_work_day;
+        
+        LISA_LOGI(TAG, "workday calc: i=%d date=%04d-%02d-%02d is_workday=%d match=%d",
+                  i,
+                  tmv->tm_year + 1970, tmv->tm_mon + 1, tmv->tm_mday,
+                  is_work_day, match);
+  
+        if (match) {
+            if (i > 0 || alarm_sec > now_sec) {
+                set_date_from_tm(alarm, tmv);
+                return 0;
+            }
+        }
+        tmv->tm_mday += 1;
+        normalize_tm(tmv);
+    }
+
+    LISA_LOGW(TAG, "workday rule not found within limit");
+    return -6;
+}
+
+// 获取未来最近的 周/月/年循环闹钟的日期
+static int set_nearest_date_from_rule(alarm_object_t *alarm,
+                                      alarm_trigger_type_t trigger_type,
+                                      int day_of_week,
+                                      int day_of_month,
+                                      int month_of_year)
+{
+    struct tm tmv;
+    if (get_current_tm(&tmv) != 0) {
+        return -1;
+    }
+
+    // Ensure tm_wday is normalized
+    normalize_tm(&tmv);
+
+    int now_sec = calc_tm_seconds(&tmv);
+    int alarm_sec = calc_alarm_seconds(alarm);
+
+    
+
+    LISA_LOGI(TAG, "set_nearest_date_from_rule: now=%02d:%02d:%02d alarm=%02u:%02u:%02u",
+                tmv.tm_hour, tmv.tm_min, tmv.tm_sec,
+                alarm->trigger.hour, alarm->trigger.minute, alarm->trigger.second);
+
+    switch (trigger_type) {
+    case ALARM_TRIG_DAILY:
+    {
+        if (alarm_sec <= now_sec) {
+            tmv.tm_mday += 1;
+            normalize_tm(&tmv);
+        }
+        set_date_from_tm(alarm, &tmv);
+        return 0;
+    }
+    case ALARM_TRIG_WEEKLY:
+    {
+        if (day_of_week < 1 || day_of_week > 7) {
+            return -2;
+        }
+
+        int today_wd = tmv.tm_wday == 0 ? 7 : tmv.tm_wday; // 1=Mon ... 7=Sun
+
+        int diff = (day_of_week - today_wd + 7) % 7;
+        if (diff == 0) {
+            if (alarm_sec <= now_sec) {
+                diff = 7;
+            }
+        }
+
+        LISA_LOGI(TAG, "weekly calc: today_wd=%d target=%d diff=%d ",
+                    today_wd, day_of_week, diff);
+
+        tmv.tm_mday += diff;
+        normalize_tm(&tmv);
+        set_date_from_tm(alarm, &tmv);
+        return 0;
+    }
+    case ALARM_TRIG_WORKDAY:
+    {
+        return set_nearest_date_from_workday_rule(alarm, &tmv, true);
+    }
+    case ALARM_TRIG_WEEKEND:
+    {
+        int today_wd = tmv.tm_wday == 0 ? 7 : tmv.tm_wday; // 1=Mon ... 7=Sun
+
+        bool today_is_weekend = (today_wd == 6 || today_wd == 7);
+        if (today_is_weekend && alarm_sec > now_sec) {
+            set_date_from_tm(alarm, &tmv);
+            return 0;
+        }
+
+        tmv.tm_mday += 1;
+        normalize_tm(&tmv);
+        for (int i = 0; i < 7; i++) {
+            int wd = tmv.tm_wday == 0 ? 7 : tmv.tm_wday;
+            if (wd == 6 || wd == 7) {
+                set_date_from_tm(alarm, &tmv);
+                return 0;
+            }
+            tmv.tm_mday += 1;
+            normalize_tm(&tmv);
+        }
+
+        LISA_LOGW(TAG, "weekend rule not found within limit");
+        return -6;
+    }
+    case ALARM_TRIG_MONTHLY:
+    {
+        if (day_of_month < 1 || day_of_month > 31) {
+            return -3;
+        }
+        LISA_LOGI(TAG, "monthly calc: today=%04d-%02d-%02d now=%02d:%02d:%02d target_day=%d ",
+                    tmv.tm_year + 1970, tmv.tm_mon + 1, tmv.tm_mday,
+                    tmv.tm_hour, tmv.tm_min, tmv.tm_sec);
+
+        int max_day = days_in_month(tmv.tm_year + 1970, tmv.tm_mon + 1);
+        int target_day = day_of_month > max_day ? max_day : day_of_month;
+        if (tmv.tm_mday < target_day) {
+            tmv.tm_mday = target_day;
+        } else if (tmv.tm_mday == target_day) {
+            if (alarm_sec <= now_sec) {
+                tmv.tm_mon += 1;
+            }
+            max_day = days_in_month(tmv.tm_year + 1970, tmv.tm_mon + 1);
+            target_day = day_of_month > max_day ? max_day : day_of_month;
+            tmv.tm_mday = target_day;
+        } else {
+            tmv.tm_mon += 1;
+            max_day = days_in_month(tmv.tm_year + 1970, tmv.tm_mon + 1);
+            target_day = day_of_month > max_day ? max_day : day_of_month;
+            tmv.tm_mday = target_day;
+        }
+    
+        normalize_tm(&tmv);
+        set_date_from_tm(alarm, &tmv);
+        return 0;
+    }
+    case ALARM_TRIG_YEARLY:
+    {
+        if (month_of_year < 1 || month_of_year > 12 || day_of_month < 1 || day_of_month > 31) {
+            return -4;
+        }
+        LISA_LOGI(TAG, "yearly calc: today=%04d-%02d-%02d now=%02d:%02d:%02d target=%02d-%02d ",
+                    tmv.tm_year + 1970, tmv.tm_mon + 1, tmv.tm_mday,
+                    tmv.tm_hour, tmv.tm_min, tmv.tm_sec,
+                    month_of_year, day_of_month);
+
+        int max_day = days_in_month(tmv.tm_year + 1970, month_of_year);
+        int target_day = day_of_month > max_day ? max_day : day_of_month;
+        if ((tmv.tm_mon + 1 < month_of_year) ||
+            ((tmv.tm_mon + 1 == month_of_year) && (tmv.tm_mday < target_day))) {
+            tmv.tm_mon = month_of_year - 1;
+            tmv.tm_mday = target_day;
+
+        } else if ((tmv.tm_mon + 1 == month_of_year) && (tmv.tm_mday == target_day)) {
+            if (alarm_sec <= now_sec) {
+                tmv.tm_year += 1;
+            }
+            tmv.tm_mon = month_of_year - 1;
+            max_day = days_in_month(tmv.tm_year + 1970, month_of_year);
+            target_day = day_of_month > max_day ? max_day : day_of_month;
+            tmv.tm_mday = target_day;
+        } else {
+            tmv.tm_year += 1;
+            tmv.tm_mon = month_of_year - 1;
+            max_day = days_in_month(tmv.tm_year + 1970, month_of_year);
+            target_day = day_of_month > max_day ? max_day : day_of_month;
+            tmv.tm_mday = target_day;
+        }
+    
+        normalize_tm(&tmv);
+        set_date_from_tm(alarm, &tmv);
+        return 0;
+    }
+    default:
+        return -5;
+    }
+}
+
+/* ==================== 闹钟对象构造工具 ==================== */
+static int build_alarm_by_params(const alarm_control_params_t *params, alarm_object_t *alarm_obj,
+                                  char *err_msg, size_t err_len)
+{
+    if (!params || !alarm_obj || !err_msg || err_len == 0) {
+        return -1;
+    }
+
+    memset(alarm_obj, 0, sizeof(*alarm_obj));
+    alarm_obj->alarm_id = 0;
+    alarm_obj->cloud_id = params->cloud_id; 
+    alarm_obj->calendar = parse_calendar_type(params->calendar_type);
+    alarm_obj->trigger.type = parse_trigger_type(params->alarm_type, params->holiday_name);
+
+    // 检查闹钟时间（必选）
+    if (!params->time_str || params->time_str[0] == '\0') {
+        LISA_LOGE(TAG, "time missing");
+        snprintf(err_msg, err_len, "没有指定时间或时间格式错误");
+        return -1;
+    }
+    if (!parse_time_hms(params->time_str, &alarm_obj->trigger.hour, &alarm_obj->trigger.minute, &alarm_obj->trigger.second)) {
+        LISA_LOGE(TAG, "invalid time format: %s", params->time_str);
+        snprintf(err_msg, err_len, "没有指定时间或时间格式错误");
+        return -1;
+    }
+
+    // 检查闹钟日期
+    bool date_set = false;
+    if (params->date_str) {
+        uint16_t y = 0;
+        uint8_t m = 0;
+        uint8_t d = 0;
+        if (parse_date_ymd(params->date_str, &y, &m, &d)) {
+            alarm_obj->trigger.year = y;
+            alarm_obj->trigger.month = m;
+            alarm_obj->trigger.day = d;
+            date_set = true;
+        }
+    }
+    // 如果没有下发日期，构造闹钟日期
+    // 先按日历类型构造
+    if (!date_set) {
+        if (alarm_obj->calendar == ALARM_CAL_LUNAR) {
+            if (!params->lunar_date_str || params->lunar_date_str[0] == '\0') {
+                LISA_LOGE(TAG, "lunar_date missing");
+                snprintf(err_msg, err_len, "缺少农历日期");
+                return -1;
+            }
+            char gregorian_date[16] = {0};
+            if (listenai_date_transition("lunar", params->lunar_date_str,
+                                         gregorian_date, sizeof(gregorian_date)) != 0) {
+                LISA_LOGE(TAG, "lunar transition failed");
+                snprintf(err_msg, err_len, "农历日期转换失败");
+                return -1;
+            }
+            uint16_t y = 0;
+            uint8_t m = 0;
+            uint8_t d = 0;
+            if (!parse_date_ymd(gregorian_date, &y, &m, &d)) {
+                LISA_LOGE(TAG, "invalid lunar transition date: %s", gregorian_date);
+                snprintf(err_msg, err_len, "农历日期转换失败");
+                return -1;
+            }
+            alarm_obj->trigger.year = y;
+            alarm_obj->trigger.month = m;
+            alarm_obj->trigger.day = d;
+            date_set = true;
+        }
+    }
+    // 再按闹钟类型构造
+    if (!date_set) {
+        if (alarm_obj->trigger.type == ALARM_TRIG_ONCE) {
+            struct tm tmv;
+            if (get_current_tm(&tmv) != 0) {
+                LISA_LOGE(TAG, "get today date failed");
+                snprintf(err_msg, err_len, "无法获取当前日期");
+                return -1;
+            }
+            set_date_from_tm(alarm_obj, &tmv);
+            date_set = true;
+        } else if (alarm_obj->trigger.type == ALARM_TRIG_DAILY  ||
+                   alarm_obj->trigger.type == ALARM_TRIG_WEEKLY ||
+                   alarm_obj->trigger.type == ALARM_TRIG_MONTHLY ||
+                   alarm_obj->trigger.type == ALARM_TRIG_YEARLY ||
+                   alarm_obj->trigger.type == ALARM_TRIG_WORKDAY||
+                   alarm_obj->trigger.type == ALARM_TRIG_WEEKEND ) {
+            int r = set_nearest_date_from_rule(alarm_obj, alarm_obj->trigger.type,
+                                               params->day_of_week, params->day_of_month, params->month_of_year);
+            if (r != 0) {
+                LISA_LOGE(TAG, "missing or invalid rule params, type=%d", alarm_obj->trigger.type);
+                snprintf(err_msg, err_len, "缺少必要的日期参数");
+                return -1;
+            }
+        }else if (alarm_obj->trigger.type == ALARM_TRIG_HOLIDAY) {
+            if (!params->holiday_name || params->holiday_name[0] == '\0') {
+                LISA_LOGE(TAG, "holiday_name missing");
+                snprintf(err_msg, err_len, "缺少节日名称");
+                return -1;
+            }
+            char gregorian_date[16] = {0};
+            if (listenai_date_transition("holiday", params->holiday_name,
+                                         gregorian_date, sizeof(gregorian_date)) != 0) {
+                LISA_LOGE(TAG, "holiday transition failed");
+                snprintf(err_msg, err_len, "节假日转换失败");
+                return -1;
+            }
+            uint16_t y = 0;
+            uint8_t m = 0;
+            uint8_t d = 0;
+            if (!parse_date_ymd(gregorian_date, &y, &m, &d)) {
+                LISA_LOGE(TAG, "invalid holiday transition date: %s", gregorian_date);
+                snprintf(err_msg, err_len, "节假日转换失败");
+                return -1;
+            }
+            alarm_obj->trigger.year = y;
+            alarm_obj->trigger.month = m;
+            alarm_obj->trigger.day = d;
+            date_set = true;
+        }
+    }
+
+    // 保存时间戳
+    alarm_obj->alarm_id = alarm_obj_to_timestamp(alarm_obj);
+    if (alarm_obj->alarm_id == 0) {
+        LISA_LOGE(TAG, "invalid alarm datetime, cannot build alarm_id");
+        snprintf(err_msg, err_len, "闹钟时间无效");
+        return -1;
+    }
+
+    // 保存循环信息
+    if (params->day_of_week >= 1 && params->day_of_week <= 7) {
+        alarm_obj->trigger.day_of_week = (uint8_t)params->day_of_week;
+    }
+    if (params->day_of_month >= 1 && params->day_of_month <= 31) {
+        alarm_obj->trigger.day_of_month = (uint8_t)params->day_of_month;
+    }
+    if (params->month_of_year >= 1 && params->month_of_year <= 12) {
+        alarm_obj->trigger.month = (uint8_t)params->month_of_year;
+    }
+    if (params->holiday_name && params->holiday_name[0] != '\0') {
+        strncpy(alarm_obj->trigger.holiday_name, params->holiday_name, sizeof(alarm_obj->trigger.holiday_name) - 1);
+        alarm_obj->trigger.holiday_name[sizeof(alarm_obj->trigger.holiday_name) - 1] = '\0';
+    }
+    if (params->lunar_date_str && alarm_obj->calendar == ALARM_CAL_LUNAR) {
+        uint8_t m = 0;
+        uint8_t d = 0;
+        if (parse_lunar_md(params->lunar_date_str, &m, &d)) {
+            alarm_obj->trigger.lunar_month = m;
+            alarm_obj->trigger.lunar_day = d;
+        } else {
+            LISA_LOGW(TAG, "invalid lunar_date format: %s", params->lunar_date_str);
+        }
+    }
+
+    // 保存文本和关键词
+    if (params->text && params->text[0] != '\0') {
+        strncpy(alarm_obj->text, params->text, sizeof(alarm_obj->text) - 1);
+        alarm_obj->text[sizeof(alarm_obj->text) - 1] = '\0';
+    }
+    if (params->search_keywords) {
+        alarm_fill_keywords(params->search_keywords, alarm_obj);
+    }
+
+    return 0;
+}
+
+/* ==================== 闹钟对象查找工具 ==================== */
+static int delete_alarm_by_cloud_id(uint64_t cloud_id, char *result_text, size_t text_len)
+{
+    return service_alarm_delete_by_cloud_id(cloud_id, result_text, text_len);
+}
+
+
+/**
+ * @brief 闹钟提醒相关功能的处理函数
+ *
+ * 该工具用于处理闹钟提醒的创建、查询、删除操作。
+ * 首先构造 alarm_obj 闹钟对象，
+ * 然后基于 action 调用不同的函数处理闹钟操作指令，
+ * 最后基于处理结果构造 MCP 响应。
+ */
+static int alarm_control_execute(const alarm_control_params_t *params, char *result_text, size_t text_len)
+{
+    if (!params || !result_text || text_len == 0) {
+        ALARM_CTRL_FAIL("缺少参数");
+    }
+    if (!params->action || params->action[0] == '\0') {
+        ALARM_CTRL_FAIL("缺少操作类型");
+    }
+    if (params->cloud_id == 0) {
+        ALARM_CTRL_FAIL("缺少闹钟id");
+    }
+
+    result_text[0] = '\0';
+
+    // 执行闹钟指令
+    if (params->action && strcmp(params->action, "CREATE") == 0) {
+        alarm_object_t alarm_obj;
+        memset(&alarm_obj, 0, sizeof(alarm_obj));
+        if (build_alarm_by_params(params, &alarm_obj, result_text, text_len) != 0) {
+            ALARM_CTRL_FAIL(result_text);
+        }
+        alarm_obj_print(&alarm_obj);
+
+        if (service_alarm_create_obj(&alarm_obj, result_text, text_len) != 0) {
+            ALARM_CTRL_FAIL(result_text);
+        }
+    } else if (params->action && strcmp(params->action, "DELETE") == 0) {
+        if (service_alarm_delete_by_cloud_id(params->cloud_id, result_text, text_len) != 0) {
+            ALARM_CTRL_FAIL(result_text);
+        }
+    } else if (params->action && strcmp(params->action, "UPDATE") == 0) {
+        if (service_alarm_delete_by_cloud_id(params->cloud_id, result_text, text_len) != 0) {
+            ALARM_CTRL_FAIL(result_text);
+        }
+
+        alarm_object_t new_alarm;
+        memset(&new_alarm, 0, sizeof(new_alarm));
+        if (build_alarm_by_params(params, &new_alarm, result_text, text_len) != 0) {
+            ALARM_CTRL_FAIL(result_text);
+        }
+        alarm_obj_print(&new_alarm);
+
+        if (service_alarm_create_obj(&new_alarm, result_text, text_len) != 0) {
+            ALARM_CTRL_FAIL(result_text);
+        }
+    } else if (params->action && strcmp(params->action, "QUERY") == 0) {
+        const alarm_object_t *target = service_alarm_find_by_cloud_id(params->cloud_id);
+        if (!target) {
+            ALARM_CTRL_FAIL("未找到对应闹钟");
+        }
+
+        snprintf(result_text, text_len, "查询成功, id=%llu, timestamp=%llu, text=%s",
+                 (unsigned long long)target->cloud_id,
+                 (unsigned long long)target->alarm_id,
+                 target->text);
+    } else {
+        ALARM_CTRL_FAIL("不支持的操作类型");
+    }
+    
+    return 0;
+}
+
+
+
+static cJSON *alarm_control_call(const char *id, const char *name, cJSON *args)
+{
+    (void)id;
+
+    alarm_control_params_t params;
+    alarm_control_params_init(&params);
+    alarm_control_params_parse(args, &params);
+
+    char result_text[512] = {0};
+    int exec_ret = alarm_control_execute(&params, result_text, sizeof(result_text));
+
+    if (result_text[0] == '\0') {
+        snprintf(result_text, sizeof(result_text), "%s", (exec_ret == 0) ? "闹钟操作成功" : "闹钟操作失败");
+    }
+
+    cJSON *result = mcp_tool_call_result_create(name);
+    if (!result) {
+        return NULL;
+    }
+
+    cJSON_AddStringToObject(result, "content", result_text);
+    cJSON_AddBoolToObject(result, "isError", exec_ret != 0);
+
+    return result;
+}
+
+
+static cJSON *alarm_control_list(const char *name)
+{
+    cJSON *tool = cJSON_CreateObject();
+    if (!tool) {
+        return NULL;
+    }
+
+    cJSON_AddStringToObject(tool, "name", name);
+    cJSON_AddStringToObject(tool, "description",
+                            "智能闹钟与提醒管理系统。支持公历/农历、固定周期及动态节假日。核心准则：1.【禁止猜测时间】若用户仅提供‘下午’、‘早晨’、‘待会’、‘以后’等模糊时段，或未提及具体时间，严禁私自编造时间点，此时必须放弃调用函数，转而向用户询问具体几点几分。2. 识别到特定节日必须填充 holiday_name；3. 只要存在提醒内容(text)，就必须同步提取搜索关键词(search_keywords)以供后续索引。");
+
+    cJSON *schema = cJSON_CreateObject();
+    if (!schema) {
+        cJSON_Delete(tool);
+        return NULL;
+    }
+
+    cJSON_AddStringToObject(schema, "type", "object");
+
+    cJSON *properties = cJSON_CreateObject();
+    if (!properties) {
+        cJSON_Delete(schema);
+        cJSON_Delete(tool);
+        return NULL;
+    }
+
+    cJSON *action_prop = cJSON_CreateObject();
+    cJSON_AddStringToObject(action_prop, "type", "string");
+    cJSON *action_enum = cJSON_CreateArray();
+    cJSON_AddItemToArray(action_enum, cJSON_CreateString("CREATE"));
+    cJSON_AddItemToArray(action_enum, cJSON_CreateString("DELETE"));
+    cJSON_AddItemToArray(action_enum, cJSON_CreateString("UPDATE"));
+    cJSON_AddItemToArray(action_enum, cJSON_CreateString("QUERY"));
+    cJSON_AddItemToObject(action_prop, "enum", action_enum);
+    cJSON_AddStringToObject(action_prop, "description", "操作类型：CREATE(新建), DELETE(删除), UPDATE(修改), QUERY(查询)。");
+    cJSON_AddItemToObject(properties, "action", action_prop);
+
+    cJSON *alarm_type_prop = cJSON_CreateObject();
+    cJSON_AddStringToObject(alarm_type_prop, "type", "string");
+    cJSON *alarm_type_enum = cJSON_CreateArray();
+    cJSON_AddItemToArray(alarm_type_enum, cJSON_CreateString("ONCE"));
+    cJSON_AddItemToArray(alarm_type_enum, cJSON_CreateString("DAILY"));
+    cJSON_AddItemToArray(alarm_type_enum, cJSON_CreateString("WEEKLY"));
+    cJSON_AddItemToArray(alarm_type_enum, cJSON_CreateString("WORKDAY"));
+    cJSON_AddItemToArray(alarm_type_enum, cJSON_CreateString("WEEKEND"));
+    cJSON_AddItemToArray(alarm_type_enum, cJSON_CreateString("MONTHLY"));
+    cJSON_AddItemToArray(alarm_type_enum, cJSON_CreateString("YEARLY"));
+    cJSON_AddItemToObject(alarm_type_prop, "enum", alarm_type_enum);
+    cJSON_AddStringToObject(alarm_type_prop, "description", "循环策略。节日提醒固定使用 YEARLY。");
+    cJSON_AddItemToObject(properties, "alarm_type", alarm_type_prop);
+
+    cJSON *holiday_name_prop = cJSON_CreateObject();
+    cJSON_AddStringToObject(holiday_name_prop, "type", "string");
+    cJSON_AddStringToObject(holiday_name_prop, "description", "节日名称（如'中秋节'、'母亲节'）。若用户提及节日，此项必填。");
+    cJSON_AddItemToObject(properties, "holiday_name", holiday_name_prop);
+
+    cJSON *calendar_type_prop = cJSON_CreateObject();
+    cJSON_AddStringToObject(calendar_type_prop, "type", "string");
+    cJSON *calendar_type_enum = cJSON_CreateArray();
+    cJSON_AddItemToArray(calendar_type_enum, cJSON_CreateString("GREGORIAN"));
+    cJSON_AddItemToArray(calendar_type_enum, cJSON_CreateString("LUNAR"));
+    cJSON_AddItemToObject(calendar_type_prop, "enum", calendar_type_enum);
+    cJSON_AddStringToObject(calendar_type_prop, "default", "GREGORIAN");
+    cJSON_AddStringToObject(calendar_type_prop, "description", "历法：GREGORIAN(公历), LUNAR(农历)。");
+    cJSON_AddItemToObject(properties, "calendar_type", calendar_type_prop);
+
+    cJSON *time_prop = cJSON_CreateObject();
+    cJSON_AddStringToObject(time_prop, "type", "string");
+    cJSON_AddStringToObject(time_prop, "description", "24小时制时间 (HH:mm:ss)。严禁推测，未提及则反问用户。");
+    cJSON_AddItemToObject(properties, "time", time_prop);
+
+    cJSON *date_prop = cJSON_CreateObject();
+    cJSON_AddStringToObject(date_prop, "type", "string");
+    cJSON_AddStringToObject(date_prop, "description", "具体日期 (YYYY-MM-DD)。仅在 ONCE 模式下使用。");
+    cJSON_AddItemToObject(properties, "date", date_prop);
+
+    cJSON *lunar_date_prop = cJSON_CreateObject();
+    cJSON_AddStringToObject(lunar_date_prop, "type", "string");
+    cJSON_AddStringToObject(lunar_date_prop, "description",
+                            "具体日期 (MM-DD)。仅在 calendar_type 为 LUNAR 模式下使用。需要输出农历对应的数字月日格式，如‘正月初三’输出‘01-03’。");
+    cJSON_AddItemToObject(properties, "lunar_date", lunar_date_prop);
+
+    cJSON *day_of_week_prop = cJSON_CreateObject();
+    cJSON_AddStringToObject(day_of_week_prop, "type", "integer");
+    cJSON_AddNumberToObject(day_of_week_prop, "minimum", 1);
+    cJSON_AddNumberToObject(day_of_week_prop, "maximum", 7);
+    cJSON_AddStringToObject(day_of_week_prop, "description", "周几（1-7，1代表周一）。仅在 WEEKLY 模式有效。");
+    cJSON_AddItemToObject(properties, "day_of_week", day_of_week_prop);
+
+    cJSON *day_of_month_prop = cJSON_CreateObject();
+    cJSON_AddStringToObject(day_of_month_prop, "type", "integer");
+    cJSON_AddNumberToObject(day_of_month_prop, "minimum", 1);
+    cJSON_AddNumberToObject(day_of_month_prop, "maximum", 31);
+    cJSON_AddStringToObject(day_of_month_prop, "description", "每月几号。仅在 MONTHLY 或无节日的 YEARLY 模式有效。");
+    cJSON_AddItemToObject(properties, "day_of_month", day_of_month_prop);
+
+    cJSON *month_of_year_prop = cJSON_CreateObject();
+    cJSON_AddStringToObject(month_of_year_prop, "type", "integer");
+    cJSON_AddNumberToObject(month_of_year_prop, "minimum", 1);
+    cJSON_AddNumberToObject(month_of_year_prop, "maximum", 12);
+    cJSON_AddStringToObject(month_of_year_prop, "description", "每年几月。仅在无节日的 YEARLY 模式有效。");
+    cJSON_AddItemToObject(properties, "month_of_year", month_of_year_prop);
+
+    cJSON *text_prop = cJSON_CreateObject();
+    cJSON_AddStringToObject(text_prop, "type", "string");
+    cJSON_AddStringToObject(text_prop, "description", "提醒的完整文本内容。例如：'给妈妈打电话庆祝生日'。");
+    cJSON_AddItemToObject(properties, "text", text_prop);
+
+    cJSON *search_keywords_prop = cJSON_CreateObject();
+    cJSON_AddStringToObject(search_keywords_prop, "type", "array");
+    cJSON *keywords_items = cJSON_CreateObject();
+    cJSON_AddStringToObject(keywords_items, "type", "string");
+    cJSON_AddItemToObject(search_keywords_prop, "items", keywords_items);
+    cJSON_AddStringToObject(search_keywords_prop, "description", "【强制要求】从 text 中提取的 1-3 个核心动词或名词。若 text 存在，此项禁止为空。例如 text 为'记得下午三点喝水'，关键词为 ['喝水']。");
+    cJSON_AddItemToObject(properties, "search_keywords", search_keywords_prop);
+
+    cJSON_AddItemToObject(schema, "properties", properties);
+
+    cJSON *required = cJSON_CreateArray();
+    cJSON_AddItemToArray(required, cJSON_CreateString("action"));
+    cJSON_AddItemToObject(schema, "required", required);
+
+    cJSON_AddItemToObject(tool, "inputSchema", schema);
+
+    return tool;
+}
+
+MCP_TOOL_DEFINE(ls.built_in.alarm_clock, alarm_control_list, alarm_control_call);