@ai.ntellect/core 0.3.1 → 0.3.3

package/dist/types.d.ts

@@ -154,8 +154,7 @@ export interface Memory {
     query: string;
     purpose: string;
     data: any;
-    scope: MemoryScopeType;
-    userId?: string;
+    roomId: string;
     createdAt: Date;
     chunks?: MemoryChunk[];
 }
@@ -205,3 +204,24 @@ export interface TransformedQueueItem {
     name: string;
     parameters: QueueItemParameter[];
 }
+export interface ScheduledAction {
+    id: string;
+    action: {
+        name: string;
+        parameters: QueueItemParameter[];
+    };
+    scheduledTime: Date;
+    userId: string;
+    status: "pending" | "completed" | "failed";
+    recurrence?: {
+        type: "daily" | "weekly" | "monthly";
+        interval: number;
+    };
+}
+export interface ScheduledActionEvents {
+    onActionStart?: (action: ScheduledAction) => void;
+    onActionComplete?: (action: ScheduledAction, result: any) => void;
+    onActionFailed?: (action: ScheduledAction, error: Error) => void;
+    onActionScheduled?: (action: ScheduledAction) => void;
+    onActionCancelled?: (actionId: string) => void;
+}

package/llm/evaluator/index.ts

@@ -3,7 +3,7 @@ import { generateObject } from "ai";
 import { z } from "zod";
 import { CacheMemory } from "../../memory/cache";
 import { PersistentMemory } from "../../memory/persistent";
-import { ActionSchema, MemoryScope, MemoryType, State } from "../../types";
+import { ActionSchema, MemoryType, State } from "../../types";
 import { injectActions } from "../../utils/inject-actions";
 import { Interpreter } from "../interpreter";
 import { evaluatorContext } from "./context";
@@ -129,7 +129,7 @@ export class Evaluator {
             purpose: item.memoryType,
             query: item.queryForData,
             data: item.data,
-            scope: MemoryScope.GLOBAL,
+            roomId: "global",
             createdAt: new Date(),
           });
         }
@@ -142,7 +142,6 @@ export class Evaluator {
           content: prompt,
           type: MemoryType.ACTION,
           data: validatedResponse.actionsAlreadyDone,
-          scope: MemoryScope.GLOBAL,
         });
         console.log(
           "✅ Workflow actions completed stored in cache",
@@ -177,7 +176,7 @@ export class Evaluator {
                 purpose: "importantToRemember",
                 query: item.content,
                 data: item.data,
-                scope: MemoryScope.GLOBAL,
+                roomId: "global",
                 createdAt: new Date(),
               });
             }

package/memory/cache.ts

@@ -44,15 +44,8 @@ export class CacheMemory {
     }
   }
 
