@ai.ntellect/core 0.3.1 → 0.4.0

package/services/redis-cache.ts

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

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

@@ -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/t.py

@@ -0,0 +1,79 @@
+import os
+import platform
+import subprocess
+import urllib.request
+import sys
+
+def download_meilisearch():
+    """Download the Meilisearch binary for the current OS."""
+    print("Checking operating system...")
+    os_name = platform.system().lower()
+    if os_name == "windows":
+        binary_url = "https://github.com/meilisearch/meilisearch/releases/latest/download/meilisearch-windows-amd64.exe"
+        binary_name = "meilisearch.exe"
+    elif os_name == "darwin":  # macOS
+        binary_url = "https://github.com/meilisearch/meilisearch/releases/latest/download/meilisearch-macos-amd64"
+        binary_name = "meilisearch"
+    elif os_name == "linux":
+        binary_url = "https://github.com/meilisearch/meilisearch/releases/latest/download/meilisearch-linux-amd64"
+        binary_name = "meilisearch"
+    else:
+        print(f"Unsupported operating system: {os_name}")
+        sys.exit(1)
+
+    # Download the binary
+    if not os.path.exists(binary_name):
+        print(f"Downloading Meilisearch binary for {os_name}...")
+        try:
+            urllib.request.urlretrieve(binary_url, binary_name)
+            print("Download complete.")
+        except Exception as e:
+            print(f"Failed to download Meilisearch: {e}")
+            sys.exit(1)
+
+        # Add execute permissions for Linux/macOS
+        if os_name != "windows":
+            os.chmod(binary_name, 0o755)
+    else:
+        print("Meilisearch binary already exists.")
+
+    return binary_name
+
+
+def create_data_directory():
+    """Create a directory for Meilisearch data if it doesn't exist."""
+    data_dir = "./data"
+    if not os.path.exists(data_dir):
+        print("Creating data directory...")
+        os.makedirs(data_dir)
+    else:
+        print("Data directory already exists.")
+    return data_dir
+
+def launch_meilisearch(binary_name, data_dir):
+    """Launch the Meilisearch server."""
+    print("Launching Meilisearch...")
+    try:
+        process = subprocess.Popen(
+            [
+                f"./{binary_name}" if platform.system().lower() != "windows" else binary_name,
+                "--db-path",
+                data_dir,
+                "--master-key",
+                "DEFAULT_MASTER_KEY",
+            ],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        print("Meilisearch is running! Access it at http://localhost:7700")
+        for line in iter(process.stdout.readline, b""):
+            print("Meilisearch Log:", line.decode().strip())
+    except Exception as e:
+        print(f"Failed to launch Meilisearch: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    binary = download_meilisearch()
+    data_directory = create_data_directory()
+    launch_meilisearch(binary, data_directory)

package/t.spec

@@ -0,0 +1,38 @@
+# -*- mode: python ; coding: utf-8 -*-
+
+
+a = Analysis(
+    ['t.py'],
+    pathex=[],
+    binaries=[],
+    datas=[],
+    hiddenimports=[],
+    hookspath=[],
+    hooksconfig={},
+    runtime_hooks=[],
+    excludes=[],
+    noarchive=False,
+    optimize=0,
+)
+pyz = PYZ(a.pure)
+
+exe = EXE(
+    pyz,
+    a.scripts,
+    a.binaries,
+    a.datas,
+    [],
+    name='t',
+    debug=False,
+    bootloader_ignore_signals=False,
+    strip=False,
+    upx=True,
+    upx_exclude=[],
+    runtime_tmpdir=None,
+    console=True,
+    disable_windowed_traceback=False,
+    argv_emulation=False,
+    target_arch=None,
+    codesign_identity=None,
+    entitlements_file=None,
+)

package/types.ts

@@ -1,4 +1,4 @@
-import { Embedding, StreamTextResult } from "ai";
+import { Embedding, EmbeddingModel, StreamTextResult } from "ai";
 import { z } from "zod";
 
 export interface BaseLLM {
@@ -146,22 +146,44 @@ export interface SummarizerAgent {
 }
 
 export interface CacheMemoryOptions {
+  embeddingModel: EmbeddingModel<string>;
   cacheTTL?: number;
   redisUrl?: string;
   cachePrefix?: string;
 }
 
+export type GenerateObjectResponse = {
+  shouldContinue: boolean;
+  actions: Array<{
+    name: string;
+    parameters: Array<{
+      name: string;
+      value: any;
+    }>;
+    scheduler?: {
+      isScheduled: boolean;
+      cronExpression: string;
+      reason?: string;
+    };
+  }>;
+  socialResponse?: {
+    shouldRespond: boolean;
+    response?: string;
+    isPartialResponse?: boolean;
+  };
+  interpreter?: string;
+};
+
 export interface CreateMemoryInput {
-  content: any;
-  type: MemoryType;
-  data: string[];
+  query: string;
+  data: any;
   userId?: string;
   scope?: MemoryScope;
+  ttl?: number;
 }
 
 export interface CacheMemoryType {
   id: string;
-  type: MemoryType;
   data: any;
   query: string;
   embedding: Embedding;
@@ -183,15 +205,15 @@ export interface MemoryChunk {
 
 export type MemoryScopeType = (typeof MemoryScope)[keyof typeof MemoryScope];
 
-export interface Memory {
+export interface LongTermMemory {
   id: string;
   query: string;
-  purpose: string;
+  category: string;
   data: any;
-  scope: MemoryScopeType;
-  userId?: string;
+  roomId: string;
   createdAt: Date;
   chunks?: MemoryChunk[];
+  tags: string[];
 }
 
 export const ActionSchema = z.array(
@@ -231,3 +253,36 @@ 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;
+}
+
+export interface WorkflowPattern {
+  query: string;
+  actions: Array<{
+    done: boolean;
+    name: string;
+    result: string;
+  }>;
+  success: boolean;
+}