@ai.ntellect/core 0.4.0 → 0.5.0

package/script.js

@@ -0,0 +1,167 @@
+// Dimensions de l'espace SVG
+const width = 800;
+const height = 600;
+
+// Exemple de données pour les nœuds et les arêtes
+const nodes = [
+  { id: "fetchData", name: "Fetch Data", group: 1, selected: false },
+  { id: "analyzeData", name: "Analyze Data", group: 1, selected: false },
+  { id: "sendAlert", name: "Send Alert", group: 1, selected: false },
+];
+
+const links = [
+  { source: "fetchData", target: "analyzeData" },
+  { source: "analyzeData", target: "sendAlert" },
+];
+
+// Simulation de force
+const simulation = d3
+  .forceSimulation(nodes)
+  .force(
+    "link",
+    d3.forceLink(links).id((d) => d.id)
+  )
+  .force("charge", d3.forceManyBody().strength(-300))
+  .force("center", d3.forceCenter(width / 2, height / 2));
+
+// Créer le conteneur SVG
+const svg = d3.select("#graph").attr("width", width).attr("height", height);
+
+// Groupes pour liens et nœuds
+const linkGroup = svg
+  .append("g")
+  .attr("class", "links")
+  .attr("stroke", "#999")
+  .attr("stroke-opacity", 0.6);
+
+const nodeGroup = svg.append("g").attr("class", "nodes");
+
+// Fonction pour mettre à jour le graphe
+function updateGraph() {
+  // Mettre à jour les liens
+  const link = linkGroup.selectAll("line").data(links);
+
+  link
+    .enter()
+    .append("line")
+    .attr("stroke-width", 2)
+    .merge(link)
+    .attr("x1", (d) => d.source.x)
+    .attr("y1", (d) => d.source.y)
+    .attr("x2", (d) => d.target.x)
+    .attr("y2", (d) => d.target.y);
+
+  link.exit().remove();
+
+  // Mettre à jour les nœuds
+  const node = nodeGroup.selectAll("circle").data(nodes, (d) => d.id);
+
+  node.exit().remove();
+
+  const nodeEnter = node
+    .enter()
+    .append("circle")
+    .attr("r", 20)
+    .attr("fill", (d) => (d.selected ? "orange" : "#69b3a2"))
+    .attr("stroke", "#fff")
+    .attr("stroke-width", 1.5)
+    .call(
+      d3
+        .drag()
+        .on("start", dragstarted)
+        .on("drag", dragged)
+        .on("end", dragended)
+    )
+    .on("click", nodeClicked);
+
+  nodeEnter
+    .merge(node)
+    .attr("cx", (d) => d.x)
+    .attr("cy", (d) => d.y)
+    .attr("fill", (d) => (d.selected ? "orange" : "#69b3a2"));
+
+  // Ajouter des labels
+  const label = nodeGroup.selectAll("text").data(nodes);
+
+  label.exit().remove();
+
+  label
+    .enter()
+    .append("text")
+    .attr("dy", 4)
+    .attr("dx", 25)
+    .merge(label)
+    .attr("x", (d) => d.x)
+    .attr("y", (d) => d.y)
+    .text((d) => d.name);
+
+  simulation.on("tick", () => {
+    link
+      .attr("x1", (d) => d.source.x)
+      .attr("y1", (d) => d.source.y)
+      .attr("x2", (d) => d.target.x)
+      .attr("y2", (d) => d.target.y);
+
+    node.attr("cx", (d) => d.x).attr("cy", (d) => d.y);
+
+    label.attr("x", (d) => d.x + 25).attr("y", (d) => d.y);
+  });
+
+  updateWorkflowOrder();
+}
+
+// Fonction pour mettre à jour l'ordre du workflow
+function updateWorkflowOrder() {
+  const selectedNodes = nodes.filter((node) => node.selected);
+  if (selectedNodes.length > 0) {
+    workflowOrder = selectedNodes.map((node) => node.name);
+  } else {
+    const startNode = nodes.find(
+      (node) => !links.some((link) => link.target === node.id)
+    );
+
+    if (!startNode) {
+      workflowOrder = [];
+      console.log("Workflow Order: []");
+      return;
+    }
+
+    workflowOrder = [];
+    let currentNode = startNode;
+    while (currentNode) {
+      workflowOrder.push(currentNode.name);
+      const nextLink = links.find((link) => link.source === currentNode.id);
+      currentNode = nextLink
+        ? nodes.find((node) => node.id === nextLink.target)
+        : null;
+    }
+  }
+  console.log("Workflow Order:", workflowOrder);
+}
+
+// Gestion de la sélection multiple
+function nodeClicked(event, node) {
+  node.selected = !node.selected;
+  updateGraph();
+}
+
+// Gestion du drag & drop
+function dragstarted(event, d) {
+  if (!event.active) simulation.alphaTarget(0.3).restart();
+  d.fx = d.x;
+  d.fy = d.y;
+}
+
+function dragged(event, d) {
+  d.fx = event.x;
+  d.fy = event.y;
+}
+
+function dragended(event, d) {
+  if (!event.active) simulation.alphaTarget(0);
+  d.fx = null;
+  d.fy = null;
+}
+
+// Initialisation
+updateGraph();

