@ai.ntellect/core 0.5.0 → 0.6.0

package/services/cache.ts

@@ -1,298 +0,0 @@
-import { type CoreMessage } from "ai";
-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.cleanupEverything();
-
-    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;
-  }
-
-  async storeMessage(
-    role: "user" | "assistant" | "system",
-    message: string
-  ): Promise<void> {
-    const id = crypto.randomUUID();
-    const key = `recent_messages:${id}`;
-    const coreMessage: CoreMessage = {
-      role,
-      content: message,
-    };
-    await this.redis.setex(
-      key,
-      this.defaultTTL,
-      JSON.stringify({ ...coreMessage, timestamp: new Date().toISOString() })
-    );
-    console.log("🔍 Message stored successfully", { key, message });
-  }
-
-  /**
-   * Store a recent message following CoreMessage structure
-   */
-  async storeRecentMessage(
-    message: string,
-    metadata?: {
-      socialResponse?: string;
-      agentName?: string;
-      agentResponse?: string;
-      actions?: any[];
-    }
-  ): Promise<void> {
-    console.log("🔍 Storing recent message:", message);
-    const id = crypto.randomUUID();
-    const key = `recent_messages:${id}`;
-
-    // Create CoreMessage structure
-    const coreMessage: CoreMessage[] = [
-      {
-        role: "user",
-        content: message,
-      },
-    ];
-
-    // Add assistant response if available
-    if (metadata?.socialResponse || metadata?.agentResponse) {
-      coreMessage.push({
-        role: "assistant",
-        content:
-          metadata.socialResponse || metadata.agentResponse
-            ? `Agent ${metadata.agentName ? metadata.agentName : "Main"}: ${
-                metadata.socialResponse || metadata.agentResponse
-              }`
-            : "",
-      });
-    }
-
-    await this.redis.setex(
-      key,
-      this.defaultTTL,
-      JSON.stringify({
-        timestamp: new Date().toISOString(),
-        messages: coreMessage,
-        actions: metadata?.actions || [],
-      })
-    );
-    console.log("🔍 Recent message stored successfully", {
-      key,
-      message,
-    });
-  }
-
-  /**
-   * Get previous actions
-   */
-  async getRecentPreviousActions(limit: number = 10): Promise<any[]> {
-    const keys = await this.redis.keys("previous_actions:*");
-    if (!keys.length) return [];
-
-    const actions = await Promise.all(
-      keys.map(async (key) => {
-        const data = await this.redis.get(key);
-        return data ? JSON.parse(data) : null;
-      })
-    );
-    return actions.slice(0, limit);
-  }
-
-  /**
-   * Get recent messages in CoreMessage format
-   */
-  async getRecentMessages(limit: number = 10): Promise<CoreMessage[]> {
-    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;
-      })
-    );
-
-    const formattedMessages = messages
-      .sort(
-        (a, b) =>
-          new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
-      ) // Tri par timestamp
-      .map((message) => {
-        return {
-          role: message.role,
-          content: message.content,
-        };
-      }) // Extraire les messages de chaque entrée
-      .slice(0, limit); // Limiter le nombre de messages
-    return formattedMessages;
-  }
-  /**
-   * 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);
-    }
-  }
-  async cleanupEverything(): Promise<void> {
-    const keys = await this.redis.keys("*");
-    console.log("🔍 Cleaning up messages with TTL:", keys);
-
-    for (const key of keys) {
-      console.log(`🧹 Suppression de la clé expirée ou invalide: ${key}`);
-      await this.redis.del(key);
-    }
-  }
-
-  /**
-   * Stop the cleanup job and close Redis connection
-   */
-  async close(): Promise<void> {
-    this.cleanupJob.stop();
-    await this.redis.quit();
-  }
-
-  /**
-   * Store a memory with tags and categories
-   */
-  async storeMemory(
-    data: string,
-    category: string,
-    tags: string[],
-    ttl?: number
-  ): Promise<void> {
-    const id = crypto.randomUUID();
-    const key = `memory:${id}`;
-    const memoryData = {
-      data,
-      category,
-      tags,
-      timestamp: new Date().toISOString(),
-    };
-
-    // Enregistrer la mémoire avec TTL
-    await this.redis.setex(
-      key,
-      ttl || this.defaultTTL,
-      JSON.stringify(memoryData)
-    );
-
-    // Indexer les tags
-    for (const tag of tags) {
-      const tagKey = `tag:${tag}`;
-      await this.redis.sadd(tagKey, key);
-    }
-
-    // Indexer les catégories
-    const categoryKey = `category:${category}`;
-    await this.redis.sadd(categoryKey, key);
-    console.log("🔍 Memory stored successfully", { key, memoryData });
-  }
-
-  /**
-   * Get memories by a specific tag
-   */
-  async getMemoriesByTag(tag: string): Promise<any[]> {
-    const tagKey = `tag:${tag}`;
-    const keys = await this.redis.smembers(tagKey);
-
-    const memories = await Promise.all(
-      keys.map(async (key) => {
-        const data = await this.redis.get(key);
-        return data ? JSON.parse(data) : null;
-      })
-    );
-
-    return memories.filter(Boolean); // Filtrer les valeurs nulles
-  }
-
-  /**
-   * Get memories by a specific category
-   */
-  async getMemoriesByCategory(category: string): Promise<any[]> {
-    const categoryKey = `category:${category}`;
-    const keys = await this.redis.smembers(categoryKey);
-
-    const memories = await Promise.all(
-      keys.map(async (key) => {
-        const data = await this.redis.get(key);
-        return data ? JSON.parse(data) : null;
-      })
-    );
-
-    return memories.filter(Boolean); // Filtrer les valeurs nulles
-  }
-
-  /**
-   * Get all available tags
-   */
-  async getAllTags(): Promise<string[]> {
-    const keys = await this.redis.keys("tag:*");
-    return keys.map((key) => key.replace("tag:", ""));
-  }
-
-  /**
-   * Get all available categories
-   */
-  async getAllCategories(): Promise<string[]> {
-    const keys = await this.redis.keys("category:*");
-    return keys.map((key) => key.replace("category:", ""));
-  }
-}

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);
-//   },
-// });

