@ai.ntellect/core 0.8.3 → 1.1.0

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

@@ -1,165 +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(),
-      content: input.content,
-      metadata: input.metadata,
-      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/modules/memory/adapters/in-memory.test.ts

@@ -1,153 +0,0 @@
-import { expect } from "chai";
-import { InMemoryAdapter } from "../../../../modules/memory/adapters/in-memory";
-import { BaseMemoryType } from "../../../../types";
-
-describe("InMemoryAdapter", () => {
-  let inMemoryAdapter: InMemoryAdapter;
-  const fixedDate = new Date("2025-01-30T07:43:50.626Z");
-  const TEST_ROOM_ID = "test-room";
-
-  const testMemory: BaseMemoryType = {
-    id: "test-id",
-    data: "test data",
-    roomId: TEST_ROOM_ID,
-    createdAt: fixedDate,
-  };
-
-  beforeEach(async () => {
-    inMemoryAdapter = new InMemoryAdapter();
-    await inMemoryAdapter.init(TEST_ROOM_ID);
-  });
-
-  describe("Initialization", () => {
-    it("should initialize storage", async () => {
-      await expect(inMemoryAdapter.init("new-room")).to.not.throw;
-      const memories = await inMemoryAdapter.getAllMemories("new-room");
-      expect(memories).to.be.an("array").that.is.empty;
-    });
-  });
-
-  describe("Memory Operations", () => {
-    it("should create memory", async () => {
-      const memory = await inMemoryAdapter.createMemory({
-        data: "test data",
-        roomId: TEST_ROOM_ID,
-        id: "test-id",
-        embedding: [0.1, 0.2, 0.3],
-      });
-
-      expect(memory).to.have.property("id");
-      expect(memory?.data).to.equal("test data");
-      expect(memory?.roomId).to.equal(TEST_ROOM_ID);
-    });
-
-    it("should not create duplicate memory", async () => {
-      // Create first memory
-      const memory1 = await inMemoryAdapter.createMemory({
-        data: "test data",
-        roomId: TEST_ROOM_ID,
-        id: "test-id",
-      });
-
-      // Try to create duplicate
-      const memory2 = await inMemoryAdapter.createMemory({
-        data: "test data",
-        roomId: TEST_ROOM_ID,
-        id: "another-id",
-      });
-
-      expect(memory2?.id).to.equal(memory1?.id);
-    });
-
-    it("should get memory by ID", async () => {
-      await inMemoryAdapter.createMemory({
-        data: testMemory.data,
-        roomId: testMemory.roomId,
-        id: testMemory.id,
-        embedding: testMemory.embedding,
-      });
-
-      const result = await inMemoryAdapter.getMemoryById(
-        "test-id",
-        TEST_ROOM_ID
-      );
-      expect(result).to.have.property("id", "test-id");
-    });
-
-    it("should get memories by index", async () => {
-      // Create test memories
-      await inMemoryAdapter.createMemory({
-        data: "test data one",
-        roomId: TEST_ROOM_ID,
-        id: "test-id-1",
-      });
-      await inMemoryAdapter.createMemory({
-        data: "test data two",
-        roomId: TEST_ROOM_ID,
-        id: "test-id-2",
-      });
-
-      const results = await inMemoryAdapter.getMemoryByIndex("one", {
-        roomId: TEST_ROOM_ID,
-        limit: 10,
-      });
-
-      expect(results).to.be.an("array");
-      expect(results).to.have.lengthOf(1);
-      expect(results[0].data).to.include("one");
-    });
-
-    it("should get all memories", async () => {
-      // Create multiple memories
-      await inMemoryAdapter.createMemory({
-        data: "test data 1",
-        roomId: TEST_ROOM_ID,
-        id: "test-id-1",
-      });
-      await inMemoryAdapter.createMemory({
-        data: "test data 2",
-        roomId: TEST_ROOM_ID,
-        id: "test-id-2",
-      });
-
-      const results = await inMemoryAdapter.getAllMemories(TEST_ROOM_ID);
-      expect(results).to.be.an("array");
-      expect(results).to.have.lengthOf(2);
-    });
-
-    it("should clear memory by ID", async () => {
-      // Create a memory
-      await inMemoryAdapter.createMemory({
-        data: "test data",
-        roomId: TEST_ROOM_ID,
-        id: "test-id",
-      });
-
-      await inMemoryAdapter.clearMemoryById("test-id", TEST_ROOM_ID);
-      const result = await inMemoryAdapter.getMemoryById(
-        "test-id",
-        TEST_ROOM_ID
-      );
-      expect(result).to.be.null;
-    });
-
-    it("should clear all memories", async () => {
-      // Create multiple memories
-      await inMemoryAdapter.createMemory({
-        data: "test data 1",
-        roomId: TEST_ROOM_ID,
-        id: "test-id-1",
-      });
-      await inMemoryAdapter.createMemory({
-        data: "test data 2",
-        roomId: TEST_ROOM_ID,
-        id: "test-id-2",
-      });
-
-      await inMemoryAdapter.clearAllMemories();
-      const results = await inMemoryAdapter.getAllMemories(TEST_ROOM_ID);
-      expect(results).to.be.an("array");
-      expect(results).to.have.lengthOf(0);
-    });
-  });
-});

