@ai.ntellect/core 0.3.3 → 0.4.0

package/services/scheduler.ts

@@ -1,167 +1,128 @@
-import { Orchestrator } from "../llm/orchestrator";
-import { ActionSchema, ScheduledAction, ScheduledActionEvents } from "../types";
-import { ActionQueueManager } from "./queue";
-
-export class ActionScheduler {
-  private scheduledActions: Map<string, NodeJS.Timeout> = new Map();
-  private storage: ScheduledActionStorage;
-  private events: ScheduledActionEvents;
-
-  constructor(
-    private actionQueueManager: ActionQueueManager,
-    private orchestrator: Orchestrator,
-    events: ScheduledActionEvents = {}
-  ) {
-    this.storage = new ScheduledActionStorage();
-    this.events = events;
-    this.initializeScheduledActions();
+import cron from "node-cron";
+import { AgentRuntime } from "../llm/orchestrator";
+import { RedisCache } from "./redis-cache";
+
+interface ScheduledRequest {
+  id: string;
+  originalRequest: string;
+  cronExpression: string;
+  isRecurring: boolean;
+  createdAt: Date;
+}
+
+export class TaskScheduler {
+  private scheduledRequests: Map<string, ScheduledRequest> = new Map();
+  private cronJobs: Map<string, cron.ScheduledTask> = new Map();
+  private readonly agentRuntime: AgentRuntime;
+  private readonly cache: RedisCache;
+
+  constructor(agentRuntime: AgentRuntime, cache: RedisCache) {
+    this.agentRuntime = agentRuntime;
+    this.cache = cache;
   }
 
-  async scheduleAction(
-    action: ActionSchema,
-    scheduledTime: Date,
-    userId: string,
-    recurrence?: ScheduledAction["recurrence"]
-  ): Promise<string> {
-    const scheduledAction: 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: {
+    originalRequest: string;
+    cronExpression: string;
+  }): Promise<string> {
+    const id = crypto.randomUUID();
+
+    const scheduledRequest: 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);
+    // Create cron job
+    const cronJob = cron.schedule(request.cronExpression, async () => {
+      await this.executeScheduledRequest(scheduledRequest);
 
-    return scheduledAction.id;
-  }
+      if (!scheduledRequest.isRecurring) {
+        this.cancelScheduledRequest(id);
+      }
+    });
 
-  private async initializeScheduledActions() {
-    const pendingActions = await this.storage.getPendingActions();
-    pendingActions.forEach((action) => this.scheduleExecution(action));
-  }
+    // Store request and job
+    this.scheduledRequests.set(id, scheduledRequest);
+    this.cronJobs.set(id, cronJob);
 
-  private scheduleExecution(scheduledAction: 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: ActionSchema) => 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");
-      }
-    }, delay);
+    console.log(
+      `✅ Request scheduled with cron expression: ${request.cronExpression}`
+    );
 
-    this.scheduledActions.set(scheduledAction.id, timeout);
+    return id;
   }
 
-  private async executeScheduledAction(scheduledAction: ScheduledAction) {
+  /**
+   * Execute a scheduled request by launching a new process
+   */
+  private async executeScheduledRequest(
+    request: ScheduledRequest
+  ): Promise<void> {
     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");
+      // Store the new actions in cache
+      if (result.actions.length > 0) {
+        await this.cache.storePreviousActions(request.id, result.actions);
+      }
 
-      this.events.onActionComplete?.(scheduledAction, result);
+      console.log(`✅ Scheduled request executed successfully`);
     } catch (error) {
-      await this.storage.updateActionStatus(scheduledAction.id, "failed");
-      this.events.onActionFailed?.(scheduledAction, error as Error);
-      throw error;
+      console.error(`❌ Failed to execute scheduled request:`, error);
     }
   }
 
