@ai.ntellect/core 0.6.10 → 0.6.12

package/dist/graph/engine.js

@@ -1,634 +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());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GraphEngine = void 0;
-const events_1 = __importDefault(require("events"));
-const zod_1 = require("zod");
-/**
- * Représente un workflow dirigé capable d’exécuter des noeuds en séquence ou en parallèle.
- *
- * @template T - Le type de données stockées dans le contexte du workflow
- */
-class GraphEngine {
-    /**
-     * Crée une nouvelle instance de GraphEngine.
-     *
-     * @param {GraphDefinition<T>} [definition] - La définition initiale du workflow
-     * @param {GraphOptions<T>} [options] - Options de configuration
-     */
-    constructor(definition, options) {
-        this.name = (definition === null || definition === void 0 ? void 0 : definition.name) || "anonymous";
-        this.eventEmitter = new events_1.default();
-        this.globalContext = new Map();
-        this.nodes = new Map();
-        this.executedNodes = new Set();
-        this.persistence = null;
-        this.notifier = null;
-        this.schema = options === null || options === void 0 ? void 0 : options.schema;
-        this.currentState = {};
-        if (definition) {
-            this.loadFromDefinition(definition);
-        }
-        if ((options === null || options === void 0 ? void 0 : options.autoDetectCycles) && this.checkForCycles()) {
-            throw new Error("Cycle détecté dans le workflow");
-        }
-        if (options === null || options === void 0 ? void 0 : options.initialState) {
-            // this.setState(options.initialState);
-        }
-    }
-    /**
-     * Ajoute un élément au contexte global.
-     * @param {string} key - La clé
-     * @param {any} value - La valeur
-     */
-    addToContext(key, value) {
-        this.globalContext.set(key, value);
-    }
-    /**
-     * Récupère un élément du contexte global.
-     * @param {string} key - La clé
-     */
-    getContext(key) {
-        return this.globalContext.get(key);
-    }
-    /**
-     * Supprime un élément du contexte global.
-     * @param {string} key - La clé
-     */
-    removeFromContext(key) {
-        this.globalContext.delete(key);
-    }
-    /**
-     * Définit la couche de persistance.
-     * @param {Persistence<T>} persistence
-     */
-    setPersistence(persistence) {
-        this.persistence = persistence;
-    }
-    /**
-     * Définit le notifier en temps réel.
-     * @param {RealTimeNotifier} notifier
-     */
-    setNotifier(notifier) {
-        this.notifier = notifier;
-    }
-    /**
-     * Charge un workflow à partir d'une définition.
-     * @private
-     * @param {GraphDefinition<T>} definition
-     */
-    loadFromDefinition(definition) {
-        Object.entries(definition.nodes).forEach(([_, nodeConfig]) => {
-            this.addNode(nodeConfig);
-        });
-    }
-    /**
-     * Vérifie récursivement s’il existe un cycle dans le workflow.
-     * @param {string} nodeName
-     * @param {Set<string>} visited
-     * @param {Set<string>} recStack
-     * @returns {boolean}
-     */
-    isCyclic(nodeName, visited, recStack) {
-        if (!visited.has(nodeName)) {
-            visited.add(nodeName);
-            recStack.add(nodeName);
-            const currentNode = this.nodes.get(nodeName);
-            if (currentNode === null || currentNode === void 0 ? void 0 : currentNode.relationships) {
-                for (const relation of currentNode.relationships) {
-                    const targetNode = relation.name;
-                    if (!visited.has(targetNode) &&
-                        this.isCyclic(targetNode, visited, recStack)) {
-                        return true;
-                    }
-                    else if (recStack.has(targetNode)) {
-                        return true;
-                    }
-                }
-            }
-        }
-        recStack.delete(nodeName);
-        return false;
-    }
-    /**
-     * Vérifie si le workflow contient des cycles.
-     * @returns {boolean}
-     */
-    checkForCycles() {
-        const visited = new Set();
-        const recStack = new Set();
-        for (const nodeName of this.nodes.keys()) {
-            if (this.isCyclic(nodeName, visited, recStack)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Ajoute un nouveau nœud au workflow.
-     * @param {Node<T>} node
-     */
-    addNode(node) {
-        if (node.relationships) {
-            node.relationships.forEach((relationship) => {
-                var _a, _b;
-                (_b = (_a = this.nodes.get(relationship.name)) === null || _a === void 0 ? void 0 : _a.relationships) === null || _b === void 0 ? void 0 : _b.push(relationship);
-            });
-        }
-        if (node.events) {
-            node.events.forEach((event) => {
-                this.eventEmitter.on(event, (data) => __awaiter(this, void 0, void 0, function* () {
-                    const state = data.state || {};
-                    yield this.execute(state, node.name);
-                }));
-            });
-        }
-        this.nodes.set(node.name, node);
-    }
-    /**
-     * Émet un événement sur l'event emitter du workflow.
-     * @param {string} eventName
-     * @param {any} data
-     */
-    emit(eventName, data) {
-        this.eventEmitter.emit(eventName, data);
-    }
-    /**
-     * Ajoute un sous-graph (GraphEngine) comme un nœud dans le workflow courant.
-     * @param {GraphEngine<T>} subGraph
-     * @param {string} entryNode - Le nom du nœud de démarrage dans le sous-graph
-     * @param {string} name - Le nom symbolique à donner au sous-graph
-     */
-    addSubGraph(subGraph, entryNode, name) {
-        const subGraphNode = {
-            name: name,
-            execute: (state) => __awaiter(this, void 0, void 0, function* () {
-                yield subGraph.execute(state, entryNode);
-                return state;
-            }),
-        };
-        this.nodes.set(name, subGraphNode);
-    }
-    /**
-     * Exécute le workflow à partir d’un nœud donné.
-     * @param {SharedState<T>} state
-     * @param {string} startNode
-     * @param {(state: SharedState<T>) => void} [onStream] - Callback sur l’évolution de l’état
-     * @param {(error: Error, nodeName: string, state: SharedState<T>) => void} [onError] - Callback sur erreur
-     */
-    execute(state, startNode, onStream, onError) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            try {
-                // Valide l'état initial via le schéma global (si défini)
-                if (this.schema) {
-                    try {
-                        this.schema.parse(state);
-                    }
-                    catch (error) {
-                        const validationError = new Error(`Échec de la validation de l'état initial: ${error instanceof Error ? error.message : error}`);
-                        if (onError)
-                            onError(validationError, startNode, state);
-                        throw validationError;
-                    }
-                }
-                this.setState(state);
-                let currentNodeName = startNode;
-                while (currentNodeName) {
-                    this.executedNodes.add(currentNodeName);
-                    const currentNode = this.nodes.get(currentNodeName);
-                    if (!currentNode) {
-                        throw new Error(`Node ${currentNodeName} introuvable.`);
-                    }
-                    // Vérification de condition (si présente)
-                    if (currentNode.condition &&
-                        !currentNode.condition(this.currentState)) {
-                        break;
-                    }
-                    try {
-                        // Notifier : début d'exécution du nœud
-                        if (this.notifier) {
-                            this.notifier.notify("nodeExecutionStarted", {
-                                workflow: this.name,
-                                node: currentNodeName,
-                            });
-                        }
-                        const newState = yield currentNode.execute(this.currentState);
-                        if (newState) {
-                            this.setState(newState);
-                            if (onStream)
-                                onStream(this);
-                        }
-                        // Sauvegarde via la persistence (optionnel)
-                        if (this.persistence) {
-                            yield this.persistence.saveState(this.name, this.currentState, currentNodeName);
-                        }
-                        // Notifier : fin d'exécution du nœud
-                        if (this.notifier) {
-                            yield this.notifier.notify("nodeExecutionCompleted", {
-                                workflow: this.name,
-                                node: currentNodeName,
-                                state: this.currentState,
-                            });
-                        }
-                    }
-                    catch (error) {
-                        if (onError) {
-                            onError(error, currentNodeName, this.currentState);
-                        }
-                        if (this.notifier) {
-                            this.notifier.notify("nodeExecutionFailed", {
-                                workflow: this.name,
-                                node: currentNodeName,
-                                state: this.currentState,
-                                error,
-                            });
-                        }
-                        break;
-                    }
-                    // Gestion des relations (branchements)
-                    const relationsNodes = currentNode.relationships || [];
-                    if (relationsNodes.length > 1) {
-                        // Exécution parallèle des branches
-                        yield Promise.all(relationsNodes.map((relation) => this.execute(this.currentState, relation.name, onStream, onError)));
-                        // Après exécution en parallèle, on arrête la boucle
-                        break;
-                    }
-                    else {
-                        // Cas normal : un seul chemin
-                        currentNodeName = ((_a = relationsNodes[0]) === null || _a === void 0 ? void 0 : _a.name) || "";
-                    }
-                }
-                return this.getState();
-            }
-            catch (error) {
-                if (onError) {
-                    onError(error, startNode, state);
-                }
-                throw error;
-            }
-        });
-    }
-    /**
-     * Exécute plusieurs nœuds en parallèle au sein du même workflow, avec une limite de concurrence.
-     * @param {SharedState<T>} state
-     * @param {string[]} nodeNames
-     * @param {number} [concurrencyLimit=5]
-     */
-    executeParallel(state_1, nodeNames_1) {
-        return __awaiter(this, arguments, void 0, function* (state, nodeNames, concurrencyLimit = 5, onStream, onError) {
-            const executeWithLimit = (nodeName) => __awaiter(this, void 0, void 0, function* () {
-                yield this.execute(state, nodeName, onStream, onError);
-            });
-            const chunks = [];
-            for (let i = 0; i < nodeNames.length; i += concurrencyLimit) {
-                chunks.push(nodeNames.slice(i, i + concurrencyLimit));
-            }
-            for (const chunk of chunks) {
-                yield Promise.all(chunk.map(executeWithLimit));
-            }
-        });
-    }
-    /**
-     * Met à jour le workflow avec une nouvelle définition (mise à jour des nœuds existants ou ajout de nouveaux).
-     * @param {GraphDefinition<T>} definition
-     */
-    updateGraph(definition) {
-        Object.entries(definition.nodes).forEach(([_, nodeConfig]) => {
-            if (this.nodes.has(nodeConfig.name)) {
-                const existingNode = this.nodes.get(nodeConfig.name);
-                existingNode.relationships =
-                    nodeConfig.relationships || existingNode.relationships;
-                existingNode.condition = nodeConfig.condition || existingNode.condition;
-                existingNode.events = nodeConfig.events || existingNode.events;
-            }
-            else {
-                this.addNode(nodeConfig);
-            }
-        });
-    }
-    /**
-     * Remplace complètement le workflow par une nouvelle définition.
-     * @param {GraphDefinition<T>} definition
-     */
-    replaceGraph(definition) {
-        this.nodes.clear();
-        this.loadFromDefinition(definition);
-    }
-    /**
-     * Génère un diagramme Mermaid pour visualiser le workflow.
-     * @param {string} [title]
-     * @returns {string}
-     */
-    generateMermaidDiagram(title) {
-        const lines = ["flowchart TD"];
-        if (title) {
-            lines.push(`  subgraph ${title}`);
-        }
-        // Ajout des nœuds
-        this.nodes.forEach((node, nodeName) => {
-            const hasEvents = node.events && node.events.length > 0;
-            const hasCondition = !!node.condition;
-            // Style selon les propriétés
-            let style = "";
-            if (hasEvents) {
-                style = "style " + nodeName + " fill:#FFD700,stroke:#DAA520"; // Jaune pour event
-            }
-            else if (hasCondition) {
-                style = "style " + nodeName + " fill:#FFA500,stroke:#FF8C00"; // Orange pour condition
-            }
-            lines.push(`  ${nodeName}[${nodeName}]`);
-            if (style) {
-                lines.push(`  ${style}`);
-            }
-        });
-        // Ajout des connexions
-        this.nodes.forEach((node, nodeName) => {
-            if (node.relationships) {
-                node.relationships.forEach((relationsNode) => {
-                    let connectionStyle = "";
-                    if (node.condition) {
-                        connectionStyle = "---|condition|";
-                    }
-                    else {
-                        connectionStyle = "-->";
-                    }
-                    lines.push(`  ${nodeName} ${connectionStyle} ${relationsNode}`);
-                });
-            }
-            // Gestion des events
-            if (node.events && node.events.length > 0) {
-                node.events.forEach((event) => {
-                    const eventNodeId = `${event}_event`;
-                    lines.push(`  ${eventNodeId}((${event})):::event`);
-                    lines.push(`  ${eventNodeId} -.->|trigger| ${nodeName}`);
-                });
-                lines.push("  classDef event fill:#FFD700,stroke:#DAA520");
-            }
-        });
-        if (title) {
-            lines.push("  end");
-        }
-        return lines.join("\n");
-    }
-    /**
-     * Affiche le diagramme Mermaid dans la console.
-     * @param {string} [title]
-     */
-    visualize(title) {
-        const diagram = this.generateMermaidDiagram(title);
-        console.log("Pour visualiser ce workflow, utilisez un rendu compatible Mermaid avec la syntaxe suivante :");
-        console.log("\n```mermaid");
-        console.log(diagram);
-        console.log("```\n");
-    }
-    /**
-     * Exporte la définition du workflow au format JSON (pour debug ou documentation).
-     * @param {GraphDefinition<T>} workflow
-     * @returns {string} JSON string
-     */
-    exportGraphToJson(workflow) {
-        const result = {
-            workflowName: workflow.name,
-            entryNode: workflow.entryNode,
-            nodes: Object.entries(workflow.nodes).reduce((acc, [key, node]) => {
-                acc[key] = {
-                    name: node.name,
-                    description: node.description || "No description provided",
-                    execute: node.execute.name,
-                    condition: node.condition ? node.condition.toString() : "None",
-                    relationships: node.relationships || [],
-                };
-                return acc;
-            }, {}),
-        };
-        return JSON.stringify(result, null, 2);
-    }
-    /**
-     * Génère une représentation textuelle (console) du schéma du workflow.
-     * @returns {string}
-     */
-    visualizeSchema() {
-        const output = [];
-        output.push(`📋 Graph: ${this.name}`);
-        output.push("=".repeat(50));
-        // Schéma global
-        if (this.schema) {
-            output.push("🔷 Global Schema:");
-            output.push("-".repeat(30));
-            if (this.schema instanceof zod_1.z.ZodObject) {
-                const shape = this.schema.shape;
-                Object.entries(shape).forEach(([key, value]) => {
-                    const description = this.describeZodType(value, 1);
-                    output.push(`${key}:`);
-                    output.push(description);
-                });
-            }
-            output.push("");
-        }
-        // Détails des nœuds
-        output.push("🔷 Nodes:");
-        output.push("-".repeat(30));
-        this.nodes.forEach((node, nodeName) => {
-            output.push(`\n📍 Node: ${nodeName}`);
-            output.push(`Description: ${node.description || "No description provided"}`);
-            if (node.relationships && node.relationships.length > 0) {
-                const rels = node.relationships.map((r) => r.name).join(", ");
-                output.push(`Next nodes: ${rels}`);
-            }
-            output.push("");
-        });
-        return output.join("\n");
-    }
-    /**
-     * Décrit récursivement un type Zod pour l'affichage.
-     * @param {z.ZodType} type
-     * @param {number} indent
-     * @returns {string}
-     */
-    describeZodType(type, indent = 0) {
-        const padding = "  ".repeat(indent);
-        if (type instanceof zod_1.z.ZodObject) {
-            const shape = type.shape;
-            const lines = [];
-            Object.entries(shape).forEach(([key, value]) => {
-                const isOptional = value instanceof zod_1.z.ZodOptional;
-                const actualType = isOptional
-                    ? value.unwrap()
-                    : value;
-                const description = this.describeZodType(actualType, indent + 1);
-                lines.push(`${padding}${key}${isOptional ? "?" : ""}: ${description}`);
-            });
-            return lines.join("\n");
-        }
-        if (type instanceof zod_1.z.ZodArray) {
-            const elementType = this.describeZodType(type.element, indent);
-            return `Array<${elementType}>`;
-        }
-        if (type instanceof zod_1.z.ZodString) {
-            const checks = type._def.checks || [];
-            const constraints = checks
-                .map((check) => {
-                if (check.kind === "url")
-                    return "url";
-                if (check.kind === "email")
-                    return "email";
-                return check.kind;
-            })
-                .join(", ");
-            return constraints ? `string (${constraints})` : "string";
-        }
-        if (type instanceof zod_1.z.ZodNumber) {
-            return "number";
-        }
-        if (type instanceof zod_1.z.ZodBoolean) {
-            return "boolean";
-        }
-        if (type instanceof zod_1.z.ZodOptional) {
-            return `${this.describeZodType(type.unwrap(), indent)} (optional)`;
-        }
-        return type.constructor.name.replace("Zod", "") || "unknown";
-    }
-    /**
-     * Met à jour le contexte du workflow pour un nœud, en renvoyant un nouvel état.
-     * @param {SharedState<T>} state
-     * @param {Partial<T>} updates
-     * @returns {SharedState<T>}
-     */
-    updateNodeState(state, updates) {
-        return Object.assign(Object.assign({}, state), updates);
-    }
-    /**
-     * Récupère l'état courant du workflow.
-     * @returns {SharedState<T>}
-     */
-    getState() {
-        return this.currentState;
-    }
-    /**
-     * Définit le nouvel état courant du workflow et met à jour le contexte global.
-     * @param {Partial<SharedState<T>>} state
-     */
-    setState(state) {
-        this.currentState = this.mergeStates(this.currentState, state);
-        if (state) {
-            Object.entries(state).forEach(([key, value]) => {
-                this.globalContext.set(key, value);
-            });
-        }
-        const currentNode = Array.from(this.executedNodes).pop();
-        if (currentNode) {
-            const node = this.nodes.get(currentNode);
-            if (node) {
-                node.state = Object.assign(Object.assign({}, (node.state || {})), (state || {}));
-            }
-        }
-    }
-    /**
-     * Fusionne deux états.
-     * @param {SharedState<T>} currentState
-     * @param {Partial<SharedState<T>>} newState
-     * @returns {SharedState<T>}
-     */
-    mergeStates(currentState, newState) {
-        return Object.assign(Object.assign({}, currentState), (newState || {}));
-    }
-    /**
-     * Met à jour l'état courant et le renvoie.
-     * @param {Partial<T>} updates
-     * @returns {SharedState<T>}
-     */
-    updateState(updates) {
-        const currentState = this.getState();
-        const newState = Object.assign(Object.assign({}, currentState), updates);
-        this.setState(newState);
-        return newState;
-    }
-    /* =============================================
-       =   MÉTHODES STATIQUES POUR PLUSIEURS GRAPHES  =
-       ============================================= */
-    /**
-     * Exécute plusieurs GraphEngine en **séquence** (l'un après l'autre).
-     * @param graphs Liste des graphes à exécuter
-     * @param startNodes Noms des nœuds de départ correspondants
-     * @param initialStates États initiaux correspondants
-     * @param onStream Callback d'avancement
-     * @param onError Callback d'erreur
-     * @returns Tableau des états finaux de chaque graphe
-     */
-    static executeGraphsInSequence(graphs, startNodes, initialStates, actions, // Pass actions here
-    onStream, onError) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Return updated actions directly
-            const finalStates = [];
-            for (let i = 0; i < graphs.length; i++) {
-                const graph = graphs[i];
-                const startNode = startNodes[i];
-                const initialState = initialStates[i];
-                const result = yield graph.execute(initialState, startNode, onStream, onError);
-                finalStates.push({
-                    name: graph.name,
-                    result,
-                });
-            }
-            // Map results to actions
-            return actions.map((action) => {
-                const result = finalStates.find((state) => state.name === action.name);
-                return Object.assign(Object.assign({}, action), { result: result ? result.result : null });
-            });
-        });
-    }
-    /**
-     * Exécute plusieurs GraphEngine en **parallèle** (sans limite de concurrence).
-     * @param graphs Liste des graphes
-     * @param startNodes Noms des nœuds de départ
-     * @param initialStates États initiaux
-     * @param onStream Callback d'avancement
-     * @param onError Callback d'erreur
-     * @returns Tableau des états finaux de chaque graphe
-     */
-    static executeGraphsInParallel(graphs, startNodes, initialStates, onStream, onError) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const promises = graphs.map((graph, index) => graph.execute(initialStates[index], startNodes[index], onStream, onError));
-            return Promise.all(promises);
-        });
-    }
-    /**
-     * Exécute plusieurs GraphEngine en parallèle **avec une limite de concurrence**.
-     * @param graphs Liste des graphes
-     * @param startNodes Noms des nœuds de départ
-     * @param initialStates États initiaux
-     * @param concurrencyLimit Limite de concurrence
-     * @param onStream Callback d'avancement
-     * @param onError Callback d'erreur
-     * @returns Tableau des états finaux de chaque graphe
-     */
-    static executeGraphsWithConcurrencyLimit(graphs, startNodes, initialStates, concurrencyLimit, onStream, onError) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const results = [];
-            for (let i = 0; i < graphs.length; i += concurrencyLimit) {
-                const chunkGraphs = graphs.slice(i, i + concurrencyLimit);
-                const chunkStartNodes = startNodes.slice(i, i + concurrencyLimit);
-                const chunkInitialStates = initialStates.slice(i, i + concurrencyLimit);
-                const chunkPromises = chunkGraphs.map((graph, index) => {
-                    return graph.execute(chunkInitialStates[index], chunkStartNodes[index], onStream, onError);
-                });
-                const chunkResults = yield Promise.all(chunkPromises);
-                results.push(...chunkResults);
-            }
-            return results;
-        });
-    }
-}
-exports.GraphEngine = GraphEngine;