@ai.ntellect/core 0.5.0 → 0.6.1

package/services/agenda.ts

@@ -1,25 +1,9 @@
+import { ScheduledRequest } from "@/types";
 import cron from "node-cron";
-import { Orchestrator } from "../llm/orchestrator";
-import { RedisCache } from "./cache";
-
-interface ScheduledRequest {
-  id: string;
-  originalRequest: string;
-  cronExpression: string;
-  isRecurring: boolean;
-  createdAt: Date;
-}
 
 export class Agenda {
   private scheduledRequests: Map<string, ScheduledRequest> = new Map();
   private cronJobs: Map<string, cron.ScheduledTask> = new Map();
-  private readonly orchestrator: Orchestrator;
-  private readonly cache: RedisCache;
-
-  constructor(orchestrator: Orchestrator, cache: RedisCache) {
-    this.orchestrator = orchestrator;
-    this.cache = cache;
-  }
 
   /**
    * Schedule a new request to be processed later
@@ -45,39 +29,34 @@ export class Agenda {
     };
 
     // Create cron job
-    const cronJob = cron.schedule(request.cronExpression, async () => {
-      await this.executeScheduledRequest(scheduledRequest);
+    const cronJob = cron.schedule(request.cronExpression, () => {
+      console.log(`🔄 Executing scheduled request: ${id}`);
 
-      if (callbacks?.onExecuted)
+      if (callbacks?.onExecuted) {
         callbacks.onExecuted(id, scheduledRequest.originalRequest);
+      }
+
+      console.log(`✅ Scheduled request executed successfully: ${id}`);
 
+      // Auto-stop pour les tâches non récurrentes
       if (!scheduledRequest.isRecurring) {
         this.cancelScheduledRequest(id);
       }
     });
 
+    // Démarrer le job en mode non-running
+    cronJob.stop();
+
     // Store request and job
     this.scheduledRequests.set(id, scheduledRequest);
     this.cronJobs.set(id, cronJob);
 
     if (callbacks?.onScheduled) callbacks.onScheduled(id);
 
-    return id;
-  }
+    // Démarrer le job après l'avoir stocké
+    cronJob.start();
 
-  /**
-   * Execute a scheduled request by launching a new process
-   */
-  private async executeScheduledRequest(
-    request: ScheduledRequest
-  ): Promise<void> {
-    try {
-      console.log(`🔄 Executing scheduled request from ${request.createdAt}`);
-
-      console.log(`✅ Scheduled request executed successfully`);
-    } catch (error) {
-      console.error(`❌ Failed to execute scheduled request:`, error);
-    }
+    return id;
   }
 
   /**
@@ -86,10 +65,17 @@ export class Agenda {
   cancelScheduledRequest(requestId: string): boolean {
     const cronJob = this.cronJobs.get(requestId);
     if (cronJob) {
-      cronJob.stop();
-      this.cronJobs.delete(requestId);
+      try {
+        cronJob.stop();
+        this.cronJobs.delete(requestId);
+        this.scheduledRequests.delete(requestId);
+        return true;
+      } catch (error) {
+        console.error(`Failed to stop cron job ${requestId}:`, error);
+        return false;
+      }
     }
-    return this.scheduledRequests.delete(requestId);
+    return false;
   }
 
   /**
@@ -103,11 +89,30 @@ export class Agenda {
    * Stop all cron jobs
    */
   stopAll(): void {
-    for (const [id, cronJob] of this.cronJobs) {
-      cronJob.stop();
-      this.cronJobs.delete(id);
-      this.scheduledRequests.delete(id);
+    const ids = Array.from(this.cronJobs.keys());
+
+    // Arrêter tous les jobs de manière synchrone
+    for (const id of ids) {
+      const job = this.cronJobs.get(id);
+      if (job) {
+        job.stop();
+        this.cronJobs.delete(id);
+        this.scheduledRequests.delete(id);
+      }
     }
-    console.log("All scheduled requests stopped");
+
+    // Double vérification
+    this.cronJobs.clear();
+    this.scheduledRequests.clear();
+  }
+
+  public async stop(): Promise<void> {
+    this.stopAll();
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+
+  public async cancel(query: {}): Promise<void> {
+    this.stopAll();
+    await new Promise((resolve) => setTimeout(resolve, 100));
   }
 }

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

@@ -20,38 +20,29 @@ export class Queue {
 
   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 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 Queue {
           });
           continue;
         }
-        console.log("✅ Action confirmed by user");
       }
       const parameters = this.formatArguments(action.parameters);
 
@@ -85,17 +75,14 @@ export class Queue {
     }
 
     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 Queue {
   }
 
   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 Queue {
       };
     }
 
-    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,
+      });
+    });
+  });
+});