@ai.ntellect/core 0.6.21 → 0.7.0

package/test/modules/embedding/ai.test.ts

@@ -1,78 +0,0 @@
-import { openai } from "@ai-sdk/openai";
-import { expect } from "chai";
-import { Embedding } from "../../../modules/embedding";
-import { AIEmbeddingAdapter } from "../../../modules/embedding/adapters/ai";
-
-describe("EmbeddingModule", () => {
-  let embeddingModule: Embedding;
-
-  before(function () {
-    this.timeout(10000);
-  });
-
-  beforeEach(() => {
-    const model = openai.embedding("text-embedding-3-small");
-    const embeddingModel = new AIEmbeddingAdapter(model);
-    embeddingModule = new Embedding(embeddingModel);
-  });
-
-  it("should embed text", async function () {
-    try {
-      const embedding = await embeddingModule.embedText("Hello, world!");
-      expect(embedding).to.be.an("array");
-      expect(embedding.length).to.be.greaterThan(0);
-      expect(embedding[0]).to.be.a("number");
-    } catch (error) {
-      console.error("Error in embedText:", error);
-      throw error;
-    }
-  });
-
-  it("should embed many texts", async function () {
-    try {
-      const embeddings = await embeddingModule.embedMany([
-        "Hello, world!",
-        "Another test text",
-      ]);
-      expect(embeddings).to.be.an("array");
-      expect(embeddings.length).to.equal(2);
-      expect(embeddings[0]).to.be.an("array");
-      expect(embeddings[0][0]).to.be.a("number");
-    } catch (error) {
-      console.error("Error in embedMany:", error);
-      throw error;
-    }
-  });
-
-  it("should calculate similarity between two embeddings", () => {
-    const embedding1 = [1, 2, 3];
-    const embedding2 = [4, 5, 6];
-    const similarity = embeddingModule.calculateSimilarity(
-      embedding1,
-      embedding2
-    );
-    expect(similarity).to.be.a("number");
-    expect(similarity).to.be.within(0, 100);
-  });
-
-  it("should handle embedding errors gracefully", async function () {
-    const mockEmbeddingAdapter = {
-      embed: async () => {
-        throw new Error("Mock embedding error");
-      },
-      embedMany: async () => {
-        throw new Error("Mock embedding error");
-      },
-    };
-
-    const mockEmbeddingModule = new Embedding(mockEmbeddingAdapter);
-
-    try {
-      await mockEmbeddingModule.embedText("test");
-      expect.fail("Should have thrown an error");
-    } catch (error) {
-      expect(error).to.exist;
-      expect((error as Error).message).to.equal("Mock embedding error");
-    }
-  });
-});

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

