@ai.ntellect/core 0.5.0 → 0.6.0

package/test/services/agenda.test.ts

@@ -0,0 +1,280 @@
+// import { expect } from "chai";
+// import sinon from "sinon";
+// import { Agenda } from "../../services/agenda";
+
+// before(function () {
+//   this.timeout(10000);
+// });
+
+// describe("Agenda Service", () => {
+//   let agenda: Agenda;
+//   const scheduledIds: string[] = []; // Track all scheduled request IDs
+
+//   beforeEach(() => {
+//     agenda = new Agenda();
+//   });
+
+//   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();
+
+//     // Vider la file d'attente
+//     await agenda.cancel({});
+
+//     // Attendre un peu pour s'assurer que tout est arrêté
+//     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); // Track the 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); // Track the 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); // Track the 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();
+//     });
+//   });
+// });
+
+// // Déplacer la variable agenda en dehors du describe pour la rendre accessible
+// let globalAgenda: Agenda;
+// before(() => {
+//   globalAgenda = new Agenda();
+// });
+
+// after(async () => {
+//   if (globalAgenda) {
+//     globalAgenda.stopAll();
+//     await new Promise((resolve) => setTimeout(resolve, 100));
+//   }
+
+//   // Nettoyage final
+//   await globalAgenda.stop();
+//   await globalAgenda.cancel({});
+//   await new Promise((resolve) => setTimeout(resolve, 100));
+// });

package/test/services/queue.test.ts

@@ -1,44 +1,286 @@
-// import { expect } from "chai";
-// import { z } from "zod";
-// import { ActionQueueManager } from "../../services/queue";
-// import { ActionSchema } from "../../types";
-
-// describe("ActionQueueManager", () => {
-//   let queueManager: ActionQueueManager;
-
-//   const mockAction: ActionSchema = {
-//     name: "prepare-transaction",
-//     description: "Prepare a transfer transaction",
-//     parameters: z.object({
-//       walletAddress: z.string(),
-//       amount: z.string(),
-//       networkId: z.string(),
-//     }),
-//     execute: async ({ walletAddress, amount, networkId }) => {
-//       return { walletAddress, amount, networkId };
-//     },
-//   };
-
-//   beforeEach(() => {
-//     queueManager = new ActionQueueManager([mockAction]);
-//   });
-
-//   it("should process queue items correctly", async () => {
-//     const queueItem = {
-//       name: "prepare-transaction",
-//       parameters: [
-//         { name: "walletAddress", value: "0x123...456" },
-//         { name: "amount", value: "0.1" },
-//         { name: "networkId", value: "1" },
-//       ],
-//     };
-
-//     queueManager.addToQueue([queueItem]);
-//     const results = await queueManager.processQueue();
-
-//     expect(results).to.exist;
-//     expect(results!).to.be.an("array");
-//     expect(results![0]).to.have.property("name", "prepare-transaction");
-//     expect(results![0]).to.have.property("result").that.is.an("object");
-//   });
-// });
+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;
+    });
+  });
+});

package/tsconfig.json

@@ -1,16 +1,16 @@
 {
   "compilerOptions": {
-    "target": "ES2020",
-    "module": "CommonJS",
-    "moduleResolution": "node",
-    "lib": ["ES2020"],
-    "declaration": true,
-    "outDir": "./dist",
-    "strict": true,
+    "target": "es2016",
+    "module": "commonjs",
     "esModuleInterop": true,
-    "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true
+    "strict": true,
+    "skipLibCheck": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./*"]
+    },
+    "outDir": "./dist"
   },
-  "exclude": ["node_modules", "dist", "test"]
+  "exclude": ["examples"]
 }