@ai.ntellect/core 0.6.16 → 0.6.19

package/test/memory/adapters/redis.test.ts

@@ -1,160 +0,0 @@
-import { BaseMemoryService } from "@/interfaces";
-import { RedisAdapter } from "@/memory/adapters/redis";
-import { BaseMemoryType } from "@/types";
-import { expect } from "chai";
-import dotenv from "dotenv";
-import Redis from "ioredis";
-
-// Load environment variables
-dotenv.config();
-
-describe("RedisAdapter", () => {
-  before(function () {
-    this.timeout(15000);
-  });
-
-  let redisAdapter: RedisAdapter;
-  let mockBaseMemoryService: BaseMemoryService;
-  let redisClient: Redis | null = null;
-  const fixedDate = new Date("2025-01-30T07:43:50.626Z");
-
-  const testMemory: BaseMemoryType = {
-    id: "test-id",
-    data: "test data",
-    query: "test query",
-    embedding: [0.1, 0.2, 0.3],
-    roomId: "test-room",
-    createdAt: fixedDate,
-  };
-
-  beforeEach(async () => {
-    mockBaseMemoryService = {
-      initializeConnection: async () => {},
-      createMemory: async () => {},
-      getMemoryById: async () => testMemory,
-      getMemoryByIndex: async () => [testMemory],
-      getAllMemories: async () => [testMemory],
-      clearMemoryById: async () => {},
-      clearAllMemories: async () => {},
-    };
-
-    // Use real Redis if environment variables are set, otherwise mock
-    if (process.env.REDIS_URL) {
-      redisClient = new Redis(process.env.REDIS_URL);
-      redisAdapter = new RedisAdapter(process.env.REDIS_URL, {
-        cachePrefix: "test-prefix",
-        cacheTTL: 3600,
-      });
-    } else {
-      // Mock Redis implementation
-      const mockRedis = {
-        connect: async () => {},
-        disconnect: async () => {},
-        set: async (key: string, value: string) => "OK",
-        get: async (key: string) => {
-          if (key.includes("test-id")) {
-            return JSON.stringify({
-              ...testMemory,
-              createdAt: fixedDate.toISOString(),
-            });
-          }
-          return null;
-        },
-        keys: async (pattern: string) => {
-          return [`${pattern}test-id`];
-        },
-        mget: async (keys: string[]) => {
-          return keys.map(() =>
-            JSON.stringify({
-              ...testMemory,
-              createdAt: fixedDate.toISOString(),
-            })
-          );
-        },
-        del: async () => 1,
-        flushall: async () => "OK",
-        quit: async () => {},
-      };
-
-      redisAdapter = new RedisAdapter(mockRedis as any, {
-        cachePrefix: "test-prefix",
-        cacheTTL: 3600,
-      });
-    }
-
-    await redisAdapter.initializeConnection();
-  });
-
-  afterEach(async () => {
-    if (redisClient) {
-      await redisClient.quit();
-      redisClient = null;
-    }
-    // @ts-ignore pour éviter l'erreur de typage
-    await redisAdapter?.quit?.();
-  });
-
-  describe("Initialization", () => {
-    it("should initialize storage", async () => {
-      await expect(redisAdapter.initializeConnection()).to.not.throw;
-    });
-  });
-
-  describe("Memory Operations", () => {
-    const TEST_ROOM_ID = "test-room";
-
-    it("should create memory", async () => {
-      await expect(
-        redisAdapter.createMemory({
-          data: "test data",
-          query: "test query",
-          roomId: TEST_ROOM_ID,
-          id: "test-id",
-          embedding: [0.1, 0.2, 0.3],
-          createdAt: fixedDate,
-        })
-      ).to.not.throw;
-    });
-
-    it("should get memory by ID", async () => {
-      const result = await redisAdapter.getMemoryById("test-id", TEST_ROOM_ID);
-      if (result) {
-        result.createdAt = new Date(result.createdAt);
-      }
-      expect(result).to.deep.equal({
-        ...testMemory,
-        createdAt: testMemory.createdAt,
-      });
-    });
-
-    it("should get memories by index", async () => {
-      const results = await redisAdapter.getMemoryByIndex("test", {
-        roomId: TEST_ROOM_ID,
-        limit: 10,
-      });
-
-      expect(results).to.be.an("array");
-      if (results[0]) {
-        results[0].createdAt = new Date(results[0].createdAt);
-      }
-      expect(results[0]).to.deep.equal(testMemory);
-    });
-
-    it("should get all memories", async () => {
-      const results = await redisAdapter.getAllMemories();
-      expect(results).to.be.an("array");
-      if (results[0]) {
-        results[0].createdAt = new Date(results[0].createdAt);
-      }
-      expect(results[0]).to.deep.equal(testMemory);
-    });
-
-    it("should clear memory by ID", async () => {
-      await expect(redisAdapter.clearMemoryById("test-id")).to.not.throw;
-    });
-
-    it("should clear all memories", async () => {
-      await expect(redisAdapter.clearAllMemories()).to.not.throw;
-    });
-  });
-});