@@ -1,169 +0,0 @@
-import { expect } from "chai";
-import dotenv from "dotenv";
-import Redis from "ioredis";
-import { IMemoryAdapter } from "../../../interfaces";
-import { RedisAdapter } from "../../../memory/adapters/redis";
-import { BaseMemoryType } from "../../../types";
-
-// Load environment variables
-dotenv.config();
-
-describe("RedisAdapter", () => {
-  before(function () {
-    this.timeout(30000);
-  });
-
-  let redisAdapter: RedisAdapter;
-  let mockAdapter: IMemoryAdapter;
-  let redisClient: Redis | null = null;
-  const fixedDate = new Date("2025-01-30T07:43:50.626Z");
-  const fixedDateString = fixedDate.toISOString();
-
-  const testMemory: BaseMemoryType = {
-    id: "test-id",
-    data: "test data",
-    roomId: "test-room",
-    createdAt: new Date(fixedDateString),
-  };
-
-  beforeEach(async function () {
-    this.timeout(10000);
-
-    try {
-      mockAdapter = {
-        init: async () => {},
-        createMemory: async (input) => testMemory,
-        getMemoryById: async () => testMemory,
-        getMemoryByIndex: async () => [testMemory],
-        getAllMemories: async () => [testMemory],
-        clearMemoryById: async () => {},
-        clearAllMemories: async () => {},
-      };
-
-      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 {
-        const mockRedis = {
-          connect: async () => Promise.resolve(),
-          disconnect: async () => Promise.resolve(),
-          set: async () => "OK",
-          get: async (key: string) => {
-            if (key.includes("test-id")) {
-              return JSON.stringify({
-                id: "test-id",
-                data: "test data",
-                embedding: null,
-                roomId: "test-room",
-                createdAt: fixedDateString,
-              });
-            }
-            return null;
-          },
-          keys: async () => [`test-id`],
-          mget: async (keys: string[]) =>
-            keys.map(() =>
-              JSON.stringify({
-                id: "test-id",
-                data: "test data",
-                embedding: null,
-                roomId: "test-room",
-                createdAt: fixedDateString,
-              })
-            ),
-          del: async () => 1,
-          flushall: async () => "OK",
-          quit: async () => Promise.resolve(),
-        };
-
-        redisAdapter = new RedisAdapter(mockRedis as any, {
-          cachePrefix: "test-prefix",
-          cacheTTL: 3600,
-        });
-      }
-
-      await redisAdapter.init("test-room");
-    } catch (error) {
-      console.error("Error in beforeEach:", error);
-      throw error;
-    }
-  });
-
-  afterEach(async function () {
-    this.timeout(5000);
-    try {
-      if (redisClient) {
-        await redisClient.quit();
-        redisClient = null;
-      }
-      if (redisAdapter) {
-        await redisAdapter.quit();
-      }
-    } catch (error) {
-      console.error("Error in afterEach:", error);
-    }
-  });
-
-  describe("Initialization", () => {
-    it("should initialize storage", async () => {
-      await expect(redisAdapter.init("test-room")).to.not.throw;
-    });
-  });
-
-  describe("Memory Operations", () => {
-    const TEST_ROOM_ID = "test-room";
-
-    it("should create memory", async () => {
-      await expect(
-        redisAdapter.createMemory({
-          data: "test data",
-          roomId: TEST_ROOM_ID,
-          id: "test-id",
-          embedding: [0.1, 0.2, 0.3],
-        })
-      ).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(fixedDateString);
-      }
-      expect(result).to.deep.equal(testMemory);
-    });
-
-    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(fixedDateString);
-      }
-      expect(results[0]).to.deep.equal(testMemory);
-    });
-
-    it("should get all memories", async () => {
-      const results = await redisAdapter.getAllMemories(TEST_ROOM_ID);
-      expect(results).to.be.an("array");
-      if (results[0]) {
-        results[0].createdAt = new Date(fixedDateString);
-      }
-      expect(results[0]).to.deep.equal(testMemory);
-    });
-
-    it("should clear memory by ID", async () => {
-      await expect(redisAdapter.clearMemoryById("test-id", TEST_ROOM_ID)).to.not
-        .throw;
-    });
-
-    it("should clear all memories", async () => {
-      await expect(redisAdapter.clearAllMemories()).to.not.throw;
-    });
-  });
-});

package/test/services/agenda.test.ts

