apexbot 1.0.2 → 1.0.5

package/dist/skills/reminder.js

@@ -0,0 +1,430 @@
+"use strict";
+/**
+ * Reminder / Scheduler Skill
+ *
+ * Schedule reminders, timers, and recurring tasks.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reminderManager = void 0;
+const events_1 = require("events");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+class ReminderManager extends events_1.EventEmitter {
+    reminders = new Map();
+    timers = new Map();
+    dataPath = '';
+    async initialize(dataPath) {
+        this.dataPath = dataPath;
+        await this.load();
+        this.scheduleAll();
+    }
+    async load() {
+        try {
+            const data = await fs.readFile(this.dataPath, 'utf-8');
+            const reminders = JSON.parse(data);
+            for (const r of reminders) {
+                r.triggerAt = new Date(r.triggerAt);
+                r.created = new Date(r.created);
+                this.reminders.set(r.id, r);
+            }
+            console.log(`[Reminders] Loaded ${this.reminders.size} reminders`);
+        }
+        catch {
+            // No existing data
+        }
+    }
+    async save() {
+        const data = Array.from(this.reminders.values());
+        await fs.writeFile(this.dataPath, JSON.stringify(data, null, 2));
+    }
+    scheduleAll() {
+        for (const reminder of this.reminders.values()) {
+            this.scheduleReminder(reminder);
+        }
+    }
+    scheduleReminder(reminder) {
+        // Clear existing timer
+        const existing = this.timers.get(reminder.id);
+        if (existing) {
+            clearTimeout(existing);
+        }
+        const now = Date.now();
+        const triggerTime = reminder.triggerAt.getTime();
+        const delay = triggerTime - now;
+        if (delay < 0) {
+            // Past reminder, trigger immediately or skip
+            if (reminder.recurring) {
+                this.rescheduleRecurring(reminder);
+            }
+            else {
+                this.reminders.delete(reminder.id);
+                this.save();
+            }
+            return;
+        }
+        // Schedule (max setTimeout is ~24 days, handle longer delays)
+        const maxDelay = 2147483647; // ~24.8 days
+        const actualDelay = Math.min(delay, maxDelay);
+        const timer = setTimeout(() => {
+            if (delay > maxDelay) {
+                // Reschedule for remaining time
+                reminder.triggerAt = new Date(triggerTime);
+                this.scheduleReminder(reminder);
+            }
+            else {
+                this.triggerReminder(reminder);
+            }
+        }, actualDelay);
+        this.timers.set(reminder.id, timer);
+    }
+    async triggerReminder(reminder) {
+        console.log(`[Reminders] Triggering: ${reminder.id}`);
+        this.emit('reminder', reminder);
+        if (reminder.recurring) {
+            this.rescheduleRecurring(reminder);
+        }
+        else {
+            this.reminders.delete(reminder.id);
+            this.timers.delete(reminder.id);
+        }
+        await this.save();
+    }
+    rescheduleRecurring(reminder) {
+        const { type, interval } = reminder.recurring;
+        const newTrigger = new Date(reminder.triggerAt);
+        switch (type) {
+            case 'daily':
+                newTrigger.setDate(newTrigger.getDate() + interval);
+                break;
+            case 'weekly':
+                newTrigger.setDate(newTrigger.getDate() + interval * 7);
+                break;
+            case 'monthly':
+                newTrigger.setMonth(newTrigger.getMonth() + interval);
+                break;
+        }
+        reminder.triggerAt = newTrigger;
+        this.reminders.set(reminder.id, reminder);
+        this.scheduleReminder(reminder);
+    }
+    add(reminder) {
+        const id = `rem_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        const full = {
+            ...reminder,
+            id,
+            created: new Date(),
+        };
+        this.reminders.set(id, full);
+        this.scheduleReminder(full);
+        this.save();
+        return full;
+    }
+    remove(id) {
+        const timer = this.timers.get(id);
+        if (timer) {
+            clearTimeout(timer);
+            this.timers.delete(id);
+        }
+        const deleted = this.reminders.delete(id);
+        if (deleted) {
+            this.save();
+        }
+        return deleted;
+    }
+    list(userId) {
+        let reminders = Array.from(this.reminders.values());
+        if (userId) {
+            reminders = reminders.filter(r => r.userId === userId);
+        }
+        return reminders.sort((a, b) => a.triggerAt.getTime() - b.triggerAt.getTime());
+    }
+    shutdown() {
+        for (const timer of this.timers.values()) {
+            clearTimeout(timer);
+        }
+        this.timers.clear();
+    }
+}
+const reminderManager = new ReminderManager();
+exports.reminderManager = reminderManager;
+// Parse natural language time
+function parseTime(input) {
+    const now = new Date();
+    const lower = input.toLowerCase().trim();
+    // Relative time patterns
+    const relativeMatch = lower.match(/^in\s+(\d+)\s+(second|minute|hour|day|week|month)s?$/);
+    if (relativeMatch) {
+        const amount = parseInt(relativeMatch[1]);
+        const unit = relativeMatch[2];
+        const result = new Date(now);
+        switch (unit) {
+            case 'second':
+                result.setSeconds(result.getSeconds() + amount);
+                break;
+            case 'minute':
+                result.setMinutes(result.getMinutes() + amount);
+                break;
+            case 'hour':
+                result.setHours(result.getHours() + amount);
+                break;
+            case 'day':
+                result.setDate(result.getDate() + amount);
+                break;
+            case 'week':
+                result.setDate(result.getDate() + amount * 7);
+                break;
+            case 'month':
+                result.setMonth(result.getMonth() + amount);
+                break;
+        }
+        return result;
+    }
+    // Tomorrow
+    if (lower === 'tomorrow') {
+        const result = new Date(now);
+        result.setDate(result.getDate() + 1);
+        result.setHours(9, 0, 0, 0);
+        return result;
+    }
+    // Time patterns (HH:MM)
+    const timeMatch = lower.match(/^(\d{1,2}):(\d{2})(?:\s*(am|pm))?$/);
+    if (timeMatch) {
+        let hours = parseInt(timeMatch[1]);
+        const minutes = parseInt(timeMatch[2]);
+        const ampm = timeMatch[3];
+        if (ampm === 'pm' && hours < 12)
+            hours += 12;
+        if (ampm === 'am' && hours === 12)
+            hours = 0;
+        const result = new Date(now);
+        result.setHours(hours, minutes, 0, 0);
+        if (result <= now) {
+            result.setDate(result.getDate() + 1);
+        }
+        return result;
+    }
+    // ISO date
+    const isoDate = new Date(input);
+    if (!isNaN(isoDate.getTime())) {
+        return isoDate;
+    }
+    return null;
+}
+const setReminderTool = {
+    definition: {
+        name: 'reminder_set',
+        description: 'Set a reminder for a specific time.',
+        category: 'automation',
+        parameters: [
+            {
+                name: 'message',
+                type: 'string',
+                description: 'Reminder message',
+                required: true,
+            },
+            {
+                name: 'time',
+                type: 'string',
+                description: 'When to remind (e.g., "in 30 minutes", "tomorrow", "14:00", "2024-01-15T14:00:00")',
+                required: true,
+            },
+            {
+                name: 'recurring',
+                type: 'string',
+                description: 'Recurrence: daily, weekly, monthly',
+                required: false,
+                enum: ['daily', 'weekly', 'monthly'],
+            },
+        ],
+        returns: 'Reminder confirmation',
+        examples: [
+            'reminder_set({ message: "Call mom", time: "in 2 hours" })',
+            'reminder_set({ message: "Team meeting", time: "14:00", recurring: "daily" })',
+        ],
+    },
+    async execute(params, context) {
+        const { message, time, recurring } = params;
+        if (!message || !time) {
+            return { success: false, error: 'Message and time are required' };
+        }
+        const triggerAt = parseTime(time);
+        if (!triggerAt) {
+            return { success: false, error: `Could not parse time: ${time}` };
+        }
+        const reminder = reminderManager.add({
+            message,
+            triggerAt,
+            recurring: recurring ? { type: recurring, interval: 1 } : undefined,
+            userId: context.userId,
+            channel: context.channel,
+        });
+        return {
+            success: true,
+            data: {
+                id: reminder.id,
+                message: reminder.message,
+                triggerAt: reminder.triggerAt.toISOString(),
+                recurring: reminder.recurring,
+            },
+        };
+    },
+};
+const listRemindersTool = {
+    definition: {
+        name: 'reminder_list',
+        description: 'List all active reminders.',
+        category: 'automation',
+        parameters: [],
+        returns: 'List of reminders',
+    },
+    async execute(params, context) {
+        const reminders = reminderManager.list(context.userId);
+        return {
+            success: true,
+            data: {
+                reminders: reminders.map(r => ({
+                    id: r.id,
+                    message: r.message,
+                    triggerAt: r.triggerAt.toISOString(),
+                    recurring: r.recurring,
+                })),
+                count: reminders.length,
+            },
+        };
+    },
+};
+const cancelReminderTool = {
+    definition: {
+        name: 'reminder_cancel',
+        description: 'Cancel a reminder.',
+        category: 'automation',
+        parameters: [
+            {
+                name: 'id',
+                type: 'string',
+                description: 'Reminder ID to cancel',
+                required: true,
+            },
+        ],
+        returns: 'Cancellation confirmation',
+    },
+    async execute(params, context) {
+        const { id } = params;
+        if (!id) {
+            return { success: false, error: 'Reminder ID is required' };
+        }
+        const deleted = reminderManager.remove(id);
+        return {
+            success: deleted,
+            data: deleted ? { id, cancelled: true } : undefined,
+            error: deleted ? undefined : `Reminder not found: ${id}`,
+        };
+    },
+};
+const timerTool = {
+    definition: {
+        name: 'timer',
+        description: 'Set a countdown timer.',
+        category: 'automation',
+        parameters: [
+            {
+                name: 'duration',
+                type: 'string',
+                description: 'Timer duration (e.g., "5 minutes", "1 hour 30 minutes")',
+                required: true,
+            },
+            {
+                name: 'message',
+                type: 'string',
+                description: 'Message when timer ends',
+                required: false,
+                default: 'Timer finished!',
+            },
+        ],
+        returns: 'Timer confirmation',
+    },
+    async execute(params, context) {
+        const { duration, message = 'Timer finished!' } = params;
+        if (!duration) {
+            return { success: false, error: 'Duration is required' };
+        }
+        const triggerAt = parseTime(`in ${duration}`);
+        if (!triggerAt) {
+            return { success: false, error: `Could not parse duration: ${duration}` };
+        }
+        const reminder = reminderManager.add({
+            message,
+            triggerAt,
+            userId: context.userId,
+            channel: context.channel,
+        });
+        const durationMs = triggerAt.getTime() - Date.now();
+        const minutes = Math.floor(durationMs / 60000);
+        const seconds = Math.floor((durationMs % 60000) / 1000);
+        return {
+            success: true,
+            data: {
+                id: reminder.id,
+                message: reminder.message,
+                duration: `${minutes}m ${seconds}s`,
+                endsAt: reminder.triggerAt.toISOString(),
+            },
+        };
+    },
+};
+const manifest = {
+    name: 'reminder',
+    version: '1.0.0',
+    description: 'Reminders, timers, and scheduled tasks',
+    category: 'automation',
+    icon: 'alarm',
+    tools: ['reminder_set', 'reminder_list', 'reminder_cancel', 'timer'],
+    config: [],
+};
+const reminderSkill = {
+    manifest,
+    tools: [setReminderTool, listRemindersTool, cancelReminderTool, timerTool],
+    async initialize(config) {
+        const dataPath = config.dataPath || path.join(process.env.HOME || process.env.USERPROFILE || '', '.apexbot', 'reminders.json');
+        await reminderManager.initialize(dataPath);
+        console.log('[Reminders] Initialized');
+    },
+    async shutdown() {
+        reminderManager.shutdown();
+        console.log('[Reminders] Shutdown');
+    },
+};
+exports.default = reminderSkill;