package/services/{scheduler.ts → agenda.ts}

@@ -1,6 +1,6 @@
 import cron from "node-cron";
-import { AgentRuntime } from "../llm/orchestrator";
-import { RedisCache } from "./redis-cache";
+import { Orchestrator } from "../llm/orchestrator";
+import { RedisCache } from "./cache";
 
 interface ScheduledRequest {
   id: string;
@@ -10,24 +10,30 @@ interface ScheduledRequest {
   createdAt: Date;
 }
 
-export class TaskScheduler {
+export class Agenda {
   private scheduledRequests: Map<string, ScheduledRequest> = new Map();
   private cronJobs: Map<string, cron.ScheduledTask> = new Map();
-  private readonly agentRuntime: AgentRuntime;
+  private readonly orchestrator: Orchestrator;
   private readonly cache: RedisCache;
 
-  constructor(agentRuntime: AgentRuntime, cache: RedisCache) {
-    this.agentRuntime = agentRuntime;
+  constructor(orchestrator: Orchestrator, cache: RedisCache) {
+    this.orchestrator = orchestrator;
     this.cache = cache;
   }
 
   /**
    * Schedule a new request to be processed later
    */
-  async scheduleRequest(request: {
-    originalRequest: string;
-    cronExpression: string;
-  }): Promise<string> {
+  async scheduleRequest(
+    request: {
+      originalRequest: string;
+      cronExpression: string;
+    },
+    callbacks?: {
+      onScheduled?: (id: string) => void;
+      onExecuted?: (id: string, originalRequest: string) => void;
+    }
+  ): Promise<string> {
     const id = crypto.randomUUID();
 
     const scheduledRequest: ScheduledRequest = {
@@ -42,6 +48,9 @@ export class TaskScheduler {
     const cronJob = cron.schedule(request.cronExpression, async () => {
       await this.executeScheduledRequest(scheduledRequest);
 
+      if (callbacks?.onExecuted)
+        callbacks.onExecuted(id, scheduledRequest.originalRequest);
+
       if (!scheduledRequest.isRecurring) {
         this.cancelScheduledRequest(id);
       }
@@ -51,9 +60,7 @@ export class TaskScheduler {
     this.scheduledRequests.set(id, scheduledRequest);
     this.cronJobs.set(id, cronJob);
 
-    console.log(
-      `✅ Request scheduled with cron expression: ${request.cronExpression}`
-    );
+    if (callbacks?.onScheduled) callbacks.onScheduled(id);
 
     return id;
   }
@@ -67,28 +74,6 @@ export class TaskScheduler {
     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);

package/services/cache.ts

@@ -0,0 +1,298 @@
+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/queue.ts

@@ -6,7 +6,7 @@ import {
   QueueResult,
 } from "../types";
 
-export class ActionQueueManager {
+export class Queue {
   private queue: QueueItem[] = [];
   private results: QueueResult[] = [];
   private callbacks: QueueCallbacks;
@@ -18,7 +18,7 @@ export class ActionQueueManager {
     this.callbacks = callbacks;
   }
 
-  addToQueue(actions: QueueItem | QueueItem[]) {
+  add(actions: QueueItem | QueueItem[]) {
     if (Array.isArray(actions)) {
       console.log("\n📋 Adding actions to queue:");
       actions.forEach((action, index) => {
@@ -31,7 +31,7 @@ export class ActionQueueManager {
     }
   }
 
-  async processQueue() {
+  async execute() {
     if (this.isProcessing) {
       console.log("\n⚠️  Queue is already being processed");
       return;