@ai.ntellect/core 0.7.8 → 1.0.0

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

package/test/modules/memory/base.test.ts

@@ -1,230 +0,0 @@
-import { expect } from "chai";
-import { IMemoryAdapter } from "../../../interfaces";
-import { Memory } from "../../../modules/memory";
-import { BaseMemoryType, CreateMemoryInput } from "../../../types";
-
-/**
- * @module MemoryTests
- * @description Test suite for the Memory service implementation.
- * Tests the core functionality of memory management including:
- * - Initialization
- * - Memory creation
- * - Memory retrieval
- * - Memory deletion
- */
-
-describe("Memory", () => {
-  let memory: Memory;
-  let mockAdapter: IMemoryAdapter;
-  const TEST_ROOM_ID = "test-room";
-
-  /**
-   * Test data fixture
-   * @type {BaseMemoryType}
-   */
-  const testMemory: BaseMemoryType = {
-    id: "test-id",
-    data: "test data",
-    embedding: [0.1, 0.2, 0.3],
-    roomId: TEST_ROOM_ID,
-    createdAt: new Date(),
-  };
-
-  /**
-   * Set up test environment before each test
-   * Creates a mock adapter and initializes the memory service
-   */
-  beforeEach(() => {
-    // Create mock implementation of IMemoryAdapter
-    mockAdapter = {
-      init: async () => Promise.resolve(),
-      createMemory: async (input: CreateMemoryInput) => ({
-        ...testMemory,
-        data: input.data,
-        embedding: input.embedding,
-      }),
-      getMemoryById: async () => testMemory,
-      getMemoryByIndex: async () => [testMemory],
-      getAllMemories: async () => [testMemory],
-      clearMemoryById: async () => Promise.resolve(),
-      clearAllMemories: async () => Promise.resolve(),
-    };
-
-    memory = new Memory(mockAdapter);
-  });
-
-  /**
-   * Test suite for initialization functionality
-   */
-  describe("Initialization", () => {
-    /**
-     * Test case: Verify adapter initialization
-     */
-    it("should initialize the memory adapter", async () => {
-      let initCalled = false;
-      mockAdapter.init = async () => {
-        initCalled = true;
-      };
-
-      await memory.init();
-      expect(initCalled).to.be.true;
-    });
-  });
-
-  /**
-   * Test suite for memory creation functionality
-   */
-  describe("Memory Creation", () => {
-    /**
-     * Test case: Verify memory creation with valid input
-     */
-    it("should create a new memory entry", async () => {
-      const input = {
-        data: "test data",
-        roomId: TEST_ROOM_ID,
-      };
-
-      const result = await memory.createMemory(input);
-      expect(result).to.deep.include(input);
-    });
-
-    /**
-     * Test case: Verify memory creation with embedding
-     */
-    it("should create a memory entry with embedding", async () => {
-      const input = {
-        data: "test data",
-        roomId: TEST_ROOM_ID,
-        embedding: [0.1, 0.2, 0.3],
-      };
-
-      const result = await memory.createMemory(input);
-      expect(result).to.deep.include(input);
-    });
-  });
-
-  /**
-   * Test suite for memory retrieval functionality
-   */
-  describe("Memory Retrieval", () => {
-    /**
-     * Test case: Verify memory retrieval by ID
-     */
-    it("should retrieve a memory by ID", async () => {
-      const result = await memory.getMemoryById("test-id", TEST_ROOM_ID);
-      expect(result).to.deep.equal(testMemory);
-    });
-
-    /**
-     * Test case: Verify memory retrieval by index
-     */
-    it("should retrieve memories by index", async () => {
-      const result = await memory.getMemoryByIndex("test", {
-        roomId: TEST_ROOM_ID,
-      });
-      expect(result).to.deep.equal([testMemory]);
-    });
-
-    /**
-     * Test case: Verify retrieval of all memories
-     */
-    it("should retrieve all memories", async () => {
-      const result = await memory.getAllMemories(TEST_ROOM_ID);
-      expect(result).to.deep.equal([testMemory]);
-    });
-  });
-
-  /**
-   * Test suite for memory deletion functionality
-   */
-  describe("Memory Deletion", () => {
-    /**
-     * Test case: Verify memory deletion by ID
-     */
-    it("should delete a memory by ID", async () => {
-      let deleteCalled = false;
-      mockAdapter.clearMemoryById = async () => {
-        deleteCalled = true;
-      };
-
-      await memory.clearMemoryById("test-id", TEST_ROOM_ID);
-      expect(deleteCalled).to.be.true;
-    });
-
-    /**
-     * Test case: Verify deletion of all memories
-     */
-    it("should clear all memories", async () => {
-      let clearAllCalled = false;
-      mockAdapter.clearAllMemories = async () => {
-        clearAllCalled = true;
-      };
-
-      await memory.clearAllMemories();
-      expect(clearAllCalled).to.be.true;
-    });
-  });
-
-  describe("Error Handling", () => {
-    it("should handle errors during memory creation", async () => {
-      mockAdapter.createMemory = async () => {
-        throw new Error("Creation failed");
-      };
-
-      try {
-        await memory.createMemory({
-          data: "test",
-          roomId: TEST_ROOM_ID,
-        });
-        expect.fail("Should have thrown an error");
-      } catch (error) {
-        expect(error).to.be.instanceOf(Error);
-        expect((error as Error).message).to.equal("Creation failed");
-      }
-    });
-
-    it("should handle errors during memory retrieval", async () => {
-      mockAdapter.getMemoryById = async () => {
-        throw new Error("Retrieval failed");
-      };
-
-      try {
-        await memory.getMemoryById("test-id", TEST_ROOM_ID);
-        expect.fail("Should have thrown an error");
-      } catch (error) {
-        expect(error).to.be.instanceOf(Error);
-        expect((error as Error).message).to.equal("Retrieval failed");
-      }
-    });
-  });
-
-  describe("Edge Cases", () => {
-    it("should handle undefined embedding", async () => {
-      const input = {
-        id: "test-id",
-        roomId: "test-room",
-        data: "test data",
-        embedding: undefined,
-      };
-
-      const result = await memory.createMemory(input);
-      expect(result?.embedding).to.be.undefined;
-    });
-
-    it("should handle empty query results", async () => {
-      mockAdapter.getMemoryByIndex = async () => [];
-
-      const results = await memory.getMemoryByIndex("nonexistent", {
-        roomId: "test-room",
-      });
-      expect(results).to.be.an("array").that.is.empty;
-    });
-
-    it("should handle non-existent memory ID", async () => {
-      mockAdapter.getMemoryById = async () => null;
-
-      const result = await memory.getMemoryById("nonexistent", TEST_ROOM_ID);
-      expect(result).to.be.null;
-    });
-  });
-});