@ai.ntellect/core 0.3.1 → 0.4.0

package/dist/services/scheduler.d.ts

@@ -0,0 +1,40 @@
+import { AgentRuntime } from "../llm/orchestrator";
+import { RedisCache } from "./redis-cache";
+interface ScheduledRequest {
+    id: string;
+    originalRequest: string;
+    cronExpression: string;
+    isRecurring: boolean;
+    createdAt: Date;
+}
+export declare class TaskScheduler {
+    private scheduledRequests;
+    private cronJobs;
+    private readonly agentRuntime;
+    private readonly cache;
+    constructor(agentRuntime: AgentRuntime, cache: RedisCache);
+    /**
+     * Schedule a new request to be processed later
+     */
+    scheduleRequest(request: {
+        originalRequest: string;
+        cronExpression: string;
+    }): Promise<string>;
+    /**
+     * Execute a scheduled request by launching a new process
+     */
+    private executeScheduledRequest;
+    /**
+     * Cancel a scheduled request
+     */
+    cancelScheduledRequest(requestId: string): boolean;
+    /**
+     * Get all scheduled requests
+     */
+    getScheduledRequests(): ScheduledRequest[];
+    /**
+     * Stop all cron jobs
+     */
+    stopAll(): void;
+}
+export {};

package/dist/services/scheduler.js

@@ -0,0 +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.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;
+    }
+    /**
+     * 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(),
+        };
+        // Create cron job
+        const cronJob = node_cron_1.default.schedule(request.cronExpression, async () => {
+            await this.executeScheduledRequest(scheduledRequest);
+            if (!scheduledRequest.isRecurring) {
+                this.cancelScheduledRequest(id);
+            }
+        });
+        // 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;
+    }
+    /**
+     * Execute a scheduled request by launching a new process
+     */
+    async executeScheduledRequest(request) {
+        try {
+            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,
+            });
+            // 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) {
+            console.error(`❌ Failed to execute scheduled request:`, error);
+        }
+    }
+    /**
+     * Cancel a scheduled request
+     */
+    cancelScheduledRequest(requestId) {
+        const cronJob = this.cronJobs.get(requestId);
+        if (cronJob) {
+            cronJob.stop();
+            this.cronJobs.delete(requestId);
+        }
+        return this.scheduledRequests.delete(requestId);
+    }
+    /**
+     * Get all scheduled requests
+     */
+    getScheduledRequests() {
+        return Array.from(this.scheduledRequests.values());
+    }
+    /**
+     * Stop all cron jobs
+     */
+    stopAll() {
+        for (const [id, cronJob] of this.cronJobs) {
+            cronJob.stop();
+            this.cronJobs.delete(id);
+            this.scheduledRequests.delete(id);
+        }
+        console.log("All scheduled requests stopped");
+    }
+}
+exports.TaskScheduler = TaskScheduler;

package/dist/services/telegram-monitor.js

@@ -0,0 +1,118 @@
+"use strict";
+// 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/dist/test.d.ts

@@ -1,167 +0,0 @@
-import { z } from "zod";
-export declare const checkHoneypot: {
-    name: string;
-    description: string;
-    parameters: z.ZodObject<{
-        address: z.ZodString;
-        chainName: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        address: string;
-        chainName: string;
-    }, {
-        address: string;
-        chainName: string;
-    }>;
-    execute: ({ address, chainName, }: {
-        address: string;
-        chainName?: string;
-    }) => Promise<{
-        status: string;
-        token: {
-            name: any;
-            symbol: any;
-            address: any;
-            holders: any;
-        };
-        risk: {
-            level: any;
-            score: any;
-            flags: any;
-        };
-        analysis: {
-            isHoneypot: any;
-            reason: any;
-            buyTax: any;
-            sellTax: any;
-            holders: {
-                total: any;
-                successful: any;
-                failed: any;
-                siphoned: any;
-            };
-        };
-        chain: {
-            name: any;
-            id: any;
-        };
-    } | {
-        status: string;
-        message: string;
-        chain: {
-            name: string;
-            id: string;
-        };
-    }>;
-};
-export interface NetworkConfig {
-    name: string;
-    id?: number;
-    rpc: string;
-    explorerUrl: string;
-    nativeToken: string;
-}
-export declare const networkConfigs: Record<string, NetworkConfig>;
-export declare const getNetworkProvider: (networkName: string) => {
-    config: NetworkConfig;
-};
-export type TransactionPrepared = {
-    to: string;
-    value: string;
-    data?: string;
-    chain: {
-        id: number;
-        rpc: string;
-    };
-    type: "transfer" | "approve" | "swap";
-    method?: string;
-    params?: any[];
-};
-export declare const prepareEvmTransaction: {
-    name: string;
-    description: string;
-    parameters: z.ZodObject<{
-        walletAddress: z.ZodString;
-        amount: z.ZodString;
-        network: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        walletAddress: string;
-        amount: string;
-        network: string;
-    }, {
-        walletAddress: string;
-        amount: string;
-        network: string;
-    }>;
-    execute: ({ walletAddress, amount, network, }: {
-        walletAddress: string;
-        amount: string;
-        network: string;
-    }) => Promise<TransactionPrepared>;
-};
-export declare const fetchMarkPrice: {
-    name: string;
-    description: string;
-    parameters: z.ZodObject<{
-        symbol: z.ZodString;
-        params: z.ZodObject<{
-            subType: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            subType: string;
-        }, {
-            subType: string;
-        }>;
-    }, "strip", z.ZodTypeAny, {
-        symbol: string;
-        params: {
-            subType: string;
-        };
-    }, {
-        symbol: string;
-        params: {
-            subType: string;
-        };
-    }>;
-    execute: ({ symbol, params }: {
-        symbol: string;
-        params: any;
-    }) => Promise<import("ccxt").Ticker>;
-};
-export declare const getChainsTVL: {
-    name: string;
-    description: string;
-    parameters: z.ZodObject<{
-        limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    }, "strip", z.ZodTypeAny, {
-        limit: number;
-    }, {
-        limit?: number | undefined;
-    }>;
-    execute: ({ limit }: {
-        limit: number;
-    }) => Promise<{
-        summary: {
-            totalTVL: number;
-            numberOfChains: number;
-        };
-        topChains: {
-            name: string;
-            tvl: number;
-            tokenSymbol: string | null;
-        }[];
-    }>;
-};
-export declare const getRssNews: {
-    name: string;
-    description: string;
-    parameters: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
-    execute: () => Promise<{
-        status: string;
-        items: {
-            title: any;
-            content: string;
-            link: any;
-            date: any;
-            source: any;
-        }[];
-    }>;
-};