@ai.ntellect/core 0.4.1 → 0.6.0

package/memory/persistent.ts

@@ -1,265 +0,0 @@
-import { cosineSimilarity, embed, EmbeddingModel, embedMany } from "ai";
-import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";
-import { LongTermMemory, MemoryScope } from "../types";
-
-interface SearchOptions {
-  scope?: MemoryScope;
-  userId?: string;
-  maxResults?: number;
-  similarityThreshold?: number;
-}
-
-interface MeilisearchSettings {
-  searchableAttributes?: string[];
-  sortableAttributes?: string[];
-}
-
-interface MeilisearchResponse {
-  hits: Array<{
-    createdAt: string;
-    query: string;
-    purpose: string;
-    data?: any;
-    chunks: Array<{
-      content: string;
-      embedding: number[];
-    }>;
-  }>;
-}
-
-interface ProcessedChunk {
-  content: string;
-  embedding: number[];
-}
-
-/**
- * Handles persistent memory storage using Meilisearch API
- */
-export class PersistentMemory {
-  private readonly host: string;
-  private readonly apiKey: string;
-  private readonly INDEX_PREFIX: string;
-  private readonly embeddingModel: EmbeddingModel<string>;
-  constructor(options: {
-    host: string;
-    apiKey: string;
-    indexPrefix?: string;
-    embeddingModel: EmbeddingModel<string>;
-  }) {
-    this.host = options.host;
-    this.apiKey = options.apiKey;
-    this.INDEX_PREFIX = options.indexPrefix || "memory";
-    this.embeddingModel = options.embeddingModel;
-  }
-
-  /**
-   * Initialize indexes
-   */
-  async init() {
-    try {
-      // Create or get main index
-      await this._getOrCreateIndex(this.INDEX_PREFIX);
-      console.log(`✅ Index '${this.INDEX_PREFIX}' initialized successfully`);
-    } catch (error) {
-      console.error(`❌ Failed to initialize index: ${error}`);
-      throw error;
-    }
-  }
-
-  /**
-   * Make API request to Meilisearch
-   */
-  private async _makeRequest<T = unknown>(
-    path: string,
-    options: RequestInit = {}
-  ): Promise<T> {
-    const url = `${this.host}${path}`;
-    console.log("🔍 Making request to Meilisearch:", url);
-    const response = await fetch(url, {
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`,
-        ...options.headers,
-      },
-    });
-
-    if (!response.ok) {
-      console.log({ response });
-      throw new Error(`Meilisearch API error: ${response.statusText}`);
-    }
-
-    return response.json() as Promise<T>;
-  }
-
-  /**
-   * Get or create an index with proper settings
-   */
-  private async _getOrCreateIndex(indexName: string) {
-    try {
-      // Check if index exists first
-      const indexExists = await this._makeRequest(`/indexes/${indexName}`, {
-        method: "GET",
-      }).catch(() => false);
-
-      if (!indexExists) {
-        console.log(`Creating new index: ${indexName}`);
-        await this._makeRequest("/indexes", {
-          method: "POST",
-          body: JSON.stringify({
-            uid: indexName,
-            primaryKey: "id",
-          }),
-        });
-      }
-
-      // Update index settings
-      const settings: MeilisearchSettings = {
-        searchableAttributes: ["query", "purpose", "chunks.content"],
-        sortableAttributes: ["createdAt"],
-      };
-
-      await this._makeRequest(`/indexes/${indexName}/settings`, {
-        method: "PATCH",
-        body: JSON.stringify(settings),
-      });
-
-      console.log(`Index ${indexName} configured successfully`);
-    } catch (error: any) {
-      console.error(`Failed to configure index ${indexName}:`, error);
-      throw error;
-    }
-  }
-
-  async processContent(content: string): Promise<ProcessedChunk[]> {
-    // Split content into chunks
-    const textSplitter = new RecursiveCharacterTextSplitter({
-      chunkSize: 1000,
-    });
-    const chunks = await textSplitter.createDocuments([content]);
-
-    // Generate embeddings for all chunks
-    const { embeddings } = await embedMany({
-      model: this.embeddingModel,
-      values: chunks.map((chunk) => chunk.pageContent),
-    });
-
-    // Create processed chunks with embeddings
-    return chunks.map((chunk, i) => ({
-      content: chunk.pageContent,
-      embedding: embeddings[i],
-    }));
-  }
-
-  /**
-   * Store a memory in the database
-   */
-  async createMemory(memory: LongTermMemory) {
-    try {
-      console.log(`📝 Creating memory in index: ${this.INDEX_PREFIX}`);
-
-      // Process content into chunks with embeddings
-      const chunks = await this.processContent(memory.data);
-
-      // Generate unique ID if not provided
-      const id = memory.id || crypto.randomUUID();
-
-      const document = {
-        ...memory,
-        chunks,
-        createdAt: memory.createdAt.toISOString(),
-      };
-
-      const response = await this._makeRequest(
-        `/indexes/${this.INDEX_PREFIX}/documents`,
-        {
-          method: "POST",
-          body: JSON.stringify([document]),
-        }
-      );
-
-      console.log("✅ Memory created successfully", { id });
-      return response;
-    } catch (error) {
-      console.error("❌ Failed to create memory:", error);
-      throw error;
-    }
-  }
-
-  /**
-   * Find best matching memories
-   */
-  async findRelevantDocuments(query: string, options: SearchOptions = {}) {
-    console.log(`\n🔍 Searching in index: ${this.INDEX_PREFIX}`);
-    console.log("Query:", query);
-
-    try {
-      // Generate embedding for the query
-      const { embedding: queryEmbedding } = await embed({
-        model: this.embeddingModel,
-        value: query,
-      });
-
-      // Search in the index
-      const searchResults = await this._makeRequest<MeilisearchResponse>(
-        `/indexes/${this.INDEX_PREFIX}/search`,
-        {
-          method: "POST",
-          body: JSON.stringify({
-            q: query,
-            limit: options.maxResults || 10,
-          }),
-        }
-      );
-
-      if (!searchResults?.hits?.length) {
-        console.log("❌ No matches found");
-        return [];
-      }
-
-      // Process and filter results using cosine similarity
-      const results = searchResults.hits
-        .flatMap((hit) => {
-          const chunkSimilarities = hit.chunks.map((chunk) => ({
-            query: hit.query,
-            data: hit.data,
-            similarityPercentage:
-              (cosineSimilarity(queryEmbedding, chunk.embedding) + 1) * 50,
-            createdAt: hit.createdAt,
-          }));
-
-          return chunkSimilarities.reduce(
-            (best, current) =>
-              current.similarityPercentage > best.similarityPercentage
-                ? current
-                : best,
-            chunkSimilarities[0]
-          );
-        })
-        .filter(
-          (match) =>
-            match.similarityPercentage >= (options.similarityThreshold || 70)
-        )
-        .sort((a, b) => b.similarityPercentage - a.similarityPercentage);
-
-      console.log(`✨ Found ${results.length} relevant matches`);
-      return results.map((result) => ({
-        query: result.query,
-        data: result.data,
-        createdAt: result.createdAt,
-      }));
-    } catch (error) {
-      console.error("❌ Search failed:", error);
-      return [];
-    }
-  }
-
-  /**
-   * Delete memories for a given scope and user
-   */
-  async deleteMemories() {
-    return this._makeRequest(`/indexes/${this.INDEX_PREFIX}`, {
-      method: "DELETE",
-    });
-  }
-}

package/services/redis-cache.ts

@@ -1,128 +0,0 @@
-import Redis from "ioredis";
-import cron from "node-cron";
-
-export interface CacheConfig {
-  host: string;
-  port: number;
-  password?: string;
-  ttl?: number; // Time to live in seconds (default 30 minutes)
-  cleanupInterval?: string; // Cron expression (default every 30 minutes)
-}
-
-export class RedisCache {
-  private redis: Redis;
-  private readonly defaultTTL: number;
-  private readonly cleanupJob: cron.ScheduledTask;
-
-  constructor(config: CacheConfig) {
-    this.redis = new Redis({
-      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 = cron.schedule(
-      config.cleanupInterval || "*/30 * * * *",
-      () => this.cleanup()
-    );
-  }
-
-  /**
-   * Store previous actions for a specific request
-   */
-  async storePreviousActions(requestId: string, actions: any[]): Promise<void> {
-    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: string): Promise<any[]> {
-    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: string,
-    metadata?: Record<string, any>
-  ): Promise<void> {
-    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: number = 10): Promise<any[]> {
-    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
-   */
-  private async cleanup(): Promise<void> {
-    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(): Promise<void> {
-    this.cleanupJob.stop();
-    await this.redis.quit();
-  }
-}

package/services/scheduler.ts

@@ -1,128 +0,0 @@
-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;
-  }
-
-  /**
-   * 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(),
-    };
-
-    // Create cron job
-    const cronJob = cron.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
-   */
-  private async executeScheduledRequest(
-    request: ScheduledRequest
-  ): Promise<void> {
-    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: string): boolean {
-    const cronJob = this.cronJobs.get(requestId);
-    if (cronJob) {
-      cronJob.stop();
-      this.cronJobs.delete(requestId);
-    }
-    return this.scheduledRequests.delete(requestId);
-  }
-
-  /**
-   * Get all scheduled requests
-   */
-  getScheduledRequests(): ScheduledRequest[] {
-    return Array.from(this.scheduledRequests.values());
-  }
-
-  /**
-   * Stop all cron jobs
-   */
-  stopAll(): void {
-    for (const [id, cronJob] of this.cronJobs) {
-      cronJob.stop();
-      this.cronJobs.delete(id);
-      this.scheduledRequests.delete(id);
-    }
-    console.log("All scheduled requests stopped");
-  }
-}

package/services/telegram-monitor.ts

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