@siftd/connect-agent 0.1.0 → 0.2.2

package/dist/core/scheduler.js

@@ -0,0 +1,311 @@
+/**
+ * Task Scheduler
+ * Schedule tasks for future execution with notifications
+ */
+import * as cron from 'node-cron';
+import * as fs from 'fs';
+export class TaskScheduler {
+    tasks = new Map();
+    activeTimers = new Map();
+    notifyCallback;
+    taskExecutor;
+    dataPath;
+    constructor(dataPath = 'scheduled_tasks.json') {
+        this.dataPath = dataPath;
+        this.loadTasks();
+    }
+    /**
+     * Set the notification callback for sending messages
+     */
+    setNotifyCallback(callback) {
+        this.notifyCallback = callback;
+    }
+    /**
+     * Set the task executor callback
+     */
+    setTaskExecutor(executor) {
+        this.taskExecutor = executor;
+    }
+    /**
+     * Parse natural language schedule
+     */
+    parseSchedule(when) {
+        const lower = when.toLowerCase().trim();
+        // "in X minutes/hours/days"
+        const delayMatch = lower.match(/^in\s+(\d+)\s+(minute|hour|day|second)s?$/);
+        if (delayMatch) {
+            const amount = parseInt(delayMatch[1]);
+            const unit = delayMatch[2];
+            const multipliers = {
+                second: 1000,
+                minute: 60000,
+                hour: 3600000,
+                day: 86400000
+            };
+            return { type: 'delay', ms: amount * multipliers[unit] };
+        }
+        // "every X minutes/hours"
+        const intervalMatch = lower.match(/^every\s+(\d+)\s+(minute|hour|second)s?$/);
+        if (intervalMatch) {
+            const amount = parseInt(intervalMatch[1]);
+            const unit = intervalMatch[2];
+            const multipliers = {
+                second: 1000,
+                minute: 60000,
+                hour: 3600000
+            };
+            return { type: 'interval', ms: amount * multipliers[unit] };
+        }
+        // "daily at HH:MM"
+        const dailyMatch = lower.match(/^daily\s+at\s+(\d{1,2}):(\d{2})$/);
+        if (dailyMatch) {
+            const hour = parseInt(dailyMatch[1]);
+            const minute = parseInt(dailyMatch[2]);
+            return { type: 'cron', pattern: `${minute} ${hour} * * *` };
+        }
+        // "every day at HH:MM"
+        const everyDayMatch = lower.match(/^every\s+day\s+at\s+(\d{1,2}):(\d{2})$/);
+        if (everyDayMatch) {
+            const hour = parseInt(everyDayMatch[1]);
+            const minute = parseInt(everyDayMatch[2]);
+            return { type: 'cron', pattern: `${minute} ${hour} * * *` };
+        }
+        // "tomorrow at HH:MM"
+        const tomorrowMatch = lower.match(/^tomorrow\s+at\s+(\d{1,2}):(\d{2})$/);
+        if (tomorrowMatch) {
+            const hour = parseInt(tomorrowMatch[1]);
+            const minute = parseInt(tomorrowMatch[2]);
+            const tomorrow = new Date();
+            tomorrow.setDate(tomorrow.getDate() + 1);
+            tomorrow.setHours(hour, minute, 0, 0);
+            return { type: 'once', at: tomorrow.toISOString() };
+        }
+        // Raw cron pattern (5 parts)
+        if (/^\S+\s+\S+\s+\S+\s+\S+\s+\S+$/.test(lower)) {
+            if (cron.validate(lower)) {
+                return { type: 'cron', pattern: lower };
+            }
+        }
+        return null;
+    }
+    /**
+     * Schedule a task
+     */
+    schedule(task, when, chatId) {
+        const schedule = typeof when === 'string' ? this.parseSchedule(when) : when;
+        if (!schedule) {
+            throw new Error(`Could not parse schedule: "${when}". Try formats like "in 30 minutes", "daily at 9:00", or "every 2 hours".`);
+        }
+        const id = `task_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+        const now = new Date();
+        const scheduledTask = {
+            id,
+            task,
+            schedule,
+            chatId,
+            enabled: true,
+            created: now.toISOString(),
+            runCount: 0,
+            nextRun: this.calculateNextRun(schedule)
+        };
+        this.tasks.set(id, scheduledTask);
+        this.activateTask(scheduledTask);
+        this.saveTasks();
+        return id;
+    }
+    /**
+     * Calculate next run time
+     */
+    calculateNextRun(schedule) {
+        const now = new Date();
+        switch (schedule.type) {
+            case 'once':
+                return schedule.at;
+            case 'delay':
+                return new Date(now.getTime() + schedule.ms).toISOString();
+            case 'interval':
+                return new Date(now.getTime() + schedule.ms).toISOString();
+            case 'cron':
+                return undefined;
+        }
+    }
+    /**
+     * Activate a task's timer
+     */
+    activateTask(task) {
+        this.deactivateTask(task.id);
+        if (!task.enabled)
+            return;
+        const executeAndNotify = async () => {
+            task.lastRun = new Date().toISOString();
+            task.runCount++;
+            let result = `Scheduled task "${task.task}" executed.`;
+            if (this.taskExecutor) {
+                try {
+                    result = await this.taskExecutor(task.task, task.chatId);
+                }
+                catch (error) {
+                    result = `Task failed: ${error instanceof Error ? error.message : String(error)}`;
+                }
+            }
+            if (this.notifyCallback) {
+                try {
+                    await this.notifyCallback(task.chatId, `Scheduled task completed:\n\n${result}`);
+                }
+                catch (error) {
+                    console.error('Failed to send notification:', error);
+                }
+            }
+            // For one-time tasks, disable after execution
+            if (task.schedule.type === 'once' || task.schedule.type === 'delay') {
+                task.enabled = false;
+                this.deactivateTask(task.id);
+            }
+            else {
+                task.nextRun = this.calculateNextRun(task.schedule);
+            }
+            this.saveTasks();
+        };
+        switch (task.schedule.type) {
+            case 'once': {
+                const runAt = new Date(task.schedule.at).getTime();
+                const delay = Math.max(0, runAt - Date.now());
+                const handle = setTimeout(executeAndNotify, delay);
+                this.activeTimers.set(task.id, { type: 'timeout', handle });
+                break;
+            }
+            case 'delay': {
+                const handle = setTimeout(executeAndNotify, task.schedule.ms);
+                this.activeTimers.set(task.id, { type: 'timeout', handle });
+                break;
+            }
+            case 'interval': {
+                const handle = setInterval(executeAndNotify, task.schedule.ms);
+                this.activeTimers.set(task.id, { type: 'interval', handle });
+                break;
+            }
+            case 'cron': {
+                const handle = cron.schedule(task.schedule.pattern, executeAndNotify);
+                this.activeTimers.set(task.id, { type: 'cron', handle });
+                break;
+            }
+        }
+    }
+    /**
+     * Deactivate a task's timer
+     */
+    deactivateTask(taskId) {
+        const timer = this.activeTimers.get(taskId);
+        if (!timer)
+            return;
+        switch (timer.type) {
+            case 'timeout':
+            case 'interval':
+                clearTimeout(timer.handle);
+                break;
+            case 'cron':
+                timer.handle.stop();
+                break;
+        }
+        this.activeTimers.delete(taskId);
+    }
+    /**
+     * Cancel a task
+     */
+    cancel(taskId) {
+        const task = this.tasks.get(taskId);
+        if (!task)
+            return false;
+        this.deactivateTask(taskId);
+        this.tasks.delete(taskId);
+        this.saveTasks();
+        return true;
+    }
+    /**
+     * Pause a task
+     */
+    pause(taskId) {
+        const task = this.tasks.get(taskId);
+        if (!task)
+            return false;
+        task.enabled = false;
+        this.deactivateTask(taskId);
+        this.saveTasks();
+        return true;
+    }
+    /**
+     * Resume a task
+     */
+    resume(taskId) {
+        const task = this.tasks.get(taskId);
+        if (!task)
+            return false;
+        task.enabled = true;
+        this.activateTask(task);
+        this.saveTasks();
+        return true;
+    }
+    /**
+     * List all tasks
+     */
+    list() {
+        return Array.from(this.tasks.values()).sort((a, b) => new Date(b.created).getTime() - new Date(a.created).getTime());
+    }
+    /**
+     * Get a specific task
+     */
+    get(taskId) {
+        return this.tasks.get(taskId);
+    }
+    /**
+     * Format schedule for display
+     */
+    formatSchedule(schedule) {
+        switch (schedule.type) {
+            case 'once':
+                return `once at ${new Date(schedule.at).toLocaleString()}`;
+            case 'delay':
+                const minutes = Math.round(schedule.ms / 60000);
+                return `in ${minutes} minute${minutes !== 1 ? 's' : ''}`;
+            case 'interval':
+                const intervalMins = Math.round(schedule.ms / 60000);
+                return `every ${intervalMins} minute${intervalMins !== 1 ? 's' : ''}`;
+            case 'cron':
+                return `cron: ${schedule.pattern}`;
+        }
+    }
+    /**
+     * Save tasks to disk
+     */
+    saveTasks() {
+        const data = Array.from(this.tasks.values());
+        fs.writeFileSync(this.dataPath, JSON.stringify(data, null, 2));
+    }
+    /**
+     * Load tasks from disk
+     */
+    loadTasks() {
+        if (!fs.existsSync(this.dataPath))
+            return;
+        try {
+            const data = JSON.parse(fs.readFileSync(this.dataPath, 'utf8'));
+            for (const task of data) {
+                this.tasks.set(task.id, task);
+                if (task.enabled) {
+                    this.activateTask(task);
+                }
+            }
+        }
+        catch (error) {
+            console.error('Failed to load scheduled tasks:', error);
+        }
+    }
+    /**
+     * Stop all timers (for shutdown)
+     */
+    shutdown() {
+        for (const taskId of this.activeTimers.keys()) {
+            this.deactivateTask(taskId);
+        }
+    }
+}

package/dist/core/system-indexer.d.ts

@@ -0,0 +1,65 @@
+/**
+ * System Indexer
+ *
+ * Indexes the user's filesystem INTO the memory system.
+ * When user says "that project" or "save in downloads",
+ * semantic search finds the relevant paths.
+ *
+ * No MCP. No new protocols. Just smart memory use.
+ */
+import { AdvancedMemoryStore } from './memory-advanced.js';
+export declare class SystemIndexer {
+    private memory;
+    private home;
+    private indexed;
+    constructor(memory: AdvancedMemoryStore);
+    /**
+     * Index the user's home directory structure into memory
+     */
+    indexHome(): Promise<{
+        projects: number;
+        directories: number;
+        total: number;
+    }>;
+    /**
+     * Index a directory and its subdirectories
+     */
+    private indexDirectory;
+    /**
+     * Find and index git repositories as projects
+     */
+    private indexGitRepos;
+    /**
+     * Get detailed info about a git project
+     */
+    private getProjectInfo;
+    /**
+     * Detect project type by looking at files
+     */
+    private detectProjectType;
+    /**
+     * Remember a key directory (Downloads, Documents, Desktop, etc.)
+     * These get high importance and multiple aliases for better search
+     */
+    private rememberKeyDirectory;
+    /**
+     * Store a project in memory
+     */
+    private rememberProject;
+    /**
+     * Generate a description for a directory
+     */
+    private describeDirectory;
+    /**
+     * Extract relevant tags from directory contents
+     */
+    private extractTags;
+    /**
+     * Re-index (clear old filesystem memories and re-scan)
+     */
+    reindex(): Promise<{
+        projects: number;
+        directories: number;
+        total: number;
+    }>;
+}