@ai.ntellect/core 0.6.1 → 0.6.3

package/dist/test/services/agenda.test.js

@@ -1,230 +0,0 @@
-"use strict";
-// 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/dist/test/services/queue.test.js

@@ -1,258 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const queue_1 = require("@/services/queue");
-const chai_1 = require("chai");
-const zod_1 = require("zod");
-describe("Queue", () => {
-    // Test actions setup
-    const testActions = [
-        {
-            name: "action1",
-            description: "Test action 1",
-            parameters: zod_1.z.object({}),
-            execute: (params) => __awaiter(void 0, void 0, void 0, function* () { return ({ success: true, params }); }),
-        },
-        {
-            name: "action2",
-            description: "Test action 2",
-            parameters: zod_1.z.object({}),
-            execute: (params) => __awaiter(void 0, void 0, void 0, function* () { return ({ success: true, params }); }),
-            confirmation: {
-                requireConfirmation: true,
-                message: "Confirm action2?",
-            },
-        },
-        {
-            name: "actionWithError",
-            description: "Test error action",
-            parameters: zod_1.z.object({}),
-            execute: () => __awaiter(void 0, void 0, void 0, function* () {
-                throw new Error("Test error");
-            }),
-        },
-    ];
-    let queue;
-    let callbacks;
-    beforeEach(() => {
-        // Reset callbacks for each test
-        callbacks = {
-            onActionStart: () => { },
-            onActionComplete: () => { },
-            onQueueComplete: () => { },
-            onConfirmationRequired: () => __awaiter(void 0, void 0, void 0, function* () { return true; }),
-        };
-        queue = new queue_1.Queue(testActions, callbacks);
-    });
-    describe("Queue Management", () => {
-        it("should add a single action to the queue", () => {
-            const action = {
-                name: "action1",
-                parameters: [{ name: "param1", value: "value1" }],
-            };
-            queue.add(action);
-            (0, chai_1.expect)(queue["queue"]).to.have.lengthOf(1);
-            (0, chai_1.expect)(queue["queue"][0]).to.deep.equal(action);
-        });
-        it("should add multiple actions to the queue", () => {
-            const actions = [
-                {
-                    name: "action1",
-                    parameters: [{ name: "param1", value: "value1" }],
-                },
-                {
-                    name: "action2",
-                    parameters: [{ name: "param2", value: "value2" }],
-                },
-            ];
-            queue.add(actions);
-            (0, chai_1.expect)(queue["queue"]).to.have.lengthOf(2);
-            (0, chai_1.expect)(queue["queue"]).to.deep.equal(actions);
-        });
-    });
-    describe("Action Execution", () => {
-        it("should execute a single action successfully", () => __awaiter(void 0, void 0, void 0, function* () {
-            const action = {
-                name: "action1",
-                parameters: [{ name: "param1", value: "value1" }],
-            };
-            queue.add(action);
-            const results = yield queue.execute();
-            if (!results) {
-                throw new Error("Results are undefined");
-            }
-            (0, chai_1.expect)(results).to.not.be.undefined;
-            (0, chai_1.expect)(results).to.have.lengthOf(1);
-            (0, chai_1.expect)(results[0].name).to.equal("action1");
-            (0, chai_1.expect)(results[0].error).to.be.null;
-            (0, chai_1.expect)(results[0].result).to.deep.include({ success: true });
-        }));
-        it("should handle action execution errors", () => __awaiter(void 0, void 0, void 0, function* () {
-            const action = {
-                name: "actionWithError",
-                parameters: [],
-            };
-            queue.add(action);
-            const results = yield queue.execute();
-            if (!results) {
-                throw new Error("Results are undefined");
-            }
-            (0, chai_1.expect)(results).to.not.be.undefined;
-            (0, chai_1.expect)(results).to.have.lengthOf(1);
-            (0, chai_1.expect)(results[0].name).to.equal("actionWithError");
-            (0, chai_1.expect)(results[0].error).to.equal("Test error");
-            (0, chai_1.expect)(results[0].result).to.be.null;
-        }));
-        it("should respect confirmation requirements", () => __awaiter(void 0, void 0, void 0, function* () {
-            let confirmationCalled = false;
-            callbacks.onConfirmationRequired = () => __awaiter(void 0, void 0, void 0, function* () {
-                confirmationCalled = true;
-                return false; // Reject the confirmation
-            });
-            queue = new queue_1.Queue(testActions, callbacks);
-            const action = {
-                name: "action2", // Action requiring confirmation
-                parameters: [],
-            };
-            queue.add(action);
-            const results = yield queue.execute();
-            if (!results) {
-                throw new Error("Results are undefined");
-            }
-            (0, chai_1.expect)(results).to.not.be.undefined;
-            (0, chai_1.expect)(confirmationCalled).to.be.true;
-            (0, chai_1.expect)(results[0].cancelled).to.be.true;
-            (0, chai_1.expect)(results[0].error).to.equal("Action cancelled by user");
-        }));
-    });
-    describe("Parameter Handling", () => {
-        it("should correctly format simple parameters", () => __awaiter(void 0, void 0, void 0, function* () {
-            const action = {
-                name: "action1",
-                parameters: [
-                    { name: "param1", value: "value1" },
-                    { name: "param2", value: "value2" },
-                ],
-            };
-            queue.add(action);
-            const results = yield queue.execute();
-            if (!results) {
-                throw new Error("Results are undefined");
-            }
-            (0, chai_1.expect)(results).to.not.be.undefined;
-            (0, chai_1.expect)(results[0].parameters).to.deep.equal({
-                param1: "value1",
-                param2: "value2",
-            });
-        }));
-        it("should handle JSON stringified parameters", () => __awaiter(void 0, void 0, void 0, function* () {
-            const action = {
-                name: "action1",
-                parameters: [
-                    {
-                        name: "jsonParam",
-                        value: JSON.stringify({ name: "test", value: "value" }),
-                    },
-                ],
-            };
-            queue.add(action);
-            const results = yield queue.execute();
-            if (!results) {
-                throw new Error("Results are undefined");
-            }
-            (0, chai_1.expect)(results).to.not.be.undefined;
-            (0, chai_1.expect)(results[0].parameters).to.deep.equal({
-                test: "value",
-            });
-        }));
-    });
-    describe("Queue Processing State", () => {
-        it("should prevent concurrent queue processing", () => __awaiter(void 0, void 0, void 0, function* () {
-            const action = {
-                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] = yield Promise.all([
-                firstExecution,
-                secondExecution,
-            ]);
-            (0, chai_1.expect)(firstResults).to.not.be.undefined;
-            (0, chai_1.expect)(firstResults).to.have.lengthOf(1);
-            (0, chai_1.expect)(secondResults).to.be.undefined;
-        }));
-        it("should reset processing state after completion", () => __awaiter(void 0, void 0, void 0, function* () {
-            const action = {
-                name: "action1",
-                parameters: [],
-            };
-            queue.add(action);
-            const results = yield queue.execute();
-            if (!results) {
-                throw new Error("Results are undefined");
-            }
-            (0, chai_1.expect)(results).to.have.lengthOf(1);
-            // Verify that isProcessing is reset
-            (0, chai_1.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 = yield queue.execute();
-            if (!secondResults) {
-                throw new Error("Second results are undefined");
-            }
-            (0, chai_1.expect)(secondResults).to.have.lengthOf(1);
-        }));
-    });
-    describe("Callback Handling", () => {
-        it("should trigger all callbacks in correct order", () => __awaiter(void 0, void 0, void 0, function* () {
-            const callbackOrder = [];
-            callbacks = {
-                onActionStart: () => callbackOrder.push("start"),
-                onActionComplete: () => callbackOrder.push("complete"),
-                onQueueComplete: () => callbackOrder.push("queueComplete"),
-            };
-            queue = new queue_1.Queue(testActions, callbacks);
-            const action = {
-                name: "action1",
-                parameters: [],
-            };
-            queue.add(action);
-            yield queue.execute();
-            (0, chai_1.expect)(callbackOrder).to.deep.equal([
-                "start",
-                "complete",
-                "queueComplete",
-            ]);
-        }));
-        it("should handle missing callbacks gracefully", () => __awaiter(void 0, void 0, void 0, function* () {
-            queue = new queue_1.Queue(testActions, {}); // No callbacks provided
-            const action = {
-                name: "action1",
-                parameters: [],
-            };
-            queue.add(action);
-            const results = yield queue.execute();
-            if (!results) {
-                throw new Error("Results are undefined");
-            }
-            (0, chai_1.expect)(results).to.not.be.undefined;
-            (0, chai_1.expect)(results).to.have.lengthOf(1);
-            (0, chai_1.expect)(results[0].error).to.be.null;
-        }));
-    });
-});

package/dist/utils/schema-generator.js

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaGenerator = void 0;
-const zod_1 = require("zod");
-class SchemaGenerator {
-    static generate(config) {
-        const { schema, instructions = "Output only the JSON schema, no 'triple quotes'json or any other text. Only the JSON schema.", outputExamples = [], } = config;
-        const getSchemaString = (schema) => {
-            if (schema instanceof zod_1.z.ZodObject) {
-                const entries = Object.entries(schema.shape);
-                const fields = entries.map(([key, value]) => {
-                    const description = value._def.description;
-                    const schemaStr = getSchemaString(value);
-                    return description
-                        ? `${key}: ${schemaStr} // ${description}`
-                        : `${key}: ${schemaStr}`;
-                });
-                return `z.object({${fields.join(", ")}})`;
-            }
-            if (schema instanceof zod_1.z.ZodArray) {
-                return `z.array(${getSchemaString(schema.element)})`;
-            }
-            if (schema instanceof zod_1.z.ZodString) {
-                return "z.string()";
-            }
-            if (schema instanceof zod_1.z.ZodNumber) {
-                return "z.number()";
-            }
-            if (schema instanceof zod_1.z.ZodBoolean) {
-                return "z.boolean()";
-            }
-            // Fallback for other Zod types
-            return `z.unknown()`;
-        };
-        const schemaString = getSchemaString(schema);
-        return {
-            schema: schemaString,
-            instructions,
-            outputExamples: outputExamples
-                .map((example) => `Input: ${JSON.stringify(example.input)}, Output: ${JSON.stringify(example.output)}`)
-                .join("\n")
-                .trim(),
-        };
-    }
-}
-exports.SchemaGenerator = SchemaGenerator;

package/dist/utils/state-manager.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StateManager = void 0;
-class StateManager {
-    /**
-     * Updates the shared state while preserving immutability
-     * @param currentState Current shared state
-     * @param updates Partial updates to apply
-     * @returns Updated shared state
-     */
-    static updateState(state, updates) {
-        return Object.assign(Object.assign({}, state), { context: Object.assign(Object.assign({}, (state.context || {})), updates) });
-    }
-    static createUpdate(updates) {
-        return {
-            context: Object.assign({}, updates),
-        };
-    }
-}
-exports.StateManager = StateManager;