package/test/memory/base.test.ts

@@ -1,229 +0,0 @@
-import { BaseMemoryService } from "@/interfaces";
-import { BaseMemory } from "@/memory";
-import { BaseMemoryType, CreateMemoryInput } from "@/types";
-import { expect } from "chai";
-
-/**
- * Test suite for the BaseMemory service
- * This suite tests the memory management system that handles storage and retrieval of memory entries
- */
-
-// Classe concrète pour tester BaseMemory
-class TestMemory extends BaseMemory {
-  async init(): Promise<void> {
-    await this.cacheService.initializeConnection();
-  }
-
-  async createMemory(
-    input: CreateMemoryInput & { embedding?: number[] }
-  ): Promise<BaseMemoryType | undefined> {
-    const memory: BaseMemoryType = {
-      id: crypto.randomUUID(),
-      data: input.data,
-      query: input.query,
-      embedding: input.embedding || null,
-      roomId: input.roomId,
-      createdAt: new Date(),
-    };
-    await this.cacheService.createMemory(memory, input.ttl);
-    return memory;
-  }
-
-  async getMemoryById(
-    id: string,
-    roomId: string
-  ): Promise<BaseMemoryType | null> {
-    return this.cacheService.getMemoryById(id);
-  }
-
-  async getMemoryByIndex(
-    query: string,
-    options: { roomId: string; limit?: number }
-  ): Promise<BaseMemoryType[]> {
-    return this.cacheService.getMemoryByIndex(query, options);
-  }
-
-  async getAllMemories(roomId: string): Promise<BaseMemoryType[]> {
-    return this.cacheService.getAllMemories();
-  }
-
-  async clearMemoryById(id: string, roomId: string): Promise<void> {
-    await this.cacheService.clearMemoryById(id);
-  }
-
-  async clearAllMemories(): Promise<void> {
-    await this.cacheService.clearAllMemories();
-  }
-}
-
-describe("BaseMemory", () => {
-  let memory: TestMemory;
-  let mockMemoryService: BaseMemoryService;
-  const TEST_ROOM_ID = "test-room";
-
-  // Mock data for testing
-  const testMemory: BaseMemoryType = {
-    id: "test-id",
-    data: "test data",
-    query: "test query",
-    embedding: [0.1, 0.2, 0.3],
-    roomId: "test-room",
-    createdAt: new Date(),
-  };
-
-  beforeEach(() => {
-    // Create mock implementation of BaseMemoryService
-    mockMemoryService = {
-      initializeConnection: async () => Promise.resolve(),
-      createMemory: async (memory: BaseMemoryType) => Promise.resolve(),
-      getMemoryById: async (id: string) => Promise.resolve(testMemory),
-      getMemoryByIndex: async (query: string, options: any) =>
-        Promise.resolve([testMemory]),
-      getAllMemories: async () => Promise.resolve([testMemory]),
-      clearMemoryById: async (id: string) => Promise.resolve(),
-      clearAllMemories: async () => Promise.resolve(),
-    };
-
-    memory = new TestMemory(mockMemoryService);
-  });
-
-  describe("Initialization", () => {
-    it("should initialize the memory service", async () => {
-      let initCalled = false;
-      mockMemoryService.initializeConnection = async () => {
-        initCalled = true;
-      };
-
-      await memory.init();
-      expect(initCalled).to.be.true;
-    });
-  });
-
-  describe("Memory Creation", () => {
-    it("should create a new memory entry", async () => {
-      const input = {
-        data: "test data",
-        query: "test query",
-        roomId: "test-room",
-        ttl: 3600,
-      };
-
-      const result = await memory.createMemory(input);
-
-      expect(result).to.exist;
-      expect(result?.data).to.equal(input.data);
-      expect(result?.query).to.equal(input.query);
-      expect(result?.roomId).to.equal(input.roomId);
-      expect(result?.id).to.be.a("string");
-    });
-
-    it("should create memory with embedding", async () => {
-      const input = {
-        data: "test data",
-        query: "test query",
-        roomId: "test-room",
-        embedding: [0.1, 0.2, 0.3],
-      };
-
-      const result = await memory.createMemory(input);
-
-      expect(result?.embedding).to.deep.equal(input.embedding);
-    });
-  });
-
-  describe("Memory Retrieval", () => {
-    it("should retrieve memory by ID", async () => {
-      const result = await memory.getMemoryById("test-id", TEST_ROOM_ID);
-      expect(result).to.deep.equal(testMemory);
-    });
-
-    it("should retrieve memories by index", async () => {
-      const results = await memory.getMemoryByIndex("test query", {
-        roomId: "test-room",
-        limit: 10,
-      });
-
-      expect(results).to.be.an("array");
-      expect(results[0]).to.deep.equal(testMemory);
-    });
-
-    it("should retrieve all memories", async () => {
-      const results = await memory.getAllMemories(TEST_ROOM_ID);
-      expect(results).to.be.an("array");
-    });
-  });
-
-  describe("Memory Clearing", () => {
-    it("should clear memory by ID", async () => {
-      await memory.clearMemoryById("test-id", TEST_ROOM_ID);
-    });
-
-    it("should clear all memories", async () => {
-      await memory.clearAllMemories();
-    });
-  });
-
-  describe("Error Handling", () => {
-    it("should handle errors during memory creation", async () => {
-      mockMemoryService.createMemory = async () => {
-        throw new Error("Creation failed");
-      };
-
-      try {
-        await memory.createMemory({
-          data: "test",
-          query: "test",
-          roomId: "test",
-        });
-        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 () => {
-      mockMemoryService.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 = {
-        data: "test data",
-        query: "test query",
-        roomId: "test-room",
-        embedding: undefined,
-      };
-
-      const result = await memory.createMemory(input);
-      expect(result?.embedding).to.be.null;
-    });
-
-    it("should handle empty query results", async () => {
-      mockMemoryService.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 () => {
-      mockMemoryService.getMemoryById = async () => null;
-
-      const result = await memory.getMemoryById("nonexistent", TEST_ROOM_ID);
-      expect(result).to.be.null;
-    });
-  });
-});

package/test/services/queue.test.ts

@@ -1,286 +0,0 @@
-import { Queue } from "@/services/queue";
-import { ActionSchema, QueueCallbacks, QueueItem } from "@/types";
-import { expect } from "chai";
-import { z } from "zod";
-
-describe("Queue", () => {
-  // Test actions setup
-  const testActions: ActionSchema[] = [
-    {
-      name: "action1",
-      description: "Test action 1",
-      parameters: z.object({}),
-      execute: async (params) => ({ success: true, params }),
-    },
-    {
-      name: "action2",
-      description: "Test action 2",
-      parameters: z.object({}),
-      execute: async (params) => ({ success: true, params }),
-      confirmation: {
-        requireConfirmation: true,
-        message: "Confirm action2?",
-      },
-    },
-    {
-      name: "actionWithError",
-      description: "Test error action",
-      parameters: z.object({}),
-      execute: async () => {
-        throw new Error("Test error");
-      },
-    },
-  ];
-
-  let queue: Queue;
-  let callbacks: QueueCallbacks;
-
-  beforeEach(() => {
-    // Reset callbacks for each test
-    callbacks = {
-      onActionStart: () => {},
-      onActionComplete: () => {},
-      onQueueComplete: () => {},
-      onConfirmationRequired: async () => true,
-    };
-    queue = new Queue(testActions, callbacks);
-  });
-
-  describe("Queue Management", () => {
-    it("should add a single action to the queue", () => {
-      const action: QueueItem = {
-        name: "action1",
-        parameters: [{ name: "param1", value: "value1" }],
-      };
-
-      queue.add(action);
-      expect(queue["queue"]).to.have.lengthOf(1);
-      expect(queue["queue"][0]).to.deep.equal(action);
-    });
-
-    it("should add multiple actions to the queue", () => {
-      const actions: QueueItem[] = [
-        {
-          name: "action1",
-          parameters: [{ name: "param1", value: "value1" }],
-        },
-        {
-          name: "action2",
-          parameters: [{ name: "param2", value: "value2" }],
-        },
-      ];
-
-      queue.add(actions);
-      expect(queue["queue"]).to.have.lengthOf(2);
-      expect(queue["queue"]).to.deep.equal(actions);
-    });
-  });
-
-  describe("Action Execution", () => {
-    it("should execute a single action successfully", async () => {
-      const action: QueueItem = {
-        name: "action1",
-        parameters: [{ name: "param1", value: "value1" }],
-      };
-
-      queue.add(action);
-      const results = await queue.execute();
-      if (!results) {
-        throw new Error("Results are undefined");
-      }
-      expect(results).to.not.be.undefined;
-      expect(results).to.have.lengthOf(1);
-      expect(results[0].name).to.equal("action1");
-      expect(results[0].error).to.be.null;
-      expect(results[0].result).to.deep.include({ success: true });
-    });
-
-    it("should handle action execution errors", async () => {
-      const action: QueueItem = {
-        name: "actionWithError",
-        parameters: [],
-      };
-
-      queue.add(action);
-      const results = await queue.execute();
-      if (!results) {
-        throw new Error("Results are undefined");
-      }
-      expect(results).to.not.be.undefined;
-      expect(results).to.have.lengthOf(1);
-      expect(results[0].name).to.equal("actionWithError");
-      expect(results[0].error).to.equal("Test error");
-      expect(results[0].result).to.be.null;
-    });
-
-    it("should respect confirmation requirements", async () => {
-      let confirmationCalled = false;
-      callbacks.onConfirmationRequired = async () => {
-        confirmationCalled = true;
-        return false; // Reject the confirmation
-      };
-
-      queue = new Queue(testActions, callbacks);
-      const action: QueueItem = {
-        name: "action2", // Action requiring confirmation
-        parameters: [],
-      };
-
-      queue.add(action);
-      const results = await queue.execute();
-      if (!results) {
-        throw new Error("Results are undefined");
-      }
-      expect(results).to.not.be.undefined;
-      expect(confirmationCalled).to.be.true;
-      expect(results[0].cancelled).to.be.true;
-      expect(results[0].error).to.equal("Action cancelled by user");
-    });
-  });
-
-  describe("Parameter Handling", () => {
-    it("should correctly format simple parameters", async () => {
-      const action: QueueItem = {
-        name: "action1",
-        parameters: [
-          { name: "param1", value: "value1" },
-          { name: "param2", value: "value2" },
-        ],
-      };
-
-      queue.add(action);
-      const results = await queue.execute();
-      if (!results) {
-        throw new Error("Results are undefined");
-      }
-      expect(results).to.not.be.undefined;
-      expect(results[0].parameters).to.deep.equal({
-        param1: "value1",
-        param2: "value2",
-      });
-    });
-
-    it("should handle JSON stringified parameters", async () => {
-      const action: QueueItem = {
-        name: "action1",
-        parameters: [
-          {
-            name: "jsonParam",
-            value: JSON.stringify({ name: "test", value: "value" }),
-          },
-        ],
-      };
-
-      queue.add(action);
-      const results = await queue.execute();
-      if (!results) {
-        throw new Error("Results are undefined");
-      }
-      expect(results).to.not.be.undefined;
-      expect(results[0].parameters).to.deep.equal({
-        test: "value",
-      });
-    });
-  });
-
-  describe("Queue Processing State", () => {
-    it("should prevent concurrent queue processing", async () => {
-      const action: QueueItem = {
-        name: "action1",
-        parameters: [],
-      };
-
-      queue.add(action);
-
-      // Start first execution
-      const firstExecution = queue.execute();
-      // Try to execute again while first execution is running
-      const secondExecution = queue.execute();
-
-      const [firstResults, secondResults] = await Promise.all([
-        firstExecution,
-        secondExecution,
-      ]);
-
-      expect(firstResults).to.not.be.undefined;
-      expect(firstResults).to.have.lengthOf(1);
-      expect(secondResults).to.be.undefined;
-    });
-
-    it("should reset processing state after completion", async () => {
-      const action: QueueItem = {
-        name: "action1",
-        parameters: [],
-      };
-
-      queue.add(action);
-      const results = await queue.execute();
-
-      if (!results) {
-        throw new Error("Results are undefined");
-      }
-      expect(results).to.have.lengthOf(1);
-
-      // Verify that isProcessing is reset
-      expect(queue["isProcessing"]).to.be.false;
-
-      // Clear both queue and results before adding new action
-      queue["queue"] = [];
-      queue["results"] = [];
-
-      // Should be able to execute again
-      queue.add(action);
-      const secondResults = await queue.execute();
-
-      if (!secondResults) {
-        throw new Error("Second results are undefined");
-      }
-      expect(secondResults).to.have.lengthOf(1);
-    });
-  });
-
-  describe("Callback Handling", () => {
-    it("should trigger all callbacks in correct order", async () => {
-      const callbackOrder: string[] = [];
-
-      callbacks = {
-        onActionStart: () => callbackOrder.push("start"),
-        onActionComplete: () => callbackOrder.push("complete"),
-        onQueueComplete: () => callbackOrder.push("queueComplete"),
-      };
-
-      queue = new Queue(testActions, callbacks);
-      const action: QueueItem = {
-        name: "action1",
-        parameters: [],
-      };
-
-      queue.add(action);
-      await queue.execute();
-
-      expect(callbackOrder).to.deep.equal([
-        "start",
-        "complete",
-        "queueComplete",
-      ]);
-    });
-
-    it("should handle missing callbacks gracefully", async () => {
-      queue = new Queue(testActions, {}); // No callbacks provided
-      const action: QueueItem = {
-        name: "action1",
-        parameters: [],
-      };
-
-      queue.add(action);
-      const results = await queue.execute();
-
-      if (!results) {
-        throw new Error("Results are undefined");
-      }
-      expect(results).to.not.be.undefined;
-      expect(results).to.have.lengthOf(1);
-      expect(results[0].error).to.be.null;
-    });
-  });
-});