@ai.ntellect/core 0.7.8 → 1.0.0

package/graph/node.ts

@@ -1,327 +0,0 @@
-import { IEventEmitter } from "interfaces";
-import { BehaviorSubject, Subject } from "rxjs";
-import { ZodSchema } from "zod";
-import { GraphContext, GraphEvent, Node } from "../types";
-import { GraphEventManager } from "./event-manager";
-
-/**
- * Represents a node in the graph that can execute operations and manage state
- * @template T - The Zod schema type for validation
- */
-export interface NodeParams<T = any> {
-  [key: string]: T;
-}
-
-export interface GraphLogger {
-  addLog: (message: string, data?: any) => void;
-}
-
-export class GraphNode<T extends ZodSchema> {
-  private lastStateEvent: GraphEvent<T> | null = null;
-  private eventEmitter: IEventEmitter;
-
-  /**
-   * Creates a new GraphNode instance
-   * @param nodes - Map of all nodes in the graph
-   * @param logger - Logger instance for tracking node operations
-   * @param eventManager - Manager for handling graph events
-   * @param eventSubject - Subject for emitting events
-   * @param stateSubject - Subject for managing graph state
-   */
-  constructor(
-    private nodes: Map<string, Node<T, any>>,
-    private logger: GraphLogger,
-    private eventManager: GraphEventManager<T>,
-    private eventSubject: Subject<GraphEvent<T>>,
-    private stateSubject: BehaviorSubject<GraphContext<T>>
-  ) {
-    this.eventEmitter = eventManager["eventEmitter"];
-  }
-
-  /**
-   * Emits an event with the specified type and payload
-   * @param type - The type of event to emit
-   * @param payload - The data associated with the event
-   * @private
-   */
-  private emitEvent(type: string, payload: any) {
-    if (type === "nodeStateChanged") {
-      if (
-        this.lastStateEvent?.type === type &&
-        this.lastStateEvent.payload.property === payload.property &&
-        this.lastStateEvent.payload.newValue === payload.newValue &&
-        this.lastStateEvent.payload.nodeName === payload.nodeName
-      ) {
-        return;
-      }
-    }
-
-    const event = {
-      type,
-      payload: {
-        ...payload,
-        name: type === "nodeStateChanged" ? payload.nodeName : payload.name,
-        context: { ...payload.context },
-      },
-      timestamp: Date.now(),
-    };
-
-    this.eventSubject.next(event);
-    this.eventManager.emitEvent(type, event);
-
-    if (type === "nodeStateChanged") {
-      this.lastStateEvent = event;
-      this.stateSubject.next({ ...payload.context });
-    }
-  }
-
-  /**
-   * Executes a node with the given name and context
-   * @param nodeName - The name of the node to execute
-   * @param context - The current graph context
-   * @param params - Input data for the node
-   * @param triggeredByEvent - Whether the execution was triggered by an event
-   * @throws Error if the node is not found or execution fails
-   */
-  public async executeNode(
-    nodeName: string,
-    context: GraphContext<T>,
-    params: any,
-    triggeredByEvent: boolean = false
-  ): Promise<void> {
-    const node = this.nodes.get(nodeName);
-    if (!node) throw new Error(`Node "${nodeName}" not found.`);
-
-    const nodeContext = { ...context };
-    this.emitEvent("nodeStarted", { name: nodeName, context: nodeContext });
-
-    try {
-      if (node.correlateEvents) {
-        await this.eventManager.waitForCorrelatedEvents(
-          node.correlateEvents.events,
-          node.correlateEvents.timeout || 30000,
-          (events) => {
-            return node.correlateEvents!.correlation(events);
-          }
-        );
-      }
-
-      // Ensuite, attendre les événements si waitForEvents est défini
-      if (node.waitForEvents) {
-        await this.eventManager.waitForEvents(
-          node.waitForEvents.events,
-          node.waitForEvents.timeout
-        );
-      }
-
-      const contextProxy = new Proxy(nodeContext, {
-        set: (target: any, prop: string | symbol, value: any) => {
-          const oldValue = target[prop.toString()];
-          if (oldValue === value) return true;
-
-          target[prop.toString()] = value;
-          // Mettre à jour le contexte global
-          context[prop.toString() as keyof typeof context] = value;
-
-          this.emitEvent("nodeStateChanged", {
-            nodeName,
-            property: prop.toString(),
-            oldValue,
-            newValue: value,
-            context: { ...target },
-          });
-          return true;
-        },
-      });
-
-      if (node.condition && !node.condition(contextProxy, params)) {
-        return;
-      }
-
-      await this.executeWithRetry(node, contextProxy, nodeName, params);
-      this.emitEvent("nodeCompleted", { name: nodeName, context: nodeContext });
-
-      if (!triggeredByEvent && node.next) {
-        const nextNodes =
-          typeof node.next === "function" ? node.next(contextProxy) : node.next;
-        for (const nextNodeName of nextNodes) {
-          await this.executeNode(nextNodeName, context, undefined, false);
-        }
-      }
-    } catch (error) {
-      this.emitEvent("nodeError", {
-        name: nodeName,
-        error,
-        context: nodeContext,
-      });
-      throw error;
-    }
-  }
-
-  /**
-   * Validates the params for a node using its schema
-   * @param node - The node whose params need validation
-   * @param params - The input data to validate
-   * @param nodeName - The name of the node (for error messages)
-   * @throws Error if validation fails
-   * @private
-   */
-  private async validateParams(
-    node: Node<T, any>,
-    params: any,
-    nodeName: string
-  ): Promise<void> {
-    // Si pas de schéma de validation ou si le schéma est optionnel, accepter n'importe quels params
-    if (!node.params || node.params.isOptional?.()) return;
-
-    // Vérifier les params uniquement si un schéma est défini et non optionnel
-    if (!params) {
-      throw new Error(`Params required for node "${nodeName}"`);
-    }
-
-    try {
-      return node.params.parse(params);
-    } catch (error: any) {
-      throw error;
-    }
-  }
-
-  /**
-   * Handles event-related operations for a node
-   * @param node - The node whose events need handling
-   * @param nodeName - The name of the node
-   * @param context - The current graph context
-   * @private
-   */
-  private async handleEvents(
-    node: Node<T, any>,
-    nodeName: string,
-    context: GraphContext<T>
-  ): Promise<void> {
-    if (node.correlateEvents) {
-      await this.handleCorrelatedEvents(node, nodeName);
-    }
-
-    if (node.waitForEvents) {
-      await this.handleWaitForEvents(node, nodeName);
-    }
-  }
-
-  /**
-   * Executes a node with retry logic
-   * @param node - The node to execute
-   * @param contextProxy - The proxied graph context
-   * @param params - Input data for the node
-   * @param nodeName - The name of the node
-   * @param params - Parameters for the node
-   * @throws Error if all retry attempts fail
-   * @private
-   */
-  private async executeWithRetry(
-    node: Node<T, any>,
-    contextProxy: GraphContext<T>,
-    nodeName: string,
-    params?: NodeParams
-  ): Promise<void> {
-    let attempts = 0;
-    let lastError: Error = new Error("Unknown error");
-
-    while (attempts < (node.retry?.maxAttempts || 1)) {
-      try {
-        if (node.params) {
-          await this.validateParams(node, params, nodeName);
-        }
-
-        await node.execute(contextProxy, params, {
-          eventEmitter: this.eventEmitter,
-        });
-        return;
-      } catch (error: any) {
-        lastError =
-          error instanceof Error
-            ? error
-            : new Error(error?.message || "Unknown error");
-        attempts++;
-
-        if (attempts === (node.retry?.maxAttempts || 1)) {
-          if (node.retry?.onRetryFailed) {
-            await node.retry.onRetryFailed(lastError, contextProxy);
-            if (node.retry.continueOnFailed) return;
-          }
-          throw lastError;
-        }
-
-        await new Promise((resolve) =>
-          setTimeout(resolve, node.retry?.delay || 0)
-        );
-      }
-    }
-  }
-
-  /**
-   * Handles correlated events for a node
-   * @param node - The node with correlated events
-   * @param nodeName - The name of the node
-   * @throws Error if correlation fails or timeout occurs
-   * @private
-   */
-  private async handleCorrelatedEvents(
-    node: Node<T, any>,
-    nodeName: string
-  ): Promise<void> {
-    if (node.correlateEvents) {
-      const { events, timeout, correlation } = node.correlateEvents;
-      this.logger.addLog(
-        `⏳ Node "${nodeName}" waiting for correlated events: ${events.join(
-          ", "
-        )}`
-      );
-
-      try {
-        // Attendre les événements
-        const receivedEvents = await this.eventManager.waitForEvents(
-          events,
-          timeout
-        );
-
-        // Vérifier la corrélation
-        if (!correlation(receivedEvents)) {
-          this.logger.addLog(
-            `❌ Event correlation failed for node "${nodeName}"`
-          );
-          throw new Error(`Event correlation failed for node "${nodeName}"`);
-        }
-
-        this.logger.addLog(
-          `✅ Event correlation succeeded for node "${nodeName}"`
-        );
-      } catch (error) {
-        this.logger.addLog(
-          `❌ Error waiting for events: ${(error as Error).message}`
-        );
-        throw error;
-      }
-    }
-  }
-
-  /**
-   * Handles waiting for events
-   * @param node - The node waiting for events
-   * @param nodeName - The name of the node
-   * @throws Error if timeout occurs
-   * @private
-   */
-  private async handleWaitForEvents(
-    node: Node<T, any>,
-    nodeName: string
-  ): Promise<void> {
-    if (node.waitForEvents) {
-      const { events, timeout } = node.waitForEvents;
-      this.logger.addLog(
-        `⏳ Node "${nodeName}" waiting for events: ${events.join(", ")}`
-      );
-      await this.eventManager.waitForEvents(events, timeout);
-      this.logger.addLog(`✅ All events received for node "${nodeName}"`);
-    }
-  }
-}

