@ai.ntellect/core 0.3.3 → 0.4.0

package/dist/services/scheduler.js

@@ -1,121 +1,99 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ActionScheduler = void 0;
-class ActionScheduler {
-    constructor(actionQueueManager, orchestrator, events = {}) {
-        this.actionQueueManager = actionQueueManager;
-        this.orchestrator = orchestrator;
-        this.scheduledActions = new Map();
-        this.storage = new ScheduledActionStorage();
-        this.events = events;
-        this.initializeScheduledActions();
+exports.TaskScheduler = void 0;
+const node_cron_1 = __importDefault(require("node-cron"));
+class TaskScheduler {
+    constructor(agentRuntime, cache) {
+        this.scheduledRequests = new Map();
+        this.cronJobs = new Map();
+        this.agentRuntime = agentRuntime;
+        this.cache = cache;
     }
-    async scheduleAction(action, scheduledTime, userId, recurrence) {
-        const scheduledAction = {
-            id: crypto.randomUUID(),
-            action: {
-                name: action.name,
-                parameters: [],
-            },
-            scheduledTime,
-            userId,
-            status: "pending",
-            recurrence,
+    /**
+     * Schedule a new request to be processed later
+     */
+    async scheduleRequest(request) {
+        const id = crypto.randomUUID();
+        const scheduledRequest = {
+            id,
+            originalRequest: request.originalRequest,
+            cronExpression: request.cronExpression,
+            isRecurring: false,
+            createdAt: new Date(),
         };
-        await this.storage.saveScheduledAction(scheduledAction);
-        this.scheduleExecution(scheduledAction);
-        this.events.onActionScheduled?.(scheduledAction);
-        return scheduledAction.id;
-    }
-    async initializeScheduledActions() {
-        const pendingActions = await this.storage.getPendingActions();
-        pendingActions.forEach((action) => this.scheduleExecution(action));
-    }
-    scheduleExecution(scheduledAction) {
-        const now = new Date();
-        const delay = scheduledAction.scheduledTime.getTime() - now.getTime();
-        if (delay < 0)
-            return;
-        const timeout = setTimeout(async () => {
-            try {
-                await this.executeScheduledAction(scheduledAction);
-                if (scheduledAction.recurrence) {
-                    const nextExecutionTime = this.calculateNextExecutionTime(scheduledAction.scheduledTime, scheduledAction.recurrence);
-                    const actionSchema = this.orchestrator.tools.find((tool) => tool.name === scheduledAction.action.name);
-                    if (actionSchema) {
-                        await this.scheduleAction(actionSchema, nextExecutionTime, scheduledAction.userId, scheduledAction.recurrence);
-                    }
-                }
-            }
-            catch (error) {
-                console.error(`Failed to execute scheduled action ${scheduledAction.id}:`, error);
-                await this.storage.updateActionStatus(scheduledAction.id, "failed");
+        // Create cron job
+        const cronJob = node_cron_1.default.schedule(request.cronExpression, async () => {
+            await this.executeScheduledRequest(scheduledRequest);
+            if (!scheduledRequest.isRecurring) {
+                this.cancelScheduledRequest(id);
             }
-        }, delay);
-        this.scheduledActions.set(scheduledAction.id, timeout);
+        });
+        // Store request and job
+        this.scheduledRequests.set(id, scheduledRequest);
+        this.cronJobs.set(id, cronJob);
+        console.log(`✅ Request scheduled with cron expression: ${request.cronExpression}`);
+        return id;
     }
-    async executeScheduledAction(scheduledAction) {
+    /**
+     * Execute a scheduled request by launching a new process
+     */
+    async executeScheduledRequest(request) {
         try {
-            this.events.onActionStart?.(scheduledAction);
-            this.actionQueueManager.addToQueue({
-                name: scheduledAction.action.name,
-                parameters: scheduledAction.action.parameters,
+            console.log(`🔄 Executing scheduled request from ${request.createdAt}`);
+            // Récupérer les actions précédentes du cache
+            const previousActions = await this.cache.getPreviousActions(request.id);
+            // Add context about when this request was scheduled
+            const contextualRequest = `You are a scheduler. 
+        You were asked to execute this request: ${request.originalRequest}\n 
+        Date of the request: ${request.createdAt.toISOString()}\n
+        Act like if you know the request was scheduled.
+        Don't reschedule the same action. 
+        Just execute it.`;
+            // Process the request as if it was just received
+            const result = await this.agentRuntime.process({
+                currentContext: contextualRequest,
+                previousActions,
             });
-            const result = await this.actionQueueManager.processQueue();
-            await this.storage.updateActionStatus(scheduledAction.id, "completed");
-            this.events.onActionComplete?.(scheduledAction, result);
+            // Store the new actions in cache
+            if (result.actions.length > 0) {
+                await this.cache.storePreviousActions(request.id, result.actions);
+            }
+            console.log(`✅ Scheduled request executed successfully`);
         }
         catch (error) {
-            await this.storage.updateActionStatus(scheduledAction.id, "failed");
-            this.events.onActionFailed?.(scheduledAction, error);
-            throw error;
-        }
-    }
-    calculateNextExecutionTime(currentTime, recurrence) {
-        const nextTime = new Date(currentTime);
-        switch (recurrence.type) {
-            case "daily":
-                nextTime.setDate(nextTime.getDate() + recurrence.interval);
-                break;
-            case "weekly":
-                nextTime.setDate(nextTime.getDate() + 7 * recurrence.interval);
-                break;
-            case "monthly":
-                nextTime.setMonth(nextTime.getMonth() + recurrence.interval);
-                break;
+            console.error(`❌ Failed to execute scheduled request:`, error);
         }
-        return nextTime;
     }
-    async cancelScheduledAction(actionId) {
-        const timeout = this.scheduledActions.get(actionId);
-        if (timeout) {
-            clearTimeout(timeout);
-            this.scheduledActions.delete(actionId);
-            await this.storage.deleteScheduledAction(actionId);
-            this.events.onActionCancelled?.(actionId);
-            return true;
+    /**
+     * Cancel a scheduled request
+     */
+    cancelScheduledRequest(requestId) {
+        const cronJob = this.cronJobs.get(requestId);
+        if (cronJob) {
+            cronJob.stop();
+            this.cronJobs.delete(requestId);
         }
-        return false;
-    }
-}
-exports.ActionScheduler = ActionScheduler;
-class ScheduledActionStorage {
-    constructor() {
-        this.actions = [];
+        return this.scheduledRequests.delete(requestId);
     }
-    async saveScheduledAction(action) {
-        this.actions.push(action);
+    /**
+     * Get all scheduled requests
+     */
+    getScheduledRequests() {
+        return Array.from(this.scheduledRequests.values());
     }
-    async getPendingActions() {
-        return this.actions.filter((action) => action.status === "pending");
-    }
-    async updateActionStatus(actionId, status) {
-        const action = this.actions.find((a) => a.id === actionId);
-        if (action) {
-            action.status = status;
+    /**
+     * Stop all cron jobs
+     */
+    stopAll() {
+        for (const [id, cronJob] of this.cronJobs) {
+            cronJob.stop();
+            this.cronJobs.delete(id);
+            this.scheduledRequests.delete(id);
         }
-    }
-    async deleteScheduledAction(actionId) {
-        this.actions = this.actions.filter((a) => a.id !== actionId);
+        console.log("All scheduled requests stopped");
     }
 }
+exports.TaskScheduler = TaskScheduler;

package/dist/services/telegram-monitor.d.ts

@@ -1,15 +0,0 @@
-export interface TokenLaunch {
-    tokenAddress: string;
-    messageUrl: string;
-    timestamp: string;
-}
-export declare class TelegramMonitor {
-    private client;
-    private botStartTime;
-    constructor();
-    connect(): Promise<void>;
-    startMonitoring(channelUsername: string, callback: {
-        onNewLaunch: (message: string) => void;
-    }): Promise<void>;
-    static generateNewSession(): Promise<void>;
-}

package/dist/services/telegram-monitor.js

@@ -1,102 +1,118 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TelegramMonitor = void 0;
-const dotenv_1 = __importDefault(require("dotenv"));
-const prompt_sync_1 = __importDefault(require("prompt-sync"));
-const telegram_1 = require("telegram");
-const events_1 = require("telegram/events");
-const sessions_1 = require("telegram/sessions");
-dotenv_1.default.config();
-const prompt = (0, prompt_sync_1.default)({ sigint: true });
-class TelegramMonitor {
-    constructor() {
-        if (!process.env.TELEGRAM_API_ID || !process.env.TELEGRAM_API_HASH) {
-            throw new Error("TELEGRAM_API_ID and TELEGRAM_API_HASH must be set");
-        }
-        this.botStartTime = new Date();
-        const apiId = parseInt(process.env.TELEGRAM_API_ID);
-        const apiHash = process.env.TELEGRAM_API_HASH;
-        // Utiliser une session stockée si disponible
-        const sessionString = process.env.TELEGRAM_SESSION;
-        this.client = new telegram_1.TelegramClient(new sessions_1.StringSession(sessionString), apiId, apiHash, {
-            connectionRetries: 5,
-        });
-    }
-    async connect() {
-        // Se connecter en tant qu'utilisateur
-        await this.client.start({
-            phoneNumber: async () => prompt("Numéro de téléphone ? "),
-            password: async () => prompt("Mot de passe ? "),
-            phoneCode: async () => prompt("Code reçu ? "),
-            onError: (err) => console.log(err),
-        });
-        // Sauvegarder la session pour une utilisation ultérieure
-        console.log("Session string à sauvegarder:", this.client.session.save());
-    }
-    async startMonitoring(channelUsername, callback) {
-        console.log(`Démarrage du monitoring pour ${channelUsername}`);
-        try {
-            // S'assurer que le client est connecté
-            if (!this.client.connected) {
-                console.log("Client non connecté, tentative de connexion...");
-                await this.client.connect();
-                console.log("Client connecté avec succès");
-            }
-            console.log("État de la connexion:", this.client.connected);
-            // Vérifier si le canal existe et est accessible
-            try {
-                const channel = await this.client.getEntity(channelUsername);
-                console.log("Canal trouvé:", channel.id);
-            }
-            catch (e) {
-                console.error("Erreur lors de l'accès au canal:", e);
-            }
-            this.client.addEventHandler(async (event) => {
-                const message = event.message;
-                if (!message) {
-                    console.log("Pas de message dans l'événement");
-                    return;
-                }
-                if (!message.text) {
-                    console.log("Message sans texte:", message);
-                    return;
-                }
-                try {
-                    callback.onNewLaunch(message.text);
-                }
-                catch (error) {
-                    console.error("Erreur lors du traitement du message:", error);
-                }
-            }, new events_1.NewMessage({ chats: [channelUsername] }));
-            console.log("Handler d'événements ajouté avec succès");
-        }
-        catch (error) {
-            console.error("Erreur lors du démarrage du monitoring:", error);
-        }
-    }
-    static async generateNewSession() {
-        // Supprimer la session existante
-        const client = new telegram_1.TelegramClient(new sessions_1.StringSession(""), parseInt(process.env.TELEGRAM_API_ID || ""), process.env.TELEGRAM_API_HASH || "", {
-            connectionRetries: 5,
-        });
-        // Se connecter en tant qu'utilisateur
-        await client.start({
-            phoneNumber: async () => prompt("Numéro de téléphone ? "),
-            password: async () => prompt("Mot de passe ? "),
-            phoneCode: async () => prompt("Code reçu ? "),
-            onError: (err) => console.log(err),
-        });
-        // Sauvegarder la nouvelle session pour une utilisation ultérieure
-        console.log("Nouvelle session string à sauvegarder:", client.session.save());
-    }
-}
-exports.TelegramMonitor = TelegramMonitor;
-const telegramMonitor = new TelegramMonitor();
-telegramMonitor.startMonitoring("testcalldegen", {
-    onNewLaunch: (message) => {
-        console.log("Nouveau message:", message);
-    },
-});
+// import dotenv from "dotenv";
+// import promptSync from "prompt-sync";
+// import { TelegramClient } from "telegram";
+// import { NewMessage } from "telegram/events";
+// import { StringSession } from "telegram/sessions";
+// dotenv.config();
+// const prompt = promptSync({ sigint: true });
+// export interface TokenLaunch {
+//   tokenAddress: string;
+//   messageUrl: string;
+//   timestamp: string;
+// }
+// export class TelegramMonitor {
+//   private client: TelegramClient;
+//   private botStartTime: Date;
+//   constructor() {
+//     if (!process.env.TELEGRAM_API_ID || !process.env.TELEGRAM_API_HASH) {
+//       throw new Error("TELEGRAM_API_ID and TELEGRAM_API_HASH must be set");
+//     }
+//     this.botStartTime = new Date();
+//     const apiId = parseInt(process.env.TELEGRAM_API_ID);
+//     const apiHash = process.env.TELEGRAM_API_HASH;
+//     // Utiliser une session stockée si disponible
+//     const sessionString = process.env.TELEGRAM_SESSION;
+//     this.client = new TelegramClient(
+//       new StringSession(sessionString),
+//       apiId,
+//       apiHash,
+//       {
+//         connectionRetries: 5,
+//       }
+//     );
+//   }
+//   async connect() {
+//     // Se connecter en tant qu'utilisateur
+//     await this.client.start({
+//       phoneNumber: async () => prompt("Numéro de téléphone ? "),
+//       password: async () => prompt("Mot de passe ? "),
+//       phoneCode: async () => prompt("Code reçu ? "),
+//       onError: (err) => console.log(err),
+//     });
+//     // Sauvegarder la session pour une utilisation ultérieure
+//     console.log("Session string à sauvegarder:", this.client.session.save());
+//   }
+//   async startMonitoring(
+//     channelUsername: string,
+//     callback: {
+//       onNewLaunch: (message: string) => void;
+//     }
+//   ) {
+//     console.log(`Démarrage du monitoring pour ${channelUsername}`);
+//     try {
+//       // S'assurer que le client est connecté
+//       if (!this.client.connected) {
+//         console.log("Client non connecté, tentative de connexion...");
+//         await this.client.connect();
+//         console.log("Client connecté avec succès");
+//       }
+//       console.log("État de la connexion:", this.client.connected);
+//       // Vérifier si le canal existe et est accessible
+//       try {
+//         const channel = await this.client.getEntity(channelUsername);
+//         console.log("Canal trouvé:", channel.id);
+//       } catch (e) {
+//         console.error("Erreur lors de l'accès au canal:", e);
+//       }
+//       this.client.addEventHandler(async (event: any) => {
+//         const message = event.message;
+//         if (!message) {
+//           console.log("Pas de message dans l'événement");
+//           return;
+//         }
+//         if (!message.text) {
+//           console.log("Message sans texte:", message);
+//           return;
+//         }
+//         try {
+//           callback.onNewLaunch(message.text);
+//         } catch (error) {
+//           console.error("Erreur lors du traitement du message:", error);
+//         }
+//       }, new NewMessage({ chats: [channelUsername] }));
+//       console.log("Handler d'événements ajouté avec succès");
+//     } catch (error) {
+//       console.error("Erreur lors du démarrage du monitoring:", error);
+//     }
+//   }
+//   static async generateNewSession() {
+//     // Supprimer la session existante
+//     const client = new TelegramClient(
+//       new StringSession(""),
+//       parseInt(process.env.TELEGRAM_API_ID || ""),
+//       process.env.TELEGRAM_API_HASH || "",
+//       {
+//         connectionRetries: 5,
+//       }
+//     );
+//     // Se connecter en tant qu'utilisateur
+//     await client.start({
+//       phoneNumber: async () => prompt("Numéro de téléphone ? "),
+//       password: async () => prompt("Mot de passe ? "),
+//       phoneCode: async () => prompt("Code reçu ? "),
+//       onError: (err) => console.log(err),
+//     });
+//     // Sauvegarder la nouvelle session pour une utilisation ultérieure
+//     console.log(
+//       "Nouvelle session string à sauvegarder:",
+//       client.session.save()
+//     );
+//   }
+// }
+// const telegramMonitor = new TelegramMonitor();
+// telegramMonitor.startMonitoring("testcalldegen", {
+//   onNewLaunch: (message: string) => {
+//     console.log("Nouveau message:", message);
+//   },
+// });