-  private getMemoryKey(scope: MemoryScope, userId?: string): string {
-    if (scope === MemoryScope.GLOBAL) {
-      return `${this.CACHE_PREFIX}global:`;
-    }
-    return `${this.CACHE_PREFIX}user:${userId}:`;
-  }
-
   private async storeMemory(memory: CacheMemoryType) {
-    const prefix = this.getMemoryKey(memory.scope, memory.userId);
+    const prefix = this.CACHE_PREFIX;
     const key = `${prefix}${memory.id}`;
     const result = await this.redis.set(key, JSON.stringify(memory), {
       EX: this.CACHE_TTL,
@@ -124,23 +117,10 @@ export class CacheMemory {
     scope?: MemoryScope,
     userId?: string
   ): Promise<CacheMemoryType[]> {
-    let patterns: CacheMemoryType[] = [];
-
-    if (!scope || scope === MemoryScope.GLOBAL) {
-      const globalPrefix = this.getMemoryKey(MemoryScope.GLOBAL);
-      const globalKeys = await this.redis.keys(`${globalPrefix}*`);
-      const globalPatterns = await this.getMemoriesFromKeys(globalKeys);
-      patterns = patterns.concat(globalPatterns);
-    }
-
-    if (userId && (!scope || scope === MemoryScope.USER)) {
-      const userPrefix = this.getMemoryKey(MemoryScope.USER, userId);
-      const userKeys = await this.redis.keys(`${userPrefix}*`);
-      const userPatterns = await this.getMemoriesFromKeys(userKeys);
-      patterns = patterns.concat(userPatterns);
-    }
+    const keys = await this.redis.keys(`${this.CACHE_PREFIX}*`);
+    const memories = await this.getMemoriesFromKeys(keys);
 
-    return patterns;
+    return memories;
   }
 
   private async getMemoriesFromKeys(

package/memory/persistent.ts

@@ -28,18 +28,6 @@ interface MeilisearchResponse {
   }>;
 }
 
-interface SearchParams {
-  q?: string;
-  offset?: number;
-  limit?: number;
-  filter?: string | string[];
-  facets?: string[];
-  attributesToRetrieve?: string[];
-  attributesToSearchOn?: string[];
-  sort?: string[];
-  matchingStrategy?: "last" | "all" | "frequency";
-}
-
 interface ProcessedChunk {
   content: string;
   embedding: number[];
@@ -56,7 +44,7 @@ export class PersistentMemory {
   constructor(options: { host: string; apiKey: string; indexPrefix?: string }) {
     this.host = options.host;
     this.apiKey = options.apiKey;
-    this.INDEX_PREFIX = options.indexPrefix || "memory_";
+    this.INDEX_PREFIX = options.indexPrefix || "memory";
   }
 
   /**
@@ -64,10 +52,7 @@ export class PersistentMemory {
    */
   async init() {
     // Create global index
-    await this._getOrCreateIndex(this._getIndexName(MemoryScope.GLOBAL));
-
-    // Create user index
-    await this._getOrCreateIndex(this._getIndexName(MemoryScope.USER));
+    await this._getOrCreateIndex(this.INDEX_PREFIX);
   }
 
   /**
@@ -94,17 +79,6 @@ export class PersistentMemory {
 
     return response.json() as Promise<T>;
   }
-
-  /**
-   * Get index name based on scope and userId
-   */
-  private _getIndexName(scope: MemoryScope, userId?: string): string {
-    if (scope === "global") {
-      return `${this.INDEX_PREFIX}global`;
-    }
-    return `${this.INDEX_PREFIX}user_${userId}`;
-  }
-
   /**
    * Get or create an index with proper settings
    */
@@ -161,8 +135,7 @@ export class PersistentMemory {
    * Store a memory in the database
    */
   async createMemory(memory: Memory) {
-    const indexName = this._getIndexName(memory.scope, memory.userId);
-    await this._getOrCreateIndex(indexName);
+    await this._getOrCreateIndex(memory.roomId);
 
     const chunks = await this.processContent(memory.data);
 
@@ -173,7 +146,7 @@ export class PersistentMemory {
     };
 
     const response = await this._makeRequest(
-      `/indexes/${indexName}/documents`,
+      `/indexes/${this.INDEX_PREFIX}/documents`,
       {
         method: "POST",
         body: JSON.stringify([document]),
@@ -199,42 +172,20 @@ export class PersistentMemory {
 
     const searchResults = [];
 
-    // Search in global memories
-    if (!options.scope || options.scope === "global") {
-      const globalIndex = this._getIndexName(MemoryScope.GLOBAL);
-      console.log("\n📚 Searching in global index:", globalIndex);
-      try {
-        const globalResults = await this._makeRequest<MeilisearchResponse>(
-          `/indexes/${globalIndex}/search`,
-          {
-            method: "POST",
-            body: JSON.stringify({ q: query }),
-          }
-        );
-        if (globalResults?.hits) {
-          searchResults.push(...globalResults.hits);
-        }
-      } catch (error) {
-        console.error("❌ Error searching global index:", error);
-      }
-    }
-
-    // Search in user memories
-    if (
-      options.userId &&
-      (!options.scope || options.scope === MemoryScope.USER)
-    ) {
-      const userIndex = this._getIndexName(MemoryScope.USER, options.userId);
-      const userResults = await this._makeRequest<MeilisearchResponse>(
-        `/indexes/${userIndex}/search`,
+    console.log("\n📚 Searching in global index:", this.INDEX_PREFIX);
+    try {
+      const globalResults = await this._makeRequest<MeilisearchResponse>(
+        `/indexes/${this.INDEX_PREFIX}/search`,
         {
           method: "POST",
           body: JSON.stringify({ q: query }),
         }
       );
-      if (userResults.hits) {
-        searchResults.push(...userResults.hits);
+      if (globalResults?.hits) {
+        searchResults.push(...globalResults.hits);
       }
+    } catch (error) {
+      console.error("❌ Error searching global index:", error);
     }
 
     const totalResults = searchResults.length;
@@ -284,9 +235,8 @@ export class PersistentMemory {
   /**
    * Delete memories for a given scope and user
    */
-  async deleteMemories(scope: MemoryScope, userId?: string) {
-    const indexName = this._getIndexName(scope, userId);
-    return this._makeRequest(`/indexes/${indexName}`, {
+  async deleteMemories() {
+    return this._makeRequest(`/indexes/${this.INDEX_PREFIX}`, {
       method: "DELETE",
     });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai.ntellect/core",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/services/scheduler.ts

@@ -0,0 +1,167 @@
+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();
+  }
+
+  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,
+    };
+
+    await this.storage.saveScheduledAction(scheduledAction);
+    this.scheduleExecution(scheduledAction);
+    this.events.onActionScheduled?.(scheduledAction);
+
+    return scheduledAction.id;
+  }
+
+  private async initializeScheduledActions() {
+    const pendingActions = await this.storage.getPendingActions();
+    pendingActions.forEach((action) => this.scheduleExecution(action));
+  }
+
+  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);
+
+    this.scheduledActions.set(scheduledAction.id, timeout);
+  }
+
+  private async executeScheduledAction(scheduledAction: 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 as Error);
+      throw 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;
+    }
+
+    return nextTime;
+  }
+
+  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);
+  }
+
+  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;
+    }
+  }
+
+  async deleteScheduledAction(actionId: string): Promise<void> {
+    this.actions = this.actions.filter((a) => a.id !== actionId);
+  }
+}

package/services/telegram-monitor.ts

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

package/types.ts

@@ -188,8 +188,7 @@ export interface Memory {
   query: string;
   purpose: string;
   data: any;
-  scope: MemoryScopeType;
-  userId?: string;
+  roomId: string;
   createdAt: Date;
   chunks?: MemoryChunk[];
 }
@@ -231,3 +230,26 @@ export interface TransformedQueueItem {
   name: string;
   parameters: QueueItemParameter[];
 }
+
+export interface ScheduledAction {
+  id: string;
+  action: {
+    name: string;
+    parameters: QueueItemParameter[];
+  };
+  scheduledTime: Date;
+  userId: string;
+  status: "pending" | "completed" | "failed";
+  recurrence?: {
+    type: "daily" | "weekly" | "monthly";
+    interval: number;
+  };
+}
+
+export interface ScheduledActionEvents {
+  onActionStart?: (action: ScheduledAction) => void;
+  onActionComplete?: (action: ScheduledAction, result: any) => void;
+  onActionFailed?: (action: ScheduledAction, error: Error) => void;
+  onActionScheduled?: (action: ScheduledAction) => void;
+  onActionCancelled?: (actionId: string) => void;
+}