package/graph/observer.ts

@@ -1,368 +0,0 @@
-import {
-  BehaviorSubject,
-  Observable,
-  Subject,
-  combineLatest,
-  firstValueFrom,
-} from "rxjs";
-import {
-  debounceTime,
-  distinctUntilChanged,
-  filter,
-  map,
-  share,
-  startWith,
-  take,
-  takeUntil,
-  timeout,
-} from "rxjs/operators";
-import { ZodSchema } from "zod";
-import { GraphObservable } from "../interfaces";
-import { GraphContext, GraphEvent } from "../types";
-import { GraphFlow } from "./index";
-
-interface ObserverOptions {
-  debounce?: number;
-  delay?: number;
-  stream?: boolean;
-  properties?: (string | number)[]; // Accepte uniquement string ou number comme clés
-  onStreamLetter?: (data: { letter: string; property: string }) => void;
-  onStreamComplete?: () => void;
-}
-
-/**
- * GraphObserver class provides reactive observation capabilities for a GraphFlow instance
- * It allows monitoring state changes, node updates, and specific events in the graph
- * @template T - The Zod schema type that defines the structure of the graph data
- */
-export class GraphObserver<T extends ZodSchema> {
-  constructor(
-    private graph: GraphFlow<T>,
-    private eventSubject: Subject<GraphEvent<T>>,
-    private stateSubject: BehaviorSubject<GraphContext<T>>,
-    private destroySubject: Subject<void>
-  ) {}
-
-  /**
-   * Observes the entire graph state changes
-   * @param options Configuration options for the observation
-   * @param options.debounce Debounce time in milliseconds
-   * @param options.delay Delay between emissions in milliseconds
-   * @param options.stream If true, streams the specified properties letter by letter
-   * @param options.properties List of properties to stream
-   * @param options.onStreamLetter Callback for each letter emitted during streaming
-   * @param options.onStreamComplete Callback when streaming is complete
-   * @returns An Observable that emits the complete graph context whenever it changes
-   */
-  state(options: ObserverOptions = {}): GraphObservable<T> {
-    const baseObservable = new Observable<any>((subscriber) => {
-      const subscription = combineLatest([
-        this.eventSubject.pipe(
-          filter((event) => event.type === "nodeStateChanged"),
-          map((event) => event.payload.context),
-          distinctUntilChanged(
-            (prev, curr) => JSON.stringify(prev) === JSON.stringify(curr)
-          ),
-          debounceTime(options.debounce || 100)
-        ),
-        this.stateSubject,
-      ])
-        .pipe(
-          map(([eventContext, stateContext]) => ({
-            ...stateContext,
-            ...eventContext,
-          })),
-          distinctUntilChanged(
-            (prev, curr) => JSON.stringify(prev) === JSON.stringify(curr)
-          )
-        )
-        .subscribe(subscriber);
-
-      // Stream the specified properties if specified
-      if (options.stream && options.properties) {
-        const context = this.stateSubject.getValue();
-        options.properties.forEach((property) => {
-          const message = context[property];
-          if (message) {
-            this.streamMessage(
-              message.toString(),
-              500,
-              property as string
-            ).subscribe({
-              next: (data) => options.onStreamLetter?.(data),
-              complete: () => options.onStreamComplete?.(),
-            });
-          }
-        });
-      }
-
-      return () => subscription.unsubscribe();
-    });
-
-    // Extend the observable with our custom methods
-    return Object.assign(baseObservable, {
-      state: () => this.stateSubject.asObservable(),
-      node: (nodeName: string) =>
-        this.stateSubject.pipe(map((state) => ({ ...state, nodeName }))),
-      nodes: (nodeNames: string[]) =>
-        this.eventSubject.pipe(
-          filter(
-            (event) =>
-              event.type === "nodeStateChanged" &&
-              nodeNames.includes(event.payload?.name ?? "")
-          ),
-          map((event) => event.payload.context),
-          distinctUntilChanged(
-            (prev, curr) => JSON.stringify(prev) === JSON.stringify(curr)
-          ),
-          takeUntil(this.destroySubject),
-          share()
-        ),
-      property: (props: string | string[]) =>
-        this.stateSubject.pipe(
-          map((state) => {
-            const properties = Array.isArray(props) ? props : [props];
-            return properties.reduce(
-              (acc, prop) => ({
-                ...acc,
-                [prop]: state[prop],
-              }),
-              {}
-            );
-          })
-        ),
-      event: (eventName: string) =>
-        this.eventSubject.pipe(filter((event) => event.type === eventName)),
-      until: (
-        observable: Observable<any>,
-        predicate: (state: any) => boolean
-      ) => firstValueFrom(observable.pipe(filter(predicate), take(1))),
-    }) as GraphObservable<T>;
-  }
-
-  /**
-   * Observes state changes for a specific node
-   * @param name - The name of the node to observe
-   * @returns An Observable that emits the graph context when the specified node changes
-   */
-  node(name: string): Observable<GraphContext<T>> {
-    return this.eventSubject.pipe(
-      filter(
-        (event) =>
-          event.type === "nodeStateChanged" && event.payload?.name === name
-      ),
-      map((event) => event.payload.context),
-      distinctUntilChanged(
-        (prev, curr) => JSON.stringify(prev) === JSON.stringify(curr)
-      ),
-      takeUntil(this.destroySubject),
-      share()
-    );
-  }
-
-  /**
-   * Observes state changes for multiple nodes
-   * @param names - Array of node names to observe
-   * @returns An Observable that emits the graph context when any of the specified nodes change
-   */
-  nodes(names: string[]): Observable<GraphContext<T>> {
-    return this.eventSubject.pipe(
-      filter(
-        (event) =>
-          names.includes(event.payload?.name ?? "") &&
-          event.type === "nodeStateChanged"
-      ),
-      map(() => this.graph.getContext()),
-      distinctUntilChanged(
-        (prev, curr) => JSON.stringify(prev) === JSON.stringify(curr)
-      ),
-      takeUntil(this.destroySubject),
-      share()
-    );
-  }
-
-  /**
-   * Observes specific properties of the graph context
-   * @param keys - Single or multiple property keys to observe
-   * @returns An Observable that emits an object containing only the specified properties
-   * @template K - The key of the property to observe from GraphContext<T>
-   */
-  property<K extends keyof GraphContext<T>>(
-    keys: K | K[]
-  ): Observable<{ [P in K]: GraphContext<T>[P] } & { name: string }> {
-    const properties = Array.isArray(keys) ? keys : [keys];
-
-    return this.eventSubject.pipe(
-      filter(
-        (event) =>
-          event.type === "nodeStateChanged" &&
-          properties.some((key) => event.payload?.property === key)
-      ),
-      map((event) => ({
-        ...properties.reduce(
-          (obj, key) => ({
-            ...obj,
-            [key]: event.payload.context[key],
-          }),
-          {} as { [P in K]: GraphContext<T>[P] }
-        ),
-        name: event.payload.name as string,
-      })),
-      startWith({
-        ...properties.reduce(
-          (obj, key) => ({
-            ...obj,
-            [key]: this.stateSubject.value[key],
-          }),
-          {}
-        ),
-        name: "initial",
-      } as { [P in K]: GraphContext<T>[P] } & { name: string }),
-      distinctUntilChanged(
-        (prev, curr) => JSON.stringify(prev) === JSON.stringify(curr)
-      ),
-      share()
-    );
-  }
-
-  /**
-   * Observes specific events in the graph
-   * @param type - The type of event to observe
-   * @returns An Observable that emits events of the specified type
-   */
-  event(type: string): Observable<GraphEvent<T>> {
-    return this.eventSubject.pipe(
-      filter((event) => event.type === type),
-      map((event) => event),
-      takeUntil(this.destroySubject),
-      share()
-    );
-  }
-
-  /**
-   * Waits for a specific condition to be met on an observable
-   * @param observable - The Observable to watch
-   * @param predicate - A function that returns true when the desired condition is met
-   * @returns A Promise that resolves with the value when the predicate returns true
-   * @template R - The type of value emitted by the observable
-   */
-  until<R>(
-    observable: Observable<R>,
-    predicate: (value: R) => boolean
-  ): Promise<R> {
-    return new Promise((resolve) => {
-      const subscription = observable.subscribe({
-        next: (value) => {
-          if (predicate(value)) {
-            subscription.unsubscribe();
-            resolve(value);
-          }
-        },
-      });
-    });
-  }
-
-  /**
-   * Waits for correlated events to occur and validates them using a correlation function
-   * @param eventTypes - Array of event types to wait for
-   * @param timeoutMs - Timeout duration in milliseconds
-   * @param correlationFn - Function to validate the correlation between events
-   * @returns Promise that resolves when all correlated events are received
-   */
-  waitForCorrelatedEvents(
-    eventTypes: string[],
-    timeoutMs: number,
-    correlationFn: (events: GraphEvent<T>[]) => boolean
-  ): Promise<GraphEvent<T>[]> {
-    return new Promise((resolve, reject) => {
-      const eventObservables = eventTypes.map((eventType) =>
-        this.eventSubject.pipe(
-          filter((event): event is GraphEvent<T> => {
-            return event.type === eventType && "timestamp" in event;
-          }),
-          take(1)
-        )
-      );
-
-      combineLatest(eventObservables)
-        .pipe(timeout(timeoutMs), take(1))
-        .subscribe({
-          next: (events) => {
-            if (correlationFn(events)) {
-              resolve(events);
-            } else {
-              reject(new Error(`Correlation validation failed`));
-            }
-          },
-          error: (error) => reject(error),
-        });
-    });
-  }
-
-  /**
-   * Observes the current state of the graph
-   * @returns Observable that emits the current graph context
-   */
-  observeState(): Observable<GraphContext<T>> {
-    return this.stateSubject.asObservable().pipe(
-      takeUntil(this.destroySubject),
-      distinctUntilChanged(
-        (prev, curr) => JSON.stringify(prev) === JSON.stringify(curr)
-      )
-    );
-  }
-
-  /**
-   * Observes specific event types in the graph
-   * @param eventType - The type of event to observe
-   * @returns Observable that emits events of the specified type
-   */
-  observeEvents(eventType: string): Observable<GraphEvent<T>> {
-    return this.eventSubject.asObservable().pipe(
-      takeUntil(this.destroySubject),
-      filter((event) => event.type === eventType)
-    );
-  }
-
-  /**
-   * Observes state changes for a specific node
-   * @param nodeName - The name of the node to observe
-   * @returns Observable that emits the graph context when the specified node changes
-   */
-  observeNodeState(nodeName: string): Observable<GraphContext<T>> {
-    return this.eventSubject.asObservable().pipe(
-      takeUntil(this.destroySubject),
-      filter(
-        (event) =>
-          event.type === "nodeStateChanged" && event.payload?.name === nodeName
-      ),
-      map(() => this.stateSubject.value)
-    );
-  }
-
-  /**
-   * Streams a message letter by letter with a specified delay
-   * @param message - The message to stream
-   * @param delayMs - The delay in milliseconds between each letter
-   * @param property - The property name being streamed
-   * @returns An Observable that emits each letter of the message along with its property
-   */
-  streamMessage(
-    message: string,
-    delayMs: number,
-    property: string
-  ): Observable<{ letter: string; property: string }> {
-    return new Observable<{ letter: string; property: string }>(
-      (subscriber) => {
-        for (let i = 0; i < message.length; i++) {
-          setTimeout(() => {
-            subscriber.next({ letter: message[i], property });
-            if (i === message.length - 1) {
-              subscriber.complete();
-            }
-          }, i * delayMs);
-        }
-      }
-    );
-  }
-}