package/t.py

@@ -1,79 +0,0 @@
-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.ts

@@ -1,25 +0,0 @@
-import { deepseek } from "@ai-sdk/deepseek";
-import { streamObject } from "ai";
-import { configDotenv } from "dotenv";
-import { z } from "zod";
-
-configDotenv();
-const model = deepseek("deepseek-chat");
-
-const main = async () => {
-  try {
-    const result = await streamObject({
-      model,
-      schema: z.object({
-        text: z.string(),
-        reason: z.string(),
-      }),
-      prompt: "Tell me why you are so good",
-    });
-  } catch (error) {
-    console.error("🔄 Start handler error:", error);
-    throw error;
-  }
-};
-
-main();

package/test/llm/orchestrator.test.ts

@@ -1,47 +0,0 @@
-import { expect } from "chai";
-import { z } from "zod";
-import { Orchestrator } from "../../llm/orchestrator";
-import { ActionSchema } from "../../types";
-
-describe("Orchestrator", () => {
-  let orchestrator: Orchestrator;
-
-  const mockAction: ActionSchema = {
-    name: "prepare-transaction",
-    description: "Prepare a transfer transaction",
-    parameters: z.object({
-      walletAddress: z.string(),
-      amount: z.string(),
-      networkId: z.string(),
-    }),
-    execute: async ({ walletAddress, amount, networkId }) => {
-      return { walletAddress, amount, networkId };
-    },
-  };
-
-  beforeEach(() => {
-    orchestrator = new Orchestrator([mockAction]);
-  });
-
-  it("should process a prompt and return just the answer", async function () {
-    this.timeout(10000);
-
-    const prompt = "Hello how are you?";
-    const result = await orchestrator.process(prompt);
-
-    expect(result).to.have.property("answer").that.is.a("string");
-  });
-
-  it("should process a prompt and return valid actions", async function () {
-    this.timeout(10000);
-
-    const prompt = "Send 0.1 ETH to 0x123...456 on ethereum";
-    const result = await orchestrator.process(prompt);
-    console.dir(result, { depth: null });
-    expect(result).to.have.property("actions").that.is.an("array");
-    expect(result).to.have.property("answer").that.is.a("string");
-    expect(result.actions[0])
-      .to.have.property("parameters")
-      .that.is.an("object");
-  });
-});

package/test/llm/synthesizer.test.ts

@@ -1,31 +0,0 @@
-// import { expect } from "chai";
-// import { Summarizer } from "../../llm/synthesizer";
-
-// describe("Synthesizer", () => {
-//   let synthesizer: Summarizer;
-
-//   beforeEach(() => {
-//     synthesizer = new Summarizer();
-//   });
-
-//   it("should process results and return a summary", async function () {
-//     this.timeout(10000);
-
-//     const mockResults = JSON.stringify({
-//       result: [
-//         {
-//           name: "prepare-transaction",
-//           result: {
-//             to: "0x123...456",
-//             value: "0.1",
-//             chain: { id: 1, name: "ethereum" },
-//           },
-//         },
-//       ],
-//       initialPrompt: "Send 0.1 ETH to 0x123...456 on ethereum",
-//     });
-
-//     const result = await synthesizer.process(mockResults);
-//     expect(result).to.have.property("response").that.is.a("string");
-//   });
-// });