@ai.ntellect/core 0.5.0 → 0.6.0

package/dist/services/queue.js

@@ -1,7 +1,16 @@
 "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 });
-exports.ActionQueueManager = void 0;
-class ActionQueueManager {
+exports.Queue = void 0;
+class Queue {
     constructor(actions, callbacks = {}) {
         this.queue = [];
         this.results = [];
@@ -9,78 +18,70 @@ class ActionQueueManager {
         this.actions = actions;
         this.callbacks = callbacks;
     }
-    addToQueue(actions) {
+    add(actions) {
         if (Array.isArray(actions)) {
-            console.log("\n📋 Adding actions to queue:");
-            actions.forEach((action, index) => {
-                console.log(`   ${index + 1}. ${action.name}`);
-            });
             this.queue.push(...actions);
         }
         else {
-            console.log("\n📋 Adding single action to queue:", actions.name);
             this.queue.push(actions);
         }
     }
-    async processQueue() {
-        if (this.isProcessing) {
-            console.log("\n⚠️  Queue is already being processed");
-            return;
-        }
-        console.log("\n🔄 Starting queue processing");
-        this.isProcessing = true;
-        const actionPromises = [];
-        for (const action of this.queue) {
-            const actionConfig = this.actions.find((a) => a.name === action.name);
-            if (actionConfig?.confirmation?.requireConfirmation) {
-                console.log("\n🔒 Action requires confirmation:", action.name);
-                const shouldProceed = await this.callbacks.onConfirmationRequired?.(actionConfig.confirmation.message ||
-                    `Do you want to proceed with action: ${action.name}?`);
-                if (!shouldProceed) {
-                    console.log("❌ Action cancelled by user:", action.name);
-                    this.results.push({
+    execute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e;
+            if (this.isProcessing) {
+                return;
+            }
+            this.isProcessing = true;
+            const actionPromises = [];
+            for (const action of this.queue) {
+                const actionConfig = this.actions.find((a) => a.name === action.name);
+                if ((_a = actionConfig === null || actionConfig === void 0 ? void 0 : actionConfig.confirmation) === null || _a === void 0 ? void 0 : _a.requireConfirmation) {
+                    const shouldProceed = yield ((_c = (_b = this.callbacks).onConfirmationRequired) === null || _c === void 0 ? void 0 : _c.call(_b, actionConfig.confirmation.message ||
+                        `Do you want to proceed with action: ${action.name}?`));
+                    if (!shouldProceed) {
+                        this.results.push({
+                            name: action.name,
+                            parameters: this.formatArguments(action.parameters),
+                            result: null,
+                            error: "Action cancelled by user",
+                            cancelled: true,
+                        });
+                        continue;
+                    }
+                }
+                const parameters = this.formatArguments(action.parameters);
+                actionPromises.push(this.executeAction(action)
+                    .then((result) => {
+                    var _a, _b;
+                    (_b = (_a = this.callbacks).onActionComplete) === null || _b === void 0 ? void 0 : _b.call(_a, result);
+                    return result;
+                })
+                    .catch((error) => {
+                    var _a, _b;
+                    const result = {
                         name: action.name,
-                        parameters: this.formatArguments(action.parameters),
+                        parameters,
                         result: null,
-                        error: "Action cancelled by user",
-                        cancelled: true,
-                    });
-                    continue;
-                }
-                console.log("✅ Action confirmed by user");
+                        error: error.message || "Unknown error occurred",
+                    };
+                    (_b = (_a = this.callbacks).onActionComplete) === null || _b === void 0 ? void 0 : _b.call(_a, result);
+                    return result;
+                }));
             }
-            const parameters = this.formatArguments(action.parameters);
-            actionPromises.push(this.executeAction(action)
-                .then((result) => {
-                this.callbacks.onActionComplete?.(result);
-                return result;
-            })
-                .catch((error) => {
-                const result = {
-                    name: action.name,
-                    parameters,
-                    result: null,
-                    error: error.message || "Unknown error occurred",
-                };
-                this.callbacks.onActionComplete?.(result);
-                return result;
-            }));
-        }
-        try {
-            console.log("\n⏳ Waiting for all actions to complete...");
-            const results = await Promise.all(actionPromises);
-            this.results.push(...results);
-            this.queue = [];
-            this.callbacks.onQueueComplete?.(this.results);
-            this.isProcessing = false;
-            console.log("\n✅ Queue processing completed successfully");
-            return this.results;
-        }
-        catch (error) {
-            this.isProcessing = false;
-            console.error("\n❌ Unexpected error in queue processing:", error);
-            throw error;
-        }
+            try {
+                const results = yield Promise.all(actionPromises);
+                this.results.push(...results);
+                this.queue = [];
+                (_e = (_d = this.callbacks).onQueueComplete) === null || _e === void 0 ? void 0 : _e.call(_d, this.results);
+                this.isProcessing = false;
+                return this.results;
+            }
+            catch (error) {
+                this.isProcessing = false;
+                throw error;
+            }
+        });
     }
     formatArguments(args) {
         return args.reduce((acc, arg) => {
@@ -97,50 +98,45 @@ class ActionQueueManager {
                     acc[arg.name] = arg.value;
                 }
             }
-            catch {
+            catch (_a) {
                 // If JSON parsing fails, use the original value
                 acc[arg.name] = arg.value;
             }
             return acc;
         }, {});
     }
-    async executeAction(action) {
-        console.log("\n🎯 Executing action:", action.name);
-        this.callbacks.onActionStart?.(action);
-        const actionConfig = this.actions.find((a) => a.name === action.name);
-        if (!actionConfig) {
-            console.error("❌ Action not found:", action.name);
-            return {
-                name: action.name,
-                parameters: {},
-                result: null,
-                error: `Action '${action.name}' not found in actions list`,
-            };
-        }
-        console.log("📝 Action parameters:", JSON.stringify(action.parameters, null, 2));
-        const actionArgs = this.formatArguments(action.parameters);
-        try {
-            const result = await actionConfig.execute(actionArgs);
-            const actionResult = {
-                name: action.name,
-                parameters: actionArgs,
-                result,
-                error: null,
-            };
-            console.log(`\n✨ Action "${action.name}" completed successfully`);
-            return actionResult;
-        }
-        catch (error) {
-            const actionResult = {
-                name: action.name,
-                parameters: actionArgs,
-                result: null,
-                error: error.message || "Unknown error occurred",
-            };
-            console.error(`\n❌ Action "${action.name}" failed:`, error);
-            console.log("Failed action details:", JSON.stringify(actionResult, null, 2));
-            return actionResult;
-        }
+    executeAction(action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            (_b = (_a = this.callbacks).onActionStart) === null || _b === void 0 ? void 0 : _b.call(_a, action);
+            const actionConfig = this.actions.find((a) => a.name === action.name);
+            if (!actionConfig) {
+                return {
+                    name: action.name,
+                    parameters: {},
+                    result: null,
+                    error: `Action '${action.name}' not found in actions list`,
+                };
+            }
+            const actionArgs = this.formatArguments(action.parameters);
+            try {
+                const result = yield actionConfig.execute(actionArgs);
+                return {
+                    name: action.name,
+                    parameters: actionArgs,
+                    result,
+                    error: null,
+                };
+            }
+            catch (error) {
+                return {
+                    name: action.name,
+                    parameters: actionArgs,
+                    result: null,
+                    error: error.message || "Unknown error occurred",
+                };
+            }
+        });
     }
 }
-exports.ActionQueueManager = ActionQueueManager;
+exports.Queue = Queue;

package/dist/test/graph/controller.test.js

@@ -0,0 +1,170 @@
+"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 controller_1 = require("@/graph/controller");
+const chai_1 = require("chai");
+const zod_1 = require("zod");
+describe("Controller", () => {
+    // Define test schema
+    const TestSchema = zod_1.z.object({
+        status: zod_1.z.string(),
+        count: zod_1.z.number(),
+    });
+    // Sample workflow definitions
+    const simpleWorkflow = {
+        name: "simple-workflow",
+        entryNode: "start",
+        nodes: {
+            start: {
+                name: "start",
+                execute: (_params, state) => __awaiter(void 0, void 0, void 0, function* () {
+                    return ({
+                        context: Object.assign(Object.assign({}, state.context), { status: "completed", count: state.context.count + 1 }),
+                    });
+                }),
+                relationships: [],
+            },
+        },
+        schema: TestSchema,
+    };
+    const complexWorkflow = {
+        name: "complex-workflow",
+        entryNode: "first",
+        nodes: {
+            first: {
+                name: "first",
+                execute: (_params, state) => __awaiter(void 0, void 0, void 0, function* () {
+                    return ({
+                        context: Object.assign(Object.assign({}, state.context), { status: "step1", count: state.context.count + 2 }),
+                    });
+                }),
+                relationships: [],
+            },
+        },
+        schema: TestSchema,
+    };
+    let controller;
+    beforeEach(() => {
+        controller = new controller_1.GraphController();
+    });
+    describe("Basic Execution", () => {
+        it("should execute a single workflow successfully", () => __awaiter(void 0, void 0, void 0, function* () {
+            const actions = [
+                {
+                    name: "simple-workflow",
+                    parameters: [
+                        { name: "status", value: "initial" },
+                        { name: "count", value: 0 },
+                    ],
+                },
+            ];
+            const result = yield controller.run(actions, [simpleWorkflow]);
+            (0, chai_1.expect)(result.context).to.deep.equal({
+                status: "completed",
+                count: 1,
+            });
+        }));
+        it("should handle multiple workflows", () => __awaiter(void 0, void 0, void 0, function* () {
+            const actions = [
+                {
+                    name: "complex-workflow",
+                    parameters: [
+                        { name: "status", value: "initial" },
+                        { name: "count", value: 0 },
+                    ],
+                },
+            ];
+            const result = yield controller.run(actions, [
+                simpleWorkflow,
+                complexWorkflow,
+            ]);
+            (0, chai_1.expect)(result.context).to.deep.equal({
+                status: "step1",
+                count: 2,
+            });
+        }));
+    });
+    describe("Error Handling", () => {
+        it("should throw error when no actions provided", () => __awaiter(void 0, void 0, void 0, function* () {
+            try {
+                yield controller.run([], [simpleWorkflow]);
+                chai_1.expect.fail("Should have thrown an error");
+            }
+            catch (error) {
+                (0, chai_1.expect)(error.message).to.equal("No actions provided");
+            }
+        }));
+        it("should throw error when workflow not found", () => __awaiter(void 0, void 0, void 0, function* () {
+            const actions = [
+                {
+                    name: "non-existent-workflow",
+                    parameters: [
+                        { name: "status", value: "initial" },
+                        { name: "count", value: 0 },
+                    ],
+                },
+            ];
+            try {
+                yield controller.run(actions, [simpleWorkflow]);
+                chai_1.expect.fail("Should have thrown an error");
+            }
+            catch (error) {
+                (0, chai_1.expect)(error.message).to.equal("Graph not found: non-existent-workflow");
+            }
+        }));
+    });
+    describe("Parameter Handling", () => {
+        it("should correctly process workflow parameters", () => __awaiter(void 0, void 0, void 0, function* () {
+            const actions = [
+                {
+                    name: "simple-workflow",
+                    parameters: [
+                        { name: "status", value: "custom-initial" },
+                        { name: "count", value: 10 },
+                    ],
+                },
+            ];
+            const result = yield controller.run(actions, [simpleWorkflow]);
+            (0, chai_1.expect)(result.context).to.deep.equal({
+                status: "completed",
+                count: 11,
+            });
+        }));
+    });
+    describe("Multiple Actions", () => {
+        it("should process the first action only", () => __awaiter(void 0, void 0, void 0, function* () {
+            const actions = [
+                {
+                    name: "simple-workflow",
+                    parameters: [
+                        { name: "status", value: "initial" },
+                        { name: "count", value: 0 },
+                    ],
+                },
+                {
+                    name: "complex-workflow",
+                    parameters: [
+                        { name: "status", value: "initial" },
+                        { name: "count", value: 5 },
+                    ],
+                },
+            ];
+            const result = yield controller.run(actions, [
+                simpleWorkflow,
+                complexWorkflow,
+            ]);
+            (0, chai_1.expect)(result.context).to.deep.equal({
+                status: "completed",
+                count: 1,
+            });
+        }));
+    });
+});