@ai.ntellect/core 0.4.1 → 0.6.0

package/services/embedding.ts

@@ -0,0 +1,26 @@
+import { EmbeddingService } from "@/interfaces";
+import { cosineSimilarity, embed, EmbeddingModel, embedMany } from "ai";
+
+export class AIEmbeddingService implements EmbeddingService {
+  constructor(private readonly model: EmbeddingModel<string>) {}
+
+  async embedText(text: string): Promise<number[]> {
+    const { embedding } = await embed({
+      model: this.model,
+      value: text,
+    });
+    return embedding;
+  }
+
+  async embedMany(texts: string[]): Promise<number[][]> {
+    const { embeddings } = await embedMany({
+      model: this.model,
+      values: texts,
+    });
+    return embeddings;
+  }
+
+  calculateSimilarity(embedding1: number[], embedding2: number[]): number {
+    return (cosineSimilarity(embedding1, embedding2) + 1) * 50;
+  }
+}

package/services/queue.ts

@@ -6,7 +6,7 @@ import {
   QueueResult,
 } from "../types";
 
-export class ActionQueueManager {
+export class Queue {
   private queue: QueueItem[] = [];
   private results: QueueResult[] = [];
   private callbacks: QueueCallbacks;
@@ -18,40 +18,31 @@ export class ActionQueueManager {
     this.callbacks = callbacks;
   }
 
-  addToQueue(actions: QueueItem | QueueItem[]) {
+  add(actions: QueueItem | QueueItem[]) {
     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() {
+  async execute() {
     if (this.isProcessing) {
-      console.log("\n⚠️  Queue is already being processed");
       return;
     }
 
-    console.log("\n🔄 Starting queue processing");
     this.isProcessing = true;
     const actionPromises: Promise<QueueResult>[] = [];
 
     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({
             name: action.name,
             parameters: this.formatArguments(action.parameters),
@@ -61,7 +52,6 @@ export class ActionQueueManager {
           });
           continue;
         }
-        console.log("✅ Action confirmed by user");
       }
       const parameters = this.formatArguments(action.parameters);
 
@@ -85,17 +75,14 @@ export class ActionQueueManager {
     }
 
     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;
     }
   }
@@ -124,12 +111,10 @@ export class ActionQueueManager {
   }
 
   private async executeAction(action: QueueItem): Promise<QueueResult> {
-    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: {},
@@ -138,35 +123,23 @@ export class ActionQueueManager {
       };
     }
 
-    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 = {
+      return {
         name: action.name,
         parameters: actionArgs,
         result,
         error: null,
       };
-      console.log(`\n✨ Action "${action.name}" completed successfully`);
-      return actionResult;
     } catch (error) {
-      const actionResult = {
+      return {
         name: action.name,
         parameters: actionArgs,
         result: null,
         error: (error as 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;
     }
   }
 }

package/test/.env.test

@@ -0,0 +1,4 @@
+MEILISEARCH_HOST=http://localhost:7700
+MEILISEARCH_API_KEY=aSampleMasterKey
+REDIS_URL=redis://localhost:6379
+REDIS_TEST_DB=1 

package/test/graph/controller.test.ts

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