package/test/modules/memory/adapters/meilisearch.test.ts

@@ -1,287 +0,0 @@
-import { expect } from "chai";
-import dotenv from "dotenv";
-import { MeilisearchAdapter } from "../../../../modules/memory/adapters/meilisearch";
-import { BaseMemoryType } from "../../../../types";
-// Load environment variables
-dotenv.config();
-
-describe("MeilisearchAdapter", () => {
-  let meilisearchAdapter: MeilisearchAdapter;
-  const TEST_ROOM_ID = "test-room";
-
-  const testMemory: BaseMemoryType = {
-    id: "test-id",
-    data: "test data",
-    roomId: "test-room",
-    createdAt: new Date(),
-  };
-
-  beforeEach(async function () {
-    this.timeout(10000); // Augmenter le timeout
-
-    // Mock fetch pour simuler l'existence de l'index
-    global.fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
-      const url = input.toString();
-
-      // Mock pour index check/creation
-      if (url.includes("/indexes")) {
-        if (init?.method === "POST") {
-          return new Response(JSON.stringify({ taskUid: 1 }));
-        }
-        if (url.endsWith("/indexes")) {
-          return new Response(
-            JSON.stringify({
-              results: [{ uid: TEST_ROOM_ID }], // Simuler l'existence de l'index
-            })
-          );
-        }
-        if (url.includes(`/indexes/${TEST_ROOM_ID}`)) {
-          return new Response(
-            JSON.stringify({
-              uid: TEST_ROOM_ID,
-              primaryKey: "id",
-            })
-          );
-        }
-      }
-
-      // Mock pour settings et autres endpoints
-      if (url.includes("/settings")) {
-        return new Response(JSON.stringify({ acknowledged: true }));
-      }
-
-      return new Response(JSON.stringify({}));
-    };
-
-    meilisearchAdapter = new MeilisearchAdapter({
-      host: "http://localhost:7700",
-      apiKey: "test_key",
-      searchableAttributes: ["content"],
-      sortableAttributes: ["createdAt"],
-    });
-
-    await meilisearchAdapter.init(TEST_ROOM_ID);
-  });
-
-  describe("Initialization", () => {
-    it("should initialize storage", async () => {
-      await expect(meilisearchAdapter.init("test-room")).to.not.throw;
-    });
-  });
-
-  describe("Memory Operations", () => {
-    beforeEach(async () => {
-      // Reset fetch mock for each test
-      if (!process.env.MEILISEARCH_HOST) {
-        global.fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
-          const url = input.toString();
-
-          // Mock for index check/creation
-          if (url.includes("/indexes")) {
-            if (init?.method === "POST") {
-              return new Response(JSON.stringify({ taskUid: 1 }));
-            }
-            if (url.endsWith("/indexes")) {
-              return new Response(JSON.stringify({ results: [] }));
-            }
-            // Mock for specific index check
-            if (url.includes(`/indexes/${TEST_ROOM_ID}`)) {
-              return new Response(
-                JSON.stringify({
-                  uid: TEST_ROOM_ID,
-                  primaryKey: "id",
-                })
-              );
-            }
-            if (url.includes("/indexes/memories")) {
-              return new Response(
-                JSON.stringify({
-                  uid: "memories",
-                  primaryKey: "id",
-                })
-              );
-            }
-          }
-
-          // Mock for settings
-          if (url.includes("/settings")) {
-            return new Response(JSON.stringify({ acknowledged: true }));
-          }
-
-          // Mock for documents
-          if (url.includes("/documents")) {
-            if (init?.method === "POST") {
-              return new Response(JSON.stringify({ taskUid: 2 }));
-            }
-            if (init?.method === "DELETE") {
-              return new Response(JSON.stringify({ taskUid: 3 }));
-            }
-            return new Response(JSON.stringify([testMemory]));
-          }
-
-          return new Response(JSON.stringify({}));
-        };
-      }
-
-      try {
-        await meilisearchAdapter.init(TEST_ROOM_ID);
-      } catch (error) {
-        console.error("Failed to initialize:", error);
-        throw error;
-      }
-    });
-
-    it("should create memory", async () => {
-      const input = {
-        id: "test-id",
-        roomId: "test-room",
-        data: "test data",
-      };
-
-      const result = await meilisearchAdapter.createMemory(input);
-      expect(result?.embedding).to.be.undefined;
-    });
-
-    it("should search memories", async () => {
-      const results = await meilisearchAdapter.getMemoryByIndex("test", {
-        roomId: TEST_ROOM_ID,
-        limit: 10,
-      });
-
-      expect(results).to.be.an("array");
-      if (results.length > 0) {
-        const result = results[0];
-        if (result) {
-          result.createdAt = new Date(result.createdAt);
-        }
-        expect(result).to.deep.equal(testMemory);
-      }
-    });
-
-    it("should handle memory retrieval by ID", async () => {
-      const testDate = new Date("2025-02-11T08:24:38.251Z");
-
-      const mockData = {
-        id: "test-id",
-        roomId: "test-room",
-        data: "test data",
-        createdAt: testDate.toISOString(),
-        embedding: undefined,
-      };
-
-      global.fetch = async (input: RequestInfo | URL) => {
-        const url = input.toString();
-        if (url.includes(`/indexes/test-room/documents/test-id`)) {
-          return new Response(JSON.stringify(mockData));
-        }
-        return new Response(JSON.stringify({}));
-      };
-
-      const result = await meilisearchAdapter.getMemoryById(
-        "test-id",
-        "test-room"
-      );
-
-      expect(result?.id).to.equal(mockData.id);
-      expect(result?.roomId).to.equal(mockData.roomId);
-      expect(result?.data).to.equal(mockData.data);
-      expect(result?.createdAt).to.equal(mockData.createdAt); // Compare directement les strings
-      expect(result?.embedding).to.be.undefined;
-    });
-
-    it("should handle non-existent memory", async () => {
-      global.fetch = async (): Promise<Response> => {
-        throw new Error("Not found");
-      };
-
-      const result = await meilisearchAdapter.getMemoryById(
-        "non-existent",
-        TEST_ROOM_ID
-      );
-      expect(result).to.be.null;
-    });
-
-    it("should clear all memories", async () => {
-      // S'assurer que l'index existe avant de le supprimer
-      await meilisearchAdapter.init(TEST_ROOM_ID);
-      await expect(meilisearchAdapter.clearAllMemories()).to.not.throw;
-    });
-
-    it("should not create duplicate memory with same data", async () => {
-      // Override fetch mock for this test
-      const firstMemoryId = "test-memory-id";
-      const mockMemory = {
-        id: firstMemoryId,
-        data: "test data",
-        roomId: TEST_ROOM_ID,
-        embedding: null,
-        createdAt: new Date().toISOString(),
-      };
-
-      global.fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
-        const url = input.toString();
-
-        if (url.includes("/search")) {
-          return new Response(
-            JSON.stringify({
-              hits: [{ ...mockMemory }],
-            })
-          );
-        }
-
-        if (url.includes("/indexes")) {
-          if (init?.method === "POST") {
-            return new Response(JSON.stringify({ taskUid: 1 }));
-          }
-          return new Response(
-            JSON.stringify({
-              uid: TEST_ROOM_ID,
-              primaryKey: "id",
-            })
-          );
-        }
-
-        return new Response(JSON.stringify({}));
-      };
-
-      const firstMemory = await meilisearchAdapter.createMemory({
-        data: "test data",
-        roomId: TEST_ROOM_ID,
-      });
-
-      const secondMemory = await meilisearchAdapter.createMemory({
-        data: "test data",
-        roomId: TEST_ROOM_ID,
-      });
-
-      expect(secondMemory?.id).to.equal(firstMemory?.id);
-      expect(secondMemory?.data).to.equal(firstMemory?.data);
-      expect(secondMemory?.roomId).to.equal(firstMemory?.roomId);
-    });
-
-    it("should initialize storage", async () => {
-      global.fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
-        const url = input.toString();
-
-        // Mock pour la vérification de l'existence de l'index
-        if (url.includes(`/indexes/${TEST_ROOM_ID}`)) {
-          return new Response(
-            JSON.stringify({
-              uid: TEST_ROOM_ID,
-              primaryKey: "id",
-            })
-          );
-        }
-
-        // Mock pour les settings
-        if (url.includes("/settings")) {
-          return new Response(JSON.stringify({ acknowledged: true }));
-        }
-
-        return new Response(JSON.stringify({}));
-      };
-
-      await expect(meilisearchAdapter.init(TEST_ROOM_ID)).to.not.throw;
-    });
-  });
-});