@@ -1,279 +0,0 @@
-import { expect } from "chai";
-import sinon from "sinon";
-import { NodeCronAdapter } from "../../modules/agenda/adapters/cron/node-cron";
-import { Agenda } from "../../modules/agenda/agenda";
-
-before(function () {
-  this.timeout(10000);
-});
-
-describe("Agenda Service", () => {
-  let agenda: Agenda;
-  const scheduledIds: string[] = []; // Track all scheduled request IDs
-
-  beforeEach(() => {
-    const cronService = new NodeCronAdapter();
-    agenda = new Agenda(cronService);
-  });
-
-  afterEach(async () => {
-    // Cancel all scheduled requests by their IDs
-    scheduledIds.forEach((id) => agenda.cancelScheduledRequest(id));
-    scheduledIds.length = 0; // Clear the array
-
-    // Ensure all tasks are stopped
-    await agenda.stop();
-
-    await agenda.cancel({});
-
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  });
-
-  describe("Request Scheduling", () => {
-    it("should schedule a new request and return an id", async () => {
-      const request = {
-        originalRequest: "test request",
-        cronExpression: "0 0 * * *",
-      };
-
-      const id = await agenda.scheduleRequest(request);
-      scheduledIds.push(id); // Track the ID
-
-      expect(id).to.be.a("string");
-      expect(agenda.getScheduledRequests()).to.have.lengthOf(1);
-
-      const scheduledRequest = agenda.getScheduledRequests()[0];
-      expect(scheduledRequest.originalRequest).to.equal(
-        request.originalRequest
-      );
-      expect(scheduledRequest.cronExpression).to.equal(request.cronExpression);
-      expect(scheduledRequest.isRecurring).to.be.false;
-
-      agenda.cancelScheduledRequest(id);
-    });
-
-    it("should execute callbacks when scheduling and executing", async function () {
-      this.timeout(5000);
-
-      const onScheduledSpy = sinon.spy();
-      const onExecutedSpy = sinon.spy();
-
-      const request = {
-        originalRequest: "test request",
-        cronExpression: `${(new Date().getSeconds() + 1) % 60} * * * * *`,
-      };
-
-      const id = await agenda.scheduleRequest(request, {
-        onScheduled: onScheduledSpy,
-        onExecuted: onExecutedSpy,
-      });
-      scheduledIds.push(id);
-
-      expect(onScheduledSpy.calledOnce).to.be.true;
-
-      await new Promise<void>((resolve, reject) => {
-        const timeout = setTimeout(() => {
-          reject(new Error("Callback execution timeout"));
-        }, 4000);
-
-        const checkExecution = () => {
-          if (onExecutedSpy.calledOnce) {
-            clearTimeout(timeout);
-            agenda.cancelScheduledRequest(id);
-            resolve();
-            return;
-          }
-          setTimeout(checkExecution, 100);
-        };
-        checkExecution();
-      });
-
-      expect(onExecutedSpy.calledOnce).to.be.true;
-    });
-  });
-
-  describe("Request Management", () => {
-    it("should cancel a scheduled request", async () => {
-      const request = {
-        originalRequest: "test request",
-        cronExpression: "*/1 * * * *",
-      };
-
-      const id = await agenda.scheduleRequest(request);
-      scheduledIds.push(id);
-      expect(agenda.getScheduledRequests()).to.have.lengthOf(1);
-
-      const cancelled = agenda.cancelScheduledRequest(id);
-      expect(cancelled).to.be.true;
-      expect(agenda.getScheduledRequests()).to.have.lengthOf(0);
-    });
-
-    it("should return false when cancelling non-existent request", () => {
-      const cancelled = agenda.cancelScheduledRequest("non-existent-id");
-      expect(cancelled).to.be.false;
-    });
-
-    it("should get all scheduled requests", async () => {
-      const requests = [
-        {
-          originalRequest: "request 1",
-          cronExpression: "*/1 * * * *",
-        },
-        {
-          originalRequest: "request 2",
-          cronExpression: "*/5 * * * *",
-        },
-      ];
-
-      for (const request of requests) {
-        const id = await agenda.scheduleRequest(request);
-        scheduledIds.push(id);
-      }
-
-      const scheduledRequests = agenda.getScheduledRequests();
-      expect(scheduledRequests).to.have.lengthOf(2);
-      expect(scheduledRequests[0].originalRequest).to.equal("request 1");
-      expect(scheduledRequests[1].originalRequest).to.equal("request 2");
-    });
-  });
-
-  describe("Global Management", () => {
-    it("should stop all scheduled requests", async () => {
-      const requests = [
-        {
-          originalRequest: "request 1",
-          cronExpression: "*/1 * * * *",
-        },
-        {
-          originalRequest: "request 2",
-          cronExpression: "*/5 * * * *",
-        },
-      ];
-
-      for (const request of requests) {
-        await agenda.scheduleRequest(request);
-      }
-
-      expect(agenda.getScheduledRequests()).to.have.lengthOf(2);
-
-      agenda.stopAll();
-      expect(agenda.getScheduledRequests()).to.have.lengthOf(0);
-    });
-  });
-
-  describe("Error Handling", () => {
-    it("should handle execution errors gracefully", async () => {
-      const consoleSpy = sinon.spy(console, "error");
-
-      const request = {
-        originalRequest: "error request",
-        cronExpression: "0 0 * * *",
-      };
-
-      const id = await agenda.scheduleRequest(request);
-
-      // Wait for execution
-      await new Promise((resolve) => setTimeout(resolve, 1100));
-
-      expect(consoleSpy.called).to.be.false;
-
-      agenda.cancelScheduledRequest(id);
-      consoleSpy.restore();
-    });
-  });
-
-  describe("Request Execution", () => {
-    it("should execute non-recurring requests only once", async function () {
-      this.timeout(5000);
-      const onExecutedSpy = sinon.spy();
-
-      const request = {
-        originalRequest: "single execution",
-        cronExpression: `${new Date().getSeconds() + 1} * * * * *`,
-      };
-
-      const id = await agenda.scheduleRequest(request, {
-        onExecuted: onExecutedSpy,
-      });
-
-      try {
-        await new Promise<void>((resolve, reject) => {
-          const timeout = setTimeout(
-            () => reject(new Error("Test timeout")),
-            4000
-          );
-          const checkExecution = () => {
-            if (onExecutedSpy.calledOnce) {
-              clearTimeout(timeout);
-              resolve();
-              return;
-            }
-            setTimeout(checkExecution, 100);
-          };
-          checkExecution();
-        });
-      } finally {
-        agenda.cancelScheduledRequest(id);
-      }
-
-      expect(onExecutedSpy.calledOnce).to.be.true;
-      expect(agenda.getScheduledRequests()).to.have.lengthOf(0);
-    });
-
-    it("should log execution status", async function () {
-      this.timeout(10000);
-      const consoleLogSpy = sinon.spy(console, "log");
-
-      const request = {
-        originalRequest: "test request",
-        cronExpression: `${new Date().getSeconds() + 1} * * * * *`,
-      };
-
-      const id = await agenda.scheduleRequest(request);
-
-      await new Promise<void>((resolve) => {
-        const checkExecution = () => {
-          if (
-            consoleLogSpy.calledWith(`🔄 Executing scheduled request: ${id}`) &&
-            consoleLogSpy.calledWith(
-              `✅ Scheduled request executed successfully: ${id}`
-            )
-          ) {
-            agenda.cancelScheduledRequest(id);
-            resolve();
-            return;
-          }
-          setTimeout(checkExecution, 100);
-        };
-        checkExecution();
-      });
-
-      expect(consoleLogSpy.calledWith(`🔄 Executing scheduled request: ${id}`))
-        .to.be.true;
-      expect(
-        consoleLogSpy.calledWith(
-          `✅ Scheduled request executed successfully: ${id}`
-        )
-      ).to.be.true;
-
-      consoleLogSpy.restore();
-    });
-  });
-});
-
-let globalAgenda: Agenda;
-before(() => {
-  const cronService = new NodeCronAdapter();
-  globalAgenda = new Agenda(cronService);
-});
-
-after(async () => {
-  if (globalAgenda) {
-    globalAgenda.stopAll();
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  }
-
-  await globalAgenda.stop();
-  await globalAgenda.cancel({});
-  await new Promise((resolve) => setTimeout(resolve, 100));
-});