-  private calculateNextExecutionTime(
-    currentTime: Date,
-    recurrence: NonNullable<ScheduledAction["recurrence"]>
-  ): Date {
-    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;
+  /**
+   * Cancel a scheduled request
+   */
+  cancelScheduledRequest(requestId: string): boolean {
+    const cronJob = this.cronJobs.get(requestId);
+    if (cronJob) {
+      cronJob.stop();
+      this.cronJobs.delete(requestId);
     }
-
-    return nextTime;
+    return this.scheduledRequests.delete(requestId);
   }
 
-  async cancelScheduledAction(actionId: string): Promise<boolean> {
-    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;
-    }
-    return false;
-  }
-}
-
-class ScheduledActionStorage {
-  private actions: ScheduledAction[] = [];
-
-  async saveScheduledAction(action: ScheduledAction): Promise<void> {
-    this.actions.push(action);
+  /**
+   * Get all scheduled requests
+   */
+  getScheduledRequests(): ScheduledRequest[] {
+    return Array.from(this.scheduledRequests.values());
   }
 
-  async getPendingActions(): Promise<ScheduledAction[]> {
-    return this.actions.filter((action) => action.status === "pending");
-  }
-
-  async updateActionStatus(
-    actionId: string,
-    status: ScheduledAction["status"]
-  ): Promise<void> {
-    const action = this.actions.find((a) => a.id === actionId);
-    if (action) {
-      action.status = status;
+  /**
+   * Stop all cron jobs
+   */
+  stopAll(): void {
+    for (const [id, cronJob] of this.cronJobs) {
+      cronJob.stop();
+      this.cronJobs.delete(id);
+      this.scheduledRequests.delete(id);
     }
-  }
-
-  async deleteScheduledAction(actionId: string): Promise<void> {
-    this.actions = this.actions.filter((a) => a.id !== actionId);
+    console.log("All scheduled requests stopped");
   }
 }

package/services/telegram-monitor.ts

@@ -1,138 +1,138 @@
-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);
-  },
-});
+// 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);
+//   },
+// });

package/t.py

@@ -0,0 +1,79 @@
+import os
+import platform
+import subprocess
+import urllib.request
+import sys
+
+def download_meilisearch():
+    """Download the Meilisearch binary for the current OS."""
+    print("Checking operating system...")
+    os_name = platform.system().lower()
+    if os_name == "windows":
+        binary_url = "https://github.com/meilisearch/meilisearch/releases/latest/download/meilisearch-windows-amd64.exe"
+        binary_name = "meilisearch.exe"
+    elif os_name == "darwin":  # macOS
+        binary_url = "https://github.com/meilisearch/meilisearch/releases/latest/download/meilisearch-macos-amd64"
+        binary_name = "meilisearch"
+    elif os_name == "linux":
+        binary_url = "https://github.com/meilisearch/meilisearch/releases/latest/download/meilisearch-linux-amd64"
+        binary_name = "meilisearch"
+    else:
+        print(f"Unsupported operating system: {os_name}")
+        sys.exit(1)
+
+    # Download the binary
+    if not os.path.exists(binary_name):
+        print(f"Downloading Meilisearch binary for {os_name}...")
+        try:
+            urllib.request.urlretrieve(binary_url, binary_name)
+            print("Download complete.")
+        except Exception as e:
+            print(f"Failed to download Meilisearch: {e}")
+            sys.exit(1)
+
+        # Add execute permissions for Linux/macOS
+        if os_name != "windows":
+            os.chmod(binary_name, 0o755)
+    else:
+        print("Meilisearch binary already exists.")
+
+    return binary_name
+
+
+def create_data_directory():
+    """Create a directory for Meilisearch data if it doesn't exist."""
+    data_dir = "./data"
+    if not os.path.exists(data_dir):
+        print("Creating data directory...")
+        os.makedirs(data_dir)
+    else:
+        print("Data directory already exists.")
+    return data_dir
+
+def launch_meilisearch(binary_name, data_dir):
+    """Launch the Meilisearch server."""
+    print("Launching Meilisearch...")
+    try:
+        process = subprocess.Popen(
+            [
+                f"./{binary_name}" if platform.system().lower() != "windows" else binary_name,
+                "--db-path",
+                data_dir,
+                "--master-key",
+                "DEFAULT_MASTER_KEY",
+            ],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        print("Meilisearch is running! Access it at http://localhost:7700")
+        for line in iter(process.stdout.readline, b""):
+            print("Meilisearch Log:", line.decode().strip())
+    except Exception as e:
+        print(f"Failed to launch Meilisearch: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    binary = download_meilisearch()
+    data_directory = create_data_directory()
+    launch_meilisearch(binary, data_directory)

package/t.spec

@@ -0,0 +1,38 @@
+# -*- mode: python ; coding: utf-8 -*-
+
+
+a = Analysis(
+    ['t.py'],
+    pathex=[],
+    binaries=[],
+    datas=[],
+    hiddenimports=[],
+    hookspath=[],
+    hooksconfig={},
+    runtime_hooks=[],
+    excludes=[],
+    noarchive=False,
+    optimize=0,
+)
+pyz = PYZ(a.pure)
+
+exe = EXE(
+    pyz,
+    a.scripts,
+    a.binaries,
+    a.datas,
+    [],
+    name='t',
+    debug=False,
+    bootloader_ignore_signals=False,
+    strip=False,
+    upx=True,
+    upx_exclude=[],
+    runtime_tmpdir=None,
+    console=True,
+    disable_windowed_traceback=False,
+    argv_emulation=False,
+    target_arch=None,
+    codesign_identity=None,
+    entitlements_file=None,
+)