@ai.ntellect/core 0.7.13 → 0.8.0

package/modules/nlp/engine.ts

@@ -0,0 +1,325 @@
+import { ActionHandler, NLPConfig } from "../../types";
+
+const { dockStart } = require("@nlpjs/basic");
+
+/**
+ * NLP Engine for processing natural language commands
+ * @example
+ * const engine = await NLPEngine.create({
+ *   corpus: require('./corpus.json'),
+ *   responses: require('./responses.json'),
+ *   entities: require('./entities.json')
+ * });
+ *
+ * engine.addAction('transferTokens', async (data) => {
+ *   // Handle transfer logic
+ * });
+ *
+ * const response = await engine.process('transfer 5 ETH');
+ */
+export class NLPEngine {
+  private manager: any;
+  private responses: Record<string, any>;
+  private intentHandlers: Record<string, ActionHandler> = {};
+
+  constructor() {
+    this.responses = {};
+  }
+
+  /**
+   * Creates and initializes a new NLP Engine
+   */
+  static async create(config: NLPConfig): Promise<NLPEngine> {
+    const engine = new NLPEngine();
+    await engine.init(config);
+    return engine;
+  }
+
+  /**
+   * Initializes the NLP engine with configuration
+   */
+  private async init({
+    corpus,
+    responses,
+    entities,
+    language = "en",
+    threshold = 0.5,
+  }: NLPConfig) {
+    const dock = await dockStart({
+      settings: {
+        nlp: {
+          forceNER: true,
+          languages: [language],
+          corpora: corpus ? [corpus] : undefined,
+        },
+        ner: { threshold },
+      },
+      use: ["Basic", "LangEn"],
+    });
+
+    this.manager = dock.get("nlp");
+    this.responses = responses || {};
+
+    if (corpus) {
+      await this.manager.addCorpus(corpus);
+    }
+
+    if (entities) {
+      this.registerEntities(entities);
+    }
+
+    await this.manager.train();
+  }
+
+  /**
+   * Registers entities for Named Entity Recognition (NER)
+   * @private
+   * @param {Record<string, any>} entities - Entity definitions
+   */
+  private registerEntities(entities: Record<string, any>) {
+    Object.entries(entities).forEach(([name, data]: [string, any]) => {
+      if (data.options) {
+        Object.entries(data.options).forEach(([option, texts]) => {
+          this.manager.addNerRuleOptionTexts(
+            "en",
+            name,
+            option,
+            texts as string[]
+          );
+        });
+      } else if (data.regex) {
+        this.manager.addNerRegexRule("en", name, data.regex);
+      } else if (data.trim) {
+        data.trim.forEach((trimRule: any) => {
+          if (trimRule.position === "afterLast") {
+            trimRule.words.forEach((word: string) => {
+              this.manager.addNerAfterLastCondition("en", name, word);
+            });
+          } else if (trimRule.position === "betweenLast") {
+            this.manager.addNerBetweenLastCondition(
+              "en",
+              name,
+              trimRule.leftWords,
+              trimRule.rightWords
+            );
+          }
+        });
+      }
+    });
+  }
+
+  /**
+   * Adds an action handler for a specific intent
+   * @param {string} name - Intent name
+   * @param {ActionHandler} handler - Action handler function
+   */
+  addAction(name: string, handler: ActionHandler): void {
+    this.intentHandlers[name] = handler;
+  }
+
+  /**
+   * Creates and loads a pre-trained NLP Engine
+   */
+  static async loadFromModel(
+    modelPath: string,
+    responses?: Record<string, any>
+  ): Promise<NLPEngine> {
+    const engine = new NLPEngine();
+    engine.responses = responses || {};
+    await engine.loadModel(modelPath);
+    return engine;
+  }
+
+  /**
+   * Loads a pre-trained model and configures default actions
+   */
+  private async loadModel(modelPath: string) {
+    const dock = await dockStart({
+      settings: {
+        nlp: {
+          forceNER: true,
+          languages: ["en"],
+        },
+      },
+      use: ["Basic", "LangEn"],
+    });
+
+    this.manager = dock.get("nlp");
+    await this.manager.load(modelPath);
+
+    // Configure default actions handler
+    this.setupDefaultActions();
+  }
+
+  /**
+   * Setup default actions to handle responses
+   */
+  private setupDefaultActions() {
+    this.manager.onIntent = async (data: any) => {
+      // Execute registered action if exists
+      if (data.actions?.length > 0) {
+        for (const actionData of data.actions) {
+          const result = await this.executeAction(actionData, data);
+          if (result) {
+            data.actionResult = result;
+          }
+        }
+      }
+
+      // Format response if answer exists
+      if (data.answer && this.responses[data.answer]) {
+        data.jsonResponse = this.formatResponse(
+          this.responses[data.answer],
+          data.actionResult || {}
+        );
+      }
+
+      return data;
+    };
+  }
+
+  /**
+   * Execute a single action
+   */
+  private async executeAction(actionData: any, context: any): Promise<any> {
+    const { action, parameters } = actionData;
+    const handler = this.manager.actions[action];
+    if (handler) {
+      return handler(context);
+    }
+    return null;
+  }
+
+  /**
+   * Processes natural language input text
+   * @param {string} input - Input text to process
+   * @returns {Promise<any>} Processing result with intent, entities and response
+   */
+  async process(input: string) {
+    const result = await this.manager.process("en", input);
+    console.log("NLP Engine Result:", result);
+
+    // Si une action est définie, exécuter le handler
+    if (result.intent) {
+      const handler = this.intentHandlers[result.intent.split(".")[1]];
+      if (handler) {
+        const handlerResult = await handler(result);
+        return {
+          ...result,
+          ...handlerResult,
+        };
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Trains the NLP model with current corpus
+   * @returns {Promise<void>}
+   */
+  public async train(): Promise<void> {
+    await this.manager.train();
+  }
+
+  /**
+   * Exports the trained model
+   * @param {boolean} [minified=true] - Whether to minify the exported model
+   * @returns {string} Exported model as string
+   */
+  public export(minified = true): string {
+    return this.manager.export(minified);
+  }
+
+  /**
+   * Imports a previously trained model
+   * @param {string} data - Model data to import
+   */
+  public import(data: string): void {
+    this.manager.import(data);
+  }
+
+  /**
+   * Saves the current model to a file
+   * @param {string} [path='./model.json'] - Path to save the model
+   * @returns {Promise<void>}
+   */
+  public async saveModel(path = "./model.json"): Promise<void> {
+    this.manager.save();
+    this.manager.save("./model.json");
+  }
+
+  /**
+   * Formats response using template and context
+   */
+  private formatResponse(template: any, context: any): any {
+    const response = JSON.parse(JSON.stringify(template));
+
+    // Format data fields
+    if (response.data) {
+      Object.keys(response.data).forEach((key) => {
+        if (context[key] !== undefined) {
+          response.data[key] = context[key];
+        }
+      });
+    }
+
+    return response;
+  }
+
+  /**
+   * Gets entity value from NLP result
+   * @param {any} data - NLP processing result
+   * @param {string} entityName - Name of the entity to extract
+   * @returns {string|undefined} Entity value if found
+   */
+  getEntity(data: any, entityName: string): string | undefined {
+    const entity = data.entities?.find((e: any) => e.entity === entityName);
+    return entity ? entity.utteranceText : undefined;
+  }
+
+  /**
+   * Gets entity option from NLP result
+   * @param {any} data - NLP processing result
+   * @param {string} entityName - Name of the entity to extract
+   * @returns {string|undefined} Entity option if found
+   */
+  getEntityOption(data: any, entityName: string): string | undefined {
+    const entity = data.entities?.find((e: any) => e.entity === entityName);
+    return entity ? entity.option : undefined;
+  }
+
+  /**
+   * Gets recipient entity from NLP result
+   * @param {any} data - NLP processing result
+   * @returns {string|undefined} Recipient value if found
+   */
+  getRecipient(data: any): string | undefined {
+    const toEntity = data.entities?.find((e: any) => e.entity === "to");
+    return toEntity ? toEntity.utteranceText : undefined;
+  }
+
+  /**
+   * Gets current responses configuration
+   * @returns {Record<string, any>} Current responses
+   */
+  public getResponses(): Record<string, any> {
+    return this.responses;
+  }
+
+  /**
+   * Gets current corpus configuration
+   * @returns {any} Current corpus
+   */
+  public getCorpus(): any {
+    return this.manager.corpora;
+  }
+
+  /**
+   * Gets current entities configuration
+   * @returns {any} Current entities configuration
+   */
+  public getEntities(): any {
+    return this.manager.nerManager?.rules || {};
+  }
+}

package/modules/nlp/index.ts

@@ -0,0 +1,45 @@
+import { NLPNodeConfig } from "@/interfaces";
+import { ZodSchema } from "zod";
+import { NLPEngine } from "./engine";
+
+/**
+ * NLPNode class handles natural language processing operations with type-safe schema validation
+ * @template T - Zod schema type for validation
+ */
+export class NLPNode<T extends ZodSchema> {
+  private engine!: NLPEngine;
+
+  /**
+   * Creates an instance of NLPNode
+   * @param {NLPNodeConfig<T>} config - Configuration object for the NLP node
+   */
+  constructor(private config: NLPNodeConfig<T>) {}
+
+  /**
+   * Initializes the NLP engine and sets up intent handlers
+   * @returns {Promise<void>}
+   */
+  async initialize() {
+    this.engine = await NLPEngine.create(this.config.nlpConfig);
+    console.log("Loaded engine");
+    if (this.config.intentHandlers) {
+      Object.entries(this.config.intentHandlers).forEach(
+        ([intent, handler]) => {
+          this.engine.addAction(intent, handler);
+        }
+      );
+    }
+  }
+
+  /**
+   * Processes the input text through the NLP engine
+   * @param {string} input - Text to be processed
+   * @returns {Promise<any>} - Processing result from the engine
+   */
+  async process(input: string) {
+    console.log("NLP Node processing:", input);
+    const result = await this.engine.process(input);
+    console.log("NLP Node result:", result);
+    return result;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai.ntellect/core",
-  "version": "0.7.13",
+  "version": "0.8.0",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -17,8 +17,11 @@
   "author": "Lorcann Rauzduel",
   "license": "ISC",
   "dependencies": {
+    "@ai-sdk/openai": "^1.1.15",
+    "@nlpjs/basic": "5.0.0-alpha.5",
     "@types/node-cron": "^3.0.11",
-    "ai": "^3.0.0",
+    "ai": "^4.1.46",
+    "chalk": "^5.4.1",
     "node-cron": "^3.0.3",
     "redis": "^4.7.0",
     "rxjs": "^7.8.1",

package/test/graph/controller.test.ts

@@ -56,12 +56,14 @@ describe("GraphController", () => {
       );
 
       expect(results).to.have.length(3);
-      expect(results[0].counter).to.equal(10);
-      expect(results[1].counter).to.equal(20);
-      expect(results[2].counter).to.equal(30);
-      expect(results[0].message).to.equal("test1-graph1");
-      expect(results[1].message).to.equal("test2-graph2");
-      expect(results[2].message).to.equal("test3-graph3");
+      expect(results[0].context.counter).to.equal(10);
+      expect(results[1].context.counter).to.equal(20);
+      expect(results[2].context.counter).to.equal(30);
+      expect(results[0].context.message).to.equal("test1-graph1");
+      expect(results[1].context.message).to.equal("test2-graph2");
+      expect(results[2].context.message).to.equal("test3-graph3");
+      expect(results[0].graphName).to.equal("graph1");
+      expect(results[0].nodeName).to.equal("start");
     });
 
     it("should handle missing params and params gracefully", async () => {
@@ -74,10 +76,10 @@ describe("GraphController", () => {
       );
 
       expect(results).to.have.length(2);
-      expect(results[0].counter).to.equal(0);
-      expect(results[1].counter).to.equal(0);
-      expect(results[0].message).to.equal("graph1");
-      expect(results[1].message).to.equal("graph2");
+      expect(results[0].context.counter).to.equal(0);
+      expect(results[1].context.counter).to.equal(0);
+      expect(results[0].context.message).to.equal("graph1");
+      expect(results[1].context.message).to.equal("graph2");
     });
   });
 
@@ -111,8 +113,8 @@ describe("GraphController", () => {
       expect(executionTime).to.be.greaterThan(0);
       expect(results).to.have.length(5);
       results.forEach((result, i) => {
-        expect(result.counter).to.equal((i + 1) * 10);
-        expect(result.message).to.equal(`test${i + 1}-graph${i + 1}`);
+        expect(result.context.counter).to.equal((i + 1) * 10);
+        expect(result.context.message).to.equal(`test${i + 1}-graph${i + 1}`);
       });
     });
 
@@ -175,8 +177,10 @@ describe("GraphController", () => {
 
       const allResults = [...parallelResults, ...sequentialResults];
       expect(allResults).to.have.length(4);
-      expect(allResults.map((r) => r.counter)).to.deep.equal([10, 20, 30, 40]);
-      expect(allResults.map((r) => r.message)).to.deep.equal([
+      expect(allResults.map((r) => r.context.counter)).to.deep.equal([
+        10, 20, 30, 40,
+      ]);
+      expect(allResults.map((r) => r.context.message)).to.deep.equal([
         "parallel1-graph1",
         "parallel2-graph2",
         "seq1-graph3",

package/test/graph/index.test.ts

@@ -6,7 +6,7 @@ import { z } from "zod";
 import { GraphController } from "../../graph/controller";
 import { GraphFlow } from "../../graph/index";
 import { NodeParams } from "../../graph/node";
-import { GraphContext, GraphConfig, GraphNodeConfig } from "../../types";
+import { GraphConfig, GraphContext, GraphNodeConfig } from "../../types";
 
 use(chaiAsPromised);
 
@@ -540,8 +540,8 @@ describe("GraphFlow", function () {
       [{}, {}]
     );
 
-    expect(results[0].value).to.equal(2); // Graph1: 1 * 2
-    expect(results[1].value).to.equal(5); // Graph2: 2 + 3
+    expect(results[0].context.value).to.equal(2); // Graph1: 1 * 2
+    expect(results[1].context.value).to.equal(5); // Graph2: 2 + 3
   });
 
   /**
@@ -587,22 +587,24 @@ describe("GraphFlow", function () {
       [{}, {}]
     );
 
-    expect(results[0].value).to.equal(2); // Graph1: 1 * 2
-    expect(results[1].value).to.equal(5); // Graph2: 3 + 2
+    expect(results[0].context.value).to.equal(2); // Graph1: 1 * 2
+    expect(results[1].context.value).to.equal(5); // Graph2: 3 + 2
   });
 
   /**
    * Tests single event waiting functionality
    */
   it("should wait for a single event before continuing", async function () {
-    this.timeout(5000);
-
     const waitingNode: GraphNodeConfig<TestSchema> = {
       name: "waitingNode",
       execute: async (context: GraphContext<typeof TestSchema>) => {
         context.value = 1;
       },
-      waitForEvent: true,
+      when: {
+        events: ["someEvent"],
+        timeout: 1000,
+        strategy: { type: "single" },
+      },
       next: ["finalNode"],
     };
 

package/test/graph/node.test.ts

@@ -512,10 +512,10 @@ describe("GraphNode", () => {
     const nodes = new Map();
     nodes.set("waitForEventsNode", {
       name: "waitForEventsNode",
-      waitForEvents: {
+      when: {
         events: ["event1", "event2"],
         timeout: 1000,
-        strategy: "all",
+        strategy: { type: "all" },
       },
       execute: async (context: TestContext) => {
         context.message = "Events received";
@@ -554,10 +554,10 @@ describe("GraphNode", () => {
     const nodes = new Map();
     nodes.set("timeoutNode", {
       name: "timeoutNode",
-      waitForEvents: {
+      when: {
         events: ["event1", "event2"],
         timeout: 100,
-        strategy: "all",
+        strategy: { type: "all" },
       },
       execute: async (context: TestContext) => {
         context.message = "Should not execute";
@@ -571,7 +571,6 @@ describe("GraphNode", () => {
       eventSubject,
       stateSubject
     );
-
     await expect(
       node.executeNode("timeoutNode", { counter: 0, message: "Hello" }, null)
     ).to.be.rejectedWith("Timeout waiting for events");
@@ -581,10 +580,10 @@ describe("GraphNode", () => {
     const nodes = new Map();
     nodes.set("partialEventsNode", {
       name: "partialEventsNode",
-      waitForEvents: {
+      when: {
         events: ["event1", "event2"],
         timeout: 1000,
-        strategy: "all",
+        strategy: { type: "all" },
       },
       execute: async (context: TestContext) => {
         context.message = "All events received";
@@ -598,14 +597,12 @@ describe("GraphNode", () => {
       eventSubject,
       stateSubject
     );
-
     const execution = node.executeNode(
       "partialEventsNode",
       { counter: 0, message: "Hello" },
       null
     );
 
-    // N'émettre qu'un seul événement
     setTimeout(() => {
       eventEmitter.emit("event1", { data: "test1" });
     }, 100);
@@ -617,13 +614,20 @@ describe("GraphNode", () => {
     const nodes = new Map();
     nodes.set("correlatedEventsNode", {
       name: "correlatedEventsNode",
-      correlateEvents: {
+      when: {
         events: ["payment", "stock"],
         timeout: 1000,
-        correlation: (events: Array<{ type: string; payload?: any }>) => {
-          const paymentEvent = events.find((e) => e.type === "payment");
-          const stockEvent = events.find((e) => e.type === "stock");
-          return paymentEvent?.payload?.id === stockEvent?.payload?.id;
+        strategy: {
+          type: "correlate",
+          correlation: (events: Array<{ type: string; payload?: any }>) => {
+            const paymentEvent = events.find(
+              (e: { type: string }) => e.type === "payment"
+            );
+            const stockEvent = events.find(
+              (e: { type: string }) => e.type === "stock"
+            );
+            return paymentEvent?.payload?.id === stockEvent?.payload?.id;
+          },
         },
       },
       execute: (context: TestContext) => {