@ai.ntellect/core 0.7.8 → 1.0.0

package/modules/memory/adapters/redis/index.ts

@@ -1,164 +0,0 @@
-import { createClient } from "redis";
-import { IMemoryAdapter } from "../../../../interfaces";
-import { BaseMemoryType, CreateMemoryInput } from "../../../../types";
-
-/**
- * @module RedisAdapter
- * @description Adapter implementation for Redis as a memory storage solution.
- * Provides integration with Redis for storing and retrieving memory entries with TTL support.
- * @implements {IMemoryAdapter}
- */
-export class RedisAdapter implements IMemoryAdapter {
-  private redis;
-  private readonly cachePrefix: string;
-  private readonly cacheTTL: number;
-
-  /**
-   * Creates an instance of RedisAdapter
-   * @param {string} redisUrl - Redis connection URL
-   * @param {Object} options - Configuration options
-   * @param {string} [options.cachePrefix="memory:"] - Prefix for Redis keys
-   * @param {number} [options.cacheTTL=3600] - Default TTL in seconds
-   */
-  constructor(
-    private readonly redisUrl: string,
-    options: {
-      cachePrefix?: string;
-      cacheTTL?: number;
-    }
-  ) {
-    this.cachePrefix = options.cachePrefix || "memory:";
-    this.cacheTTL = options.cacheTTL || 3600;
-    this.redis = createClient({
-      url: redisUrl,
-      socket: {
-        tls: true,
-        rejectUnauthorized: true,
-      },
-    });
-  }
-
-  /**
-   * Initializes the Redis connection
-   * @param {string} roomId - Room identifier
-   * @returns {Promise<void>}
-   */
-  async init(roomId: string): Promise<void> {
-    this.redis.on("error", (err) => console.error("Redis Client Error:", err));
-    await this.redis.connect();
-  }
-
-  /**
-   * Creates a new memory entry in Redis
-   * @param {CreateMemoryInput & { embedding?: number[] }} input - Memory data with optional embedding
-   * @returns {Promise<BaseMemoryType | undefined>} Created memory or undefined
-   */
-  async createMemory(
-    input: CreateMemoryInput & { embedding?: number[] }
-  ): Promise<BaseMemoryType | undefined> {
-    const memory: BaseMemoryType = {
-      id: input.id || crypto.randomUUID(),
-      data: input.data,
-      embedding: input.embedding,
-      roomId: input.roomId,
-      createdAt: new Date(),
-    };
-
-    const key = memory.roomId
-      ? `${this.cachePrefix}${memory.roomId}:${memory.id}`
-      : `${this.cachePrefix}${memory.id}`;
-
-    await this.redis.set(key, JSON.stringify(memory), {
-      EX: this.cacheTTL,
-    });
-
-    return memory;
-  }
-
-  /**
-   * Retrieves a memory by ID and room ID from Redis
-   * @param {string} id - Memory identifier
-   * @param {string} roomId - Room identifier
-   * @returns {Promise<BaseMemoryType | null>} Memory entry or null if not found
-   */
-  async getMemoryById(
-    id: string,
-    roomId: string
-  ): Promise<BaseMemoryType | null> {
-    const key = `${this.cachePrefix}${roomId}:${id}`;
-    const data = await this.redis.get(key);
-    return data ? JSON.parse(data) : null;
-  }
-
-  /**
-   * Searches for memories in Redis based on pattern matching
-   * @param {string} query - Search query
-   * @param {Object} options - Search options
-   * @param {string} options.roomId - Room identifier
-   * @param {number} [options.limit] - Maximum number of results
-   * @returns {Promise<BaseMemoryType[]>} Array of matching memories
-   */
-  async getMemoryByIndex(
-    query: string,
-    options: { roomId: string; limit?: number }
-  ): Promise<BaseMemoryType[]> {
-    const pattern = `${this.cachePrefix}${options.roomId}:*`;
-    const keys = await this.redis.keys(pattern);
-    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).slice(0, options.limit || 10);
-  }
-
-  /**
-   * Retrieves all memories for a room from Redis
-   * @param {string} roomId - Room identifier
-   * @returns {Promise<BaseMemoryType[]>} Array of all memories
-   */
-  async getAllMemories(roomId: string): Promise<BaseMemoryType[]> {
-    const pattern = `${this.cachePrefix}${roomId}:*`;
-    const keys = await this.redis.keys(pattern);
-    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);
-  }
-
-  /**
-   * Deletes a specific memory from Redis
-   * @param {string} id - Memory identifier
-   * @param {string} roomId - Room identifier
-   * @returns {Promise<void>}
-   */
-  async clearMemoryById(id: string, roomId: string): Promise<void> {
-    const key = `${this.cachePrefix}${roomId}:${id}`;
-    await this.redis.del(key);
-  }
-
-  /**
-   * Clears all memories across all rooms from Redis
-   * @returns {Promise<void>}
-   */
-  async clearAllMemories(): Promise<void> {
-    const keys = await this.redis.keys(`${this.cachePrefix}*`);
-    if (keys.length > 0) {
-      await this.redis.del(keys);
-    }
-  }
-
-  /**
-   * Closes the Redis connection
-   * @returns {Promise<void>}
-   */
-  async quit(): Promise<void> {
-    if (this.redis) {
-      await this.redis.quit();
-    }
-  }
-}

package/modules/memory/index.ts

@@ -1,93 +0,0 @@
-import { BaseMemory, IMemoryAdapter } from "../../interfaces";
-import { BaseMemoryType, CreateMemoryInput } from "../../types";
-
-/**
- * @module Memory
- * @description A module for managing memory storage and retrieval operations.
- * Implements the BaseMemory abstract class and provides concrete implementations
- * for memory-related operations using the provided adapter.
- * @extends {BaseMemory}
- */
-export class Memory extends BaseMemory {
-  /**
-   * Creates an instance of Memory
-   * @param {IMemoryAdapter} adapter - The memory adapter implementation to use
-   */
-  constructor(adapter: IMemoryAdapter) {
-    super(adapter);
-  }
-
-  /**
-   * Initializes the memory module with default room
-   * @returns {Promise<void>}
-   */
-  async init(): Promise<void> {
-    await this.adapter.init("default");
-  }
-
-  /**
-   * Creates a new memory entry
-   * @param {CreateMemoryInput & { embedding?: number[] }} input - Memory data with optional embedding
-   * @returns {Promise<BaseMemoryType | undefined>} Created memory or undefined
-   */
-  async createMemory(
-    input: CreateMemoryInput & { embedding?: number[] }
-  ): Promise<BaseMemoryType | undefined> {
-    return this.adapter.createMemory(input);
-  }
-
-  /**
-   * Retrieves a memory by ID and room ID
-   * @param {string} id - Memory identifier
-   * @param {string} roomId - Room identifier
-   * @returns {Promise<BaseMemoryType | null>} Memory entry or null if not found
-   */
-  async getMemoryById(
-    id: string,
-    roomId: string
-  ): Promise<BaseMemoryType | null> {
-    return this.adapter.getMemoryById(id, roomId);
-  }
-
-  /**
-   * Searches for memories based on query and options
-   * @param {string} query - Search query
-   * @param {Object} options - Search options
-   * @param {string} options.roomId - Room identifier
-   * @param {number} [options.limit] - Maximum number of results to return
-   * @returns {Promise<BaseMemoryType[]>} Array of matching memories
-   */
-  async getMemoryByIndex(
-    query: string,
-    options: { roomId: string; limit?: number }
-  ): Promise<BaseMemoryType[]> {
-    return this.adapter.getMemoryByIndex(query, options);
-  }
-
-  /**
-   * Retrieves all memories for a specific room
-   * @param {string} roomId - Room identifier
-   * @returns {Promise<BaseMemoryType[]>} Array of all memories in the room
-   */
-  async getAllMemories(roomId: string): Promise<BaseMemoryType[]> {
-    return this.adapter.getAllMemories(roomId);
-  }
-
-  /**
-   * Deletes a specific memory
-   * @param {string} id - Memory identifier
-   * @param {string} roomId - Room identifier
-   * @returns {Promise<void>}
-   */
-  async clearMemoryById(id: string, roomId: string): Promise<void> {
-    await this.adapter.clearMemoryById(id, roomId);
-  }
-
-  /**
-   * Clears all memories across all rooms
-   * @returns {Promise<void>}
-   */
-  async clearAllMemories(): Promise<void> {
-    await this.adapter.clearAllMemories();
-  }
-}

package/test/graph/controller.test.ts

@@ -1,187 +0,0 @@
-import { expect } from "chai";
-import { z } from "zod";
-import { GraphController } from "../../graph/controller";
-import { GraphFlow } from "../../graph/index";
-import { Node } from "../../types";
-
-describe("GraphController", () => {
-  const TestSchema = z.object({
-    counter: z.number(),
-    message: z.string(),
-  });
-
-  const createTestGraph = (name: string): GraphFlow<typeof TestSchema> => {
-    const nodes: Node<typeof TestSchema>[] = [
-      {
-        name: "start",
-        execute: async (context, params) => {
-          context.counter = params?.value ?? 0;
-          context.message = params?.prefix ? `${params.prefix}-${name}` : name;
-        },
-      },
-      {
-        name: "increment",
-        execute: async (context) => {
-          context.counter += 1;
-        },
-      },
-    ];
-
-    return new GraphFlow(name, {
-      name,
-      nodes,
-      schema: TestSchema,
-      context: { counter: 0, message: "" },
-    });
-  };
-
-  describe("Sequential Execution", () => {
-    it("should execute graphs sequentially with different params and params", async () => {
-      const graph1 = createTestGraph("graph1");
-      const graph2 = createTestGraph("graph2");
-      const graph3 = createTestGraph("graph3");
-
-      const params = [{ value: 10 }, { value: 20 }, { value: 30 }];
-
-      const params2 = [
-        { prefix: "test1" },
-        { prefix: "test2" },
-        { prefix: "test3" },
-      ];
-
-      const results = await GraphController.executeSequential(
-        [graph1, graph2, graph3],
-        ["start", "start", "start"],
-        params.map((value, i) => ({ ...value, prefix: params2[i].prefix }))
-      );
-
-      expect(results).to.have.length(3);
-      expect(results[0].counter).to.equal(10);
-      expect(results[1].counter).to.equal(20);
-      expect(results[2].counter).to.equal(30);
-      expect(results[0].message).to.equal("test1-graph1");
-      expect(results[1].message).to.equal("test2-graph2");
-      expect(results[2].message).to.equal("test3-graph3");
-    });
-
-    it("should handle missing params and params gracefully", async () => {
-      const graph1 = createTestGraph("graph1");
-      const graph2 = createTestGraph("graph2");
-
-      const results = await GraphController.executeSequential(
-        [graph1, graph2],
-        ["start", "start"]
-      );
-
-      expect(results).to.have.length(2);
-      expect(results[0].counter).to.equal(0);
-      expect(results[1].counter).to.equal(0);
-      expect(results[0].message).to.equal("graph1");
-      expect(results[1].message).to.equal("graph2");
-    });
-  });
-
-  describe("Parallel Execution", () => {
-    it("should execute graphs in parallel with concurrency limit", async () => {
-      const graphs = Array.from({ length: 5 }, (_, i) =>
-        createTestGraph(`graph${i + 1}`)
-      );
-
-      const params = Array.from({ length: 5 }, (_, i) => ({
-        value: (i + 1) * 10,
-        prefix: `test${i + 1}`,
-      }));
-
-      // Ajouter un délai dans l'exécution
-      const originalExecute = graphs[0].execute;
-      graphs[0].execute = async (...args) => {
-        await new Promise((resolve) => setTimeout(resolve, 100));
-        return originalExecute.apply(graphs[0], args);
-      };
-
-      const startTime = Date.now();
-      const results = await GraphController.executeParallel(
-        graphs,
-        Array(5).fill("start"),
-        2,
-        params
-      );
-      const executionTime = Date.now() - startTime;
-
-      expect(executionTime).to.be.greaterThan(0);
-      expect(results).to.have.length(5);
-      results.forEach((result, i) => {
-        expect(result.counter).to.equal((i + 1) * 10);
-        expect(result.message).to.equal(`test${i + 1}-graph${i + 1}`);
-      });
-    });
-
-    it("should handle errors in parallel execution", async () => {
-      const errorGraph = new GraphFlow("errorGraph", {
-        name: "errorGraph",
-        nodes: [
-          {
-            name: "start",
-            execute: async () => {
-              throw new Error("Test error");
-            },
-          },
-        ],
-        schema: TestSchema,
-        context: { counter: 0, message: "" },
-      });
-
-      const successGraph = createTestGraph("successGraph");
-
-      try {
-        await GraphController.executeParallel(
-          [errorGraph, successGraph],
-          ["start", "start"],
-          2
-        );
-        expect.fail("Should have thrown an error");
-      } catch (error: any) {
-        expect(error.message).to.equal("Test error");
-      }
-    });
-  });
-
-  describe("Complex Workflows", () => {
-    it("should handle mixed sequential and parallel execution", async () => {
-      const graphs = Array.from({ length: 4 }, (_, i) =>
-        createTestGraph(`graph${i + 1}`)
-      );
-
-      // Exécuter les deux premiers graphes en parallèle
-      const parallelResults = await GraphController.executeParallel(
-        graphs.slice(0, 2),
-        ["start", "start"],
-        2,
-        [
-          { value: 10, prefix: "parallel1" },
-          { value: 20, prefix: "parallel2" },
-        ]
-      );
-
-      // Puis exécuter les deux suivants séquentiellement
-      const sequentialResults = await GraphController.executeSequential(
-        graphs.slice(2),
-        ["start", "start"],
-        [
-          { value: 30, prefix: "seq1" },
-          { value: 40, prefix: "seq2" },
-        ]
-      );
-
-      const allResults = [...parallelResults, ...sequentialResults];
-      expect(allResults).to.have.length(4);
-      expect(allResults.map((r) => r.counter)).to.deep.equal([10, 20, 30, 40]);
-      expect(allResults.map((r) => r.message)).to.deep.equal([
-        "parallel1-graph1",
-        "parallel2-graph2",
-        "seq1-graph3",
-        "seq2-graph4",
-      ]);
-    });
-  });
-});

package/test/graph/event-manager.test.ts

@@ -1,118 +0,0 @@
-import { expect } from "chai";
-import { EventEmitter } from "events";
-import { z } from "zod";
-import { GraphEventManager } from "../../graph/event-manager";
-
-describe("GraphEventManager", () => {
-  const TestSchema = z.object({
-    counter: z.number(),
-    message: z.string(),
-  });
-
-  let eventManager: GraphEventManager<typeof TestSchema>;
-  let eventEmitter: EventEmitter;
-  let events: any[] = [];
-
-  beforeEach(() => {
-    events = [];
-    eventEmitter = new EventEmitter();
-    eventManager = new GraphEventManager(eventEmitter, new Map(), "test", {
-      counter: 0,
-      message: "Hello",
-    });
-  });
-
-  it("should emit events without duplication", () => {
-    const emittedEvents: any[] = [];
-    eventEmitter.on("test", (event) => emittedEvents.push(event));
-
-    eventManager.emitEvent("test", { data: "test" });
-
-    expect(emittedEvents).to.have.lengthOf(1);
-    expect(emittedEvents[0]).to.deep.equal({ data: "test" });
-  });
-
-  it("should handle nodeStateChanged events correctly", () => {
-    const stateChanges: any[] = [];
-    eventEmitter.on("nodeStateChanged", (event) => stateChanges.push(event));
-
-    eventManager.emitEvent("nodeStateChanged", {
-      nodeName: "test",
-      property: "counter",
-      oldValue: 0,
-      newValue: 1,
-      context: { counter: 1, message: "Hello" },
-    });
-
-    expect(stateChanges).to.have.lengthOf(1);
-    expect(stateChanges[0].nodeName).to.equal("test");
-    expect(stateChanges[0].context.counter).to.equal(1);
-  });
-
-  it("should setup and cleanup event listeners", () => {
-    const nodes = new Map();
-    nodes.set("test", {
-      name: "test",
-      events: ["customEvent"],
-      execute: async () => {},
-    });
-
-    eventManager = new GraphEventManager(eventEmitter, nodes, "test", {
-      counter: 0,
-      message: "Hello",
-    });
-
-    eventManager.setupEventListeners();
-    expect(eventEmitter.listenerCount("customEvent")).to.equal(1);
-
-    // Réinitialiser les listeners
-    eventManager.setupEventListeners();
-    expect(eventEmitter.listenerCount("customEvent")).to.equal(1);
-  });
-
-  it("should handle timeout for correlated events", async () => {
-    const timeout = 100;
-
-    try {
-      // N'émettre qu'un seul événement pour provoquer le timeout
-      eventManager.emitEvent("event1", { data: "test1" });
-
-      await eventManager.waitForCorrelatedEvents(
-        ["event1", "event2"],
-        timeout,
-        () => false // La fonction de corrélation retourne toujours false pour forcer le timeout
-      );
-      throw new Error("Should have timed out");
-    } catch (error: any) {
-      expect(error.message).to.include("Timeout waiting for correlated events");
-    }
-  });
-
-  it("should wait for multiple events before continuing", async () => {
-    let receivedEvents = 0;
-    let resolvePromise: (value: unknown) => void;
-    const eventPromise = new Promise((resolve) => {
-      resolvePromise = resolve;
-    });
-
-    // Configurer les écouteurs d'événements AVANT d'émettre
-    eventEmitter.on("event1", () => {
-      receivedEvents++;
-      if (receivedEvents === 2) resolvePromise(true);
-    });
-    eventEmitter.on("event2", () => {
-      receivedEvents++;
-      if (receivedEvents === 2) resolvePromise(true);
-    });
-
-    // Émettre les événements AVANT de démarrer l'attente
-    eventManager.emitEvent("event1", { data: "test1" });
-    eventManager.emitEvent("event2", { data: "test2" });
-
-    // Démarrer l'attente
-    const waitPromise = eventManager.waitForEvents(["event1", "event2"], 1000);
-
-    await Promise.race([waitPromise, eventPromise]);
-    expect(receivedEvents).to.equal(2);
-  });
-});