@ai.ntellect/core 0.3.1 → 0.3.3

package/dist/services/scheduler.js

@@ -0,0 +1,121 @@
+"use strict";
+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();
+    }
+    async scheduleAction(action, scheduledTime, userId, recurrence) {
+        const scheduledAction = {
+            id: crypto.randomUUID(),
+            action: {
+                name: action.name,
+                parameters: [],
+            },
+            scheduledTime,
+            userId,
+            status: "pending",
+            recurrence,
+        };
+        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");
+            }
+        }, delay);
+        this.scheduledActions.set(scheduledAction.id, timeout);
+    }
+    async executeScheduledAction(scheduledAction) {
+        try {
+            this.events.onActionStart?.(scheduledAction);
+            this.actionQueueManager.addToQueue({
+                name: scheduledAction.action.name,
+                parameters: scheduledAction.action.parameters,
+            });
+            const result = await this.actionQueueManager.processQueue();
+            await this.storage.updateActionStatus(scheduledAction.id, "completed");
+            this.events.onActionComplete?.(scheduledAction, result);
+        }
+        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;
+        }
+        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;
+        }
+        return false;
+    }
+}
+exports.ActionScheduler = ActionScheduler;
+class ScheduledActionStorage {
+    constructor() {
+        this.actions = [];
+    }
+    async saveScheduledAction(action) {
+        this.actions.push(action);
+    }
+    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;
+        }
+    }
+    async deleteScheduledAction(actionId) {
+        this.actions = this.actions.filter((a) => a.id !== actionId);
+    }
+}

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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,102 @@
+"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);
+    },
+});

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;
-        }[];
-    }>;
-};