@ai.ntellect/core 0.5.0 → 0.6.1

package/dist/services/redis-cache.js

@@ -1,93 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisCache = void 0;
-const ioredis_1 = __importDefault(require("ioredis"));
-const node_cron_1 = __importDefault(require("node-cron"));
-class RedisCache {
-    constructor(config) {
-        this.redis = new ioredis_1.default({
-            host: config.host,
-            port: config.port,
-            password: config.password,
-        });
-        this.defaultTTL = config.ttl || 1800; // 30 minutes in seconds
-        // Setup cleanup job (default: every 30 minutes)
-        this.cleanupJob = node_cron_1.default.schedule(config.cleanupInterval || "*/30 * * * *", () => this.cleanup());
-    }
-    /**
-     * Store previous actions for a specific request
-     */
-    async storePreviousActions(requestId, actions) {
-        const key = `previous_actions:${requestId}`;
-        await this.redis.setex(key, this.defaultTTL, JSON.stringify({
-            timestamp: new Date().toISOString(),
-            actions,
-        }));
-    }
-    /**
-     * Get previous actions for a specific request
-     */
-    async getPreviousActions(requestId) {
-        const key = `previous_actions:${requestId}`;
-        const data = await this.redis.get(key);
-        if (!data)
-            return [];
-        const parsed = JSON.parse(data);
-        return parsed.actions;
-    }
-    /**
-     * Store a recent message
-     */
-    async storeRecentMessage(message, metadata) {
-        const id = crypto.randomUUID();
-        const key = `recent_messages:${id}`;
-        await this.redis.setex(key, this.defaultTTL, JSON.stringify({
-            timestamp: new Date().toISOString(),
-            message,
-            metadata,
-        }));
-    }
-    /**
-     * Get recent messages
-     */
-    async getRecentMessages(limit = 10) {
-        const keys = await this.redis.keys("recent_messages:*");
-        if (!keys.length)
-            return [];
-        const messages = await Promise.all(keys.map(async (key) => {
-            const data = await this.redis.get(key);
-            return data ? JSON.parse(data) : null;
-        }));
-        return messages
-            .filter(Boolean)
-            .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime())
-            .slice(0, limit);
-    }
-    /**
-     * Cleanup expired keys
-     */
-    async cleanup() {
-        console.log("🧹 Starting cache cleanup...");
-        try {
-            // Redis automatically removes expired keys
-            // This is just for logging purposes
-            const actionKeys = await this.redis.keys("previous_actions:*");
-            const messageKeys = await this.redis.keys("recent_messages:*");
-            console.log(`Cache status: ${actionKeys.length} actions, ${messageKeys.length} messages`);
-        }
-        catch (error) {
-            console.error("❌ Cache cleanup error:", error);
-        }
-    }
-    /**
-     * Stop the cleanup job and close Redis connection
-     */
-    async close() {
-        this.cleanupJob.stop();
-        await this.redis.quit();
-    }
-}
-exports.RedisCache = RedisCache;

package/dist/services/scheduler.d.ts

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

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

@@ -1,118 +0,0 @@
-"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/t.d.ts

@@ -1,46 +0,0 @@
-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;
-};
-import { z } from "zod";
-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>;
-};

package/dist/t.js

@@ -1,102 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.prepareEvmTransaction = exports.getNetworkProvider = exports.networkConfigs = void 0;
-exports.networkConfigs = {
-    ethereum: {
-        name: "Ethereum Mainnet",
-        id: 1,
-        rpc: "https://eth.llamarpc.com",
-        explorerUrl: "https://etherscan.io",
-        nativeToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
-    },
-    polygon: {
-        name: "Polygon Mainnet",
-        id: 137,
-        rpc: "https://polygon.llamarpc.com",
-        explorerUrl: "https://polygonscan.com",
-        nativeToken: "0x0000000000000000000000000000000000001010",
-    },
-    arbitrum: {
-        name: "Arbitrum Mainnet",
-        id: 42161,
-        rpc: "https://arbitrum.llamarpc.com",
-        explorerUrl: "https://arbiscan.io",
-        nativeToken: "0x82af49447d8a07e3bd95bd0d56f35241523fbab1",
-    },
-    base: {
-        name: "Base Mainnet",
-        id: 8453,
-        rpc: "https://base.llamarpc.com",
-        explorerUrl: "https://basescan.org",
-        nativeToken: "0x4200000000000000000000000000000000000006",
-    },
-    solana: {
-        name: "Solana Mainnet",
-        rpc: "https://api.mainnet-beta.solana.com",
-        explorerUrl: "https://solscan.io",
-        nativeToken: "So11111111111111111111111111111111111111112",
-    },
-    sepolia: {
-        name: "Sepolia Testnet",
-        id: 11155111,
-        rpc: "https://sepolia.llamarpc.com",
-        explorerUrl: "https://sepolia.etherscan.io",
-        nativeToken: "0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14",
-    },
-    baseSepolia: {
-        name: "Base Sepolia Testnet",
-        id: 84532,
-        rpc: "https://base-sepolia-rpc.publicnode.com",
-        explorerUrl: "https://sepolia.basescan.org",
-        nativeToken: "0x4200000000000000000000000000000000000006",
-    },
-};
-const getNetworkProvider = (networkName) => {
-    const config = exports.networkConfigs[networkName.toLowerCase()];
-    if (!config) {
-        throw new Error(`Network ${networkName} not supported`);
-    }
-    return { config };
-};
-exports.getNetworkProvider = getNetworkProvider;
-const ethers_1 = require("ethers");
-const zod_1 = require("zod");
-exports.prepareEvmTransaction = {
-    name: "prepare-evm-transaction",
-    description: "Prepare a transaction for the user to sign.",
-    parameters: zod_1.z.object({
-        walletAddress: zod_1.z.string(),
-        amount: zod_1.z
-            .string()
-            .describe("Ask the user for the amount to send, if not specified"),
-        network: zod_1.z
-            .string()
-            .describe("Examples networks: ethereum, arbitrum, base. IMPORTANT: You must respect the network name."),
-    }),
-    execute: async ({ walletAddress, amount, network, }) => {
-        try {
-            console.log("💰 Preparing transaction", {
-                to: walletAddress,
-                amount,
-                network,
-            });
-            const networkConfig = exports.networkConfigs[network.toLowerCase()];
-            if (!networkConfig) {
-                throw new Error(`Network ${network} not found`);
-            }
-            return {
-                to: walletAddress,
-                value: (0, ethers_1.parseEther)(amount).toString(),
-                chain: {
-                    id: networkConfig.id || 0,
-                    rpc: networkConfig.rpc,
-                },
-                type: "transfer",
-            };
-        }
-        catch (error) {
-            console.error("💰 Error sending transaction:", error);
-            throw new Error("An error occurred while sending the transaction");
-        }
-    },
-};