@ai.ntellect/core 0.5.0 → 0.6.1

package/services/workflow.ts

@@ -1,491 +0,0 @@
-import { configDotenv } from "dotenv";
-import EventEmitter from "events";
-import {
-  mergeState,
-  Node,
-  Persistence,
-  RealTimeNotifier,
-  SharedState,
-  WorkflowDefinition,
-} from "../types";
-
-configDotenv();
-
-/**
- * Represents a directed worflow structure capable of executing nodes in sequence or parallel.
- * The worflow can handle state management, event emissions, and conditional execution paths.
- *
- * @template T - The type of data stored in the worflow's context
- */
-export class Workflow<T> {
-  /** Stores global context data accessible to all nodes */
-  public globalContext: Map<string, any>;
-
-  /** Event emitter for handling worflow-wide events */
-  private eventEmitter: EventEmitter;
-
-  /** Map of all nodes in the worflow */
-  public nodes: Map<string, Node<T>>;
-
-  /** Set of nodes that have been executed */
-  public executedNodes: Set<string>;
-
-  /** Name identifier for the worflow */
-  public name: string;
-
-  /** Optional persistence layer for saving worflow state */
-  private persistence: Persistence<T> | null;
-
-  /** Optional notifier for real-time updates */
-  private notifier: RealTimeNotifier | null;
-
-  /**
-   * Creates a new Workflow instance.
-   *
-   * @param {WorkflowDefinition<T>} [definition] - Initial worflow structure and configuration
-   * @param {Object} [config] - Additional configuration options
-   * @param {boolean} [config.autoDetectCycles] - Whether to check for cycles during initialization
-   * @throws {Error} If cycles are detected when autoDetectCycles is true
-   */
-  constructor(
-    definition?: WorkflowDefinition<T>,
-    config?: { autoDetectCycles?: boolean }
-  ) {
-    this.name = definition?.name || "anonymous";
-    this.eventEmitter = new EventEmitter();
-    this.globalContext = new Map();
-    this.nodes = new Map();
-    this.executedNodes = new Set();
-    this.persistence = null;
-    this.notifier = null;
-
-    if (definition) {
-      this.loadFromDefinition(definition);
-    }
-
-    if (config?.autoDetectCycles && this.checkForCycles()) {
-      throw new Error("Cycle detected in the worflow");
-    }
-  }
-
-  /**
-   * Adds a value to the global context.
-   * @param {string} key - The key to store the value under
-   * @param {any} value - The value to store
-   */
-  addToContext(key: string, value: any): void {
-    this.globalContext.set(key, value);
-  }
-
-  /**
-   * Retrieves a value from the global context.
-   * @param {string} key - The key to retrieve
-   * @returns {any} The stored value, or undefined if not found
-   */
-  getContext(key: string): any {
-    return this.globalContext.get(key);
-  }
-
-  /**
-   * Removes a value from the global context.
-   * @param {string} key - The key to remove
-   */
-  removeFromContext(key: string): void {
-    this.globalContext.delete(key);
-  }
-
-  /**
-   * Sets the persistence layer for the worflow.
-   * @param {Persistence<T>} persistence - The persistence implementation
-   */
-  setPersistence(persistence: Persistence<T>): void {
-    this.persistence = persistence;
-  }
-
-  /**
-   * Sets the real-time notifier for the worflow.
-   * @param {RealTimeNotifier} notifier - The notifier implementation
-   */
-  setNotifier(notifier: RealTimeNotifier): void {
-    this.notifier = notifier;
-  }
-
-  /**
-   * Loads a worflow structure from a definition object.
-   * @private
-   * @param {WorkflowDefinition<T>} definition - The worflow definition
-   */
-  private loadFromDefinition(definition: WorkflowDefinition<T>): void {
-    Object.entries(definition.nodes).forEach(([_, nodeConfig]) => {
-      this.addNode(nodeConfig, {
-        condition: nodeConfig.condition,
-        next: nodeConfig.next,
-      });
-    });
-  }
-
-  /**
-   * Recursively checks if a node is part of a cycle.
-   * @private
-   * @param {string} nodeName - The name of the node to check
-   * @param {Set<string>} visited - Set of visited nodes
-   * @param {Set<string>} recStack - Set of nodes in the current recursion stack
-   * @returns {boolean} True if a cycle is detected, false otherwise
-   */
-  private isCyclic(
-    nodeName: string,
-    visited: Set<string>,
-    recStack: Set<string>
-  ): boolean {
-    if (!visited.has(nodeName)) {
-      visited.add(nodeName);
-      recStack.add(nodeName);
-
-      const currentNode = this.nodes.get(nodeName);
-      if (currentNode?.next) {
-        for (const nextNode of currentNode.next) {
-          if (
-            !visited.has(nextNode) &&
-            this.isCyclic(nextNode, visited, recStack)
-          ) {
-            return true;
-          } else if (recStack.has(nextNode)) {
-            return true;
-          }
-        }
-      }
-    }
-    recStack.delete(nodeName);
-    return false;
-  }
-
-  /**
-   * Checks if the worflow contains any cycles.
-   * @returns {boolean} True if cycles are detected, false otherwise
-   */
-  public checkForCycles(): boolean {
-    const visited = new Set<string>();
-    const recStack = new Set<string>();
-
-    for (const nodeName of this.nodes.keys()) {
-      if (this.isCyclic(nodeName, visited, recStack)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  /**
-   * Adds a new node to the worflow.
-   * @param {Node<T>} node - The node to add
-   * @param {Object} options - Node configuration options
-   * @param {Function} [options.condition] - Condition function for node execution
-   * @param {string[]} [options.next] - Array of next node names
-   * @param {string[]} [options.events] - Array of event names to listen for
-   */
-  addNode(
-    node: Node<T>,
-    {
-      condition,
-      next,
-      events,
-    }: {
-      condition?: (state: SharedState<T>) => boolean;
-      next?: string[];
-      events?: string[];
-    }
-  ): void {
-    node.next = next;
-    node.condition = condition;
-
-    if (events) {
-      events.forEach((event) => {
-        this.eventEmitter.on(event, async (data) => {
-          console.log(`Event "${event}" received by node "${node.name}"`);
-          const state = data.state || {};
-          await this.execute(state, node.name);
-        });
-      });
-    }
-
-    this.nodes.set(node.name, node);
-  }
-
-  /**
-   * Emits an event to the worflow's event emitter.
-   * @param {string} eventName - Name of the event to emit
-   * @param {any} data - Data to pass with the event
-   */
-  public emit(eventName: string, data: any): void {
-    console.log(`Event "${eventName}" emitted with data:`, data);
-    this.eventEmitter.emit(eventName, data);
-  }
-
-  /**
-   * Adds a subworflow as a node in the current worflow.
-   * @param {Workflow<T>} subWorkflow - The subworflow to add
-   * @param {string} entryNode - The entry node name in the subworflow
-   * @param {string} name - The name for the subworflow node
-   */
-  addSubWorkflow(
-    subWorkflow: Workflow<T>,
-    entryNode: string,
-    name: string
-  ): void {
-    const subWorkflowNode: Node<T> = {
-      name,
-      execute: async (state) => {
-        console.log(`Executing subworflow: ${name}`);
-        await subWorkflow.execute(state, entryNode);
-        return state;
-      },
-    };
-    this.nodes.set(name, subWorkflowNode);
-  }
-
-  /**
-   * Executes the worflow starting from a specific node.
-   * @param {SharedState<T>} state - The initial state
-   * @param {string} startNode - The name of the starting node
-   * @param {Function} [onStream] - Callback for streaming state updates
-   * @param {Function} [onError] - Callback for handling errors
-   */
-  async execute(
-    state: SharedState<T>,
-    startNode: string,
-    onStream?: (state: SharedState<T>) => void,
-    onError?: (error: Error, nodeName: string, state: SharedState<T>) => void
-  ): Promise<void> {
-    let currentNodeName = startNode;
-
-    while (currentNodeName) {
-      this.executedNodes.add(currentNodeName);
-
-      const currentNode = this.nodes.get(currentNodeName);
-      if (!currentNode) throw new Error(`Node ${currentNodeName} not found.`);
-
-      if (currentNode.condition && !currentNode.condition(state)) {
-        console.log(
-          `Condition for node "${currentNodeName}" not met. Ending Workflow.`
-        );
-        break;
-      }
-
-      try {
-        if (this.notifier) {
-          this.notifier.notify("nodeExecutionStarted", {
-            worflow: this.name,
-            node: currentNodeName,
-          });
-        }
-
-        console.log(`Executing node: ${currentNodeName}`);
-        const newState = await currentNode.execute(state);
-        Object.assign(state, mergeState(state, newState));
-
-        if (onStream) onStream(state);
-
-        if (this.persistence) {
-          await this.persistence.saveState(this.name, state, currentNodeName);
-        }
-
-        if (this.notifier) {
-          await this.notifier.notify("nodeExecutionCompleted", {
-            worflow: this.name,
-            node: currentNodeName,
-            state,
-          });
-        }
-      } catch (error) {
-        console.error(`Error in node ${currentNodeName}:`, error);
-        if (onError) onError(error as Error, currentNodeName, state);
-        if (this.notifier) {
-          this.notifier.notify("nodeExecutionFailed", {
-            worflow: this.name,
-            node: currentNodeName,
-            state,
-            error,
-          });
-        }
-        break;
-      }
-
-      const nextNodes = currentNode.next || [];
-      if (nextNodes.length > 1) {
-        await Promise.all(
-          nextNodes.map((nextNode) =>
-            this.execute(state, nextNode, onStream, onError)
-          )
-        );
-        break;
-      } else {
-        currentNodeName = nextNodes[0] || "";
-      }
-    }
-
-    console.log(`Workflow completed for node: ${startNode}`);
-  }
-
-  /**
-   * Executes multiple nodes in parallel with a concurrency limit.
-   * @param {SharedState<T>} state - The shared state
-   * @param {string[]} nodeNames - Array of node names to execute
-   * @param {number} [concurrencyLimit=5] - Maximum number of concurrent executions
-   * @param {Function} [onStream] - Callback for streaming state updates
-   * @param {Function} [onError] - Callback for handling errors
-   */
-  async executeParallel(
-    state: SharedState<T>,
-    nodeNames: string[],
-    concurrencyLimit: number = 5,
-    onStream?: (state: SharedState<T>) => void,
-    onError?: (error: Error, nodeName: string, state: SharedState<T>) => void
-  ): Promise<void> {
-    console.log(`Executing nodes in parallel: ${nodeNames.join(", ")}`);
-
-    const executeWithLimit = async (nodeName: string) => {
-      await 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) {
-      await Promise.all(chunk.map(executeWithLimit));
-    }
-  }
-
-  /**
-   * Updates the worflow structure with a new definition.
-   * @param {WorkflowDefinition<T>} definition - The new worflow definition
-   */
-  updateWorkflow(definition: WorkflowDefinition<T>): void {
-    Object.entries(definition.nodes).forEach(([_, nodeConfig]) => {
-      if (this.nodes.has(nodeConfig.name)) {
-        const existingNode = this.nodes.get(nodeConfig.name)!;
-        existingNode.next = nodeConfig.next || existingNode.next;
-        existingNode.condition = nodeConfig.condition || existingNode.condition;
-      } else {
-        this.addNode(nodeConfig, {
-          condition: nodeConfig.condition,
-          next: nodeConfig.next,
-        });
-      }
-    });
-  }
-
-  /**
-   * Replace the worflow with a new definition.
-   * @param {WorkflowDefinition<T>} definition - The new worflow definition
-   */
-  replaceWorkflow(definition: WorkflowDefinition<T>): void {
-    this.nodes.clear();
-    this.loadFromDefinition(definition);
-  }
-
-  /**
-   * Generates a visual representation of the worflow using Mermaid diagram syntax.
-   * The diagram shows all nodes and their connections, with special highlighting for:
-   * - Entry nodes (green)
-   * - Event nodes (yellow)
-   * - Conditional nodes (orange)
-   *
-   * @param {string} [title] - Optional title for the diagram
-   * @returns {string} Mermaid diagram syntax representing the worflow
-   */
-  generateMermaidDiagram(title?: string): string {
-    const lines: string[] = ["worflow TD"];
-
-    if (title) {
-      lines.push(`  subworflow ${title}`);
-    }
-
-    // Add nodes with styling
-    this.nodes.forEach((node, nodeName) => {
-      const hasEvents = node.events && node.events.length > 0;
-      const hasCondition = !!node.condition;
-
-      // Style nodes based on their properties
-      let style = "";
-      if (hasEvents) {
-        style = "style " + nodeName + " fill:#FFD700,stroke:#DAA520"; // Yellow for event nodes
-      } else if (hasCondition) {
-        style = "style " + nodeName + " fill:#FFA500,stroke:#FF8C00"; // Orange for conditional nodes
-      }
-
-      // Add node definition
-      lines.push(`  ${nodeName}[${nodeName}]`);
-      if (style) {
-        lines.push(`  ${style}`);
-      }
-    });
-
-    // Add connections
-    this.nodes.forEach((node, nodeName) => {
-      if (node.next) {
-        node.next.forEach((nextNode) => {
-          let connectionStyle = "";
-          if (node.condition) {
-            connectionStyle = "---|condition|"; // Add label for conditional connections
-          } else {
-            connectionStyle = "-->"; // Normal connection
-          }
-          lines.push(`  ${nodeName} ${connectionStyle} ${nextNode}`);
-        });
-      }
-
-      // Add event connections if any
-      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}`);
-        });
-        // Add style class for event nodes
-        lines.push("  classDef event fill:#FFD700,stroke:#DAA520");
-      }
-    });
-
-    if (title) {
-      lines.push("  end");
-    }
-
-    return lines.join("\n");
-  }
-
-  /**
-   * Renders the worflow visualization using Mermaid syntax.
-   * This method can be used to visualize the worflow structure in supported environments.
-   *
-   * @param {string} [title] - Optional title for the visualization
-   */
-  visualize(title?: string): void {
-    const diagram = this.generateMermaidDiagram(title);
-    console.log(
-      "To visualize this worflow, use a Mermaid-compatible renderer with this syntax:"
-    );
-    console.log("\n```mermaid");
-    console.log(diagram);
-    console.log("```\n");
-  }
-
-  exportWorkflowToJson<T>(worflow: WorkflowDefinition<T>): string {
-    const result = {
-      worflowName: worflow.name,
-      entryNode: worflow.entryNode,
-      nodes: Object.entries(worflow.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",
-          next: node.next || [],
-        };
-        return acc;
-      }, {} as Record<string, any>),
-    };
-    return JSON.stringify(result, null, 2);
-  }
-}

package/t.py

@@ -1,79 +0,0 @@
-import os
-import platform
-import subprocess
-import urllib.request
-import sys
-
-def download_meilisearch():
-    """Download the Meilisearch binary for the current OS."""
-    print("Checking operating system...")
-    os_name = platform.system().lower()
-    if os_name == "windows":
-        binary_url = "https://github.com/meilisearch/meilisearch/releases/latest/download/meilisearch-windows-amd64.exe"
-        binary_name = "meilisearch.exe"
-    elif os_name == "darwin":  # macOS
-        binary_url = "https://github.com/meilisearch/meilisearch/releases/latest/download/meilisearch-macos-amd64"
-        binary_name = "meilisearch"
-    elif os_name == "linux":
-        binary_url = "https://github.com/meilisearch/meilisearch/releases/latest/download/meilisearch-linux-amd64"
-        binary_name = "meilisearch"
-    else:
-        print(f"Unsupported operating system: {os_name}")
-        sys.exit(1)
-
-    # Download the binary
-    if not os.path.exists(binary_name):
-        print(f"Downloading Meilisearch binary for {os_name}...")
-        try:
-            urllib.request.urlretrieve(binary_url, binary_name)
-            print("Download complete.")
-        except Exception as e:
-            print(f"Failed to download Meilisearch: {e}")
-            sys.exit(1)
-
-        # Add execute permissions for Linux/macOS
-        if os_name != "windows":
-            os.chmod(binary_name, 0o755)
-    else:
-        print("Meilisearch binary already exists.")
-
-    return binary_name
-
-
-def create_data_directory():
-    """Create a directory for Meilisearch data if it doesn't exist."""
-    data_dir = "./data"
-    if not os.path.exists(data_dir):
-        print("Creating data directory...")
-        os.makedirs(data_dir)
-    else:
-        print("Data directory already exists.")
-    return data_dir
-
-def launch_meilisearch(binary_name, data_dir):
-    """Launch the Meilisearch server."""
-    print("Launching Meilisearch...")
-    try:
-        process = subprocess.Popen(
-            [
-                f"./{binary_name}" if platform.system().lower() != "windows" else binary_name,
-                "--db-path",
-                data_dir,
-                "--master-key",
-                "DEFAULT_MASTER_KEY",
-            ],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-        )
-        print("Meilisearch is running! Access it at http://localhost:7700")
-        for line in iter(process.stdout.readline, b""):
-            print("Meilisearch Log:", line.decode().strip())
-    except Exception as e:
-        print(f"Failed to launch Meilisearch: {e}")
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    binary = download_meilisearch()
-    data_directory = create_data_directory()
-    launch_meilisearch(binary, data_directory)

package/t.ts

@@ -1,25 +0,0 @@
-import { deepseek } from "@ai-sdk/deepseek";
-import { streamObject } from "ai";
-import { configDotenv } from "dotenv";
-import { z } from "zod";
-
-configDotenv();
-const model = deepseek("deepseek-chat");
-
-const main = async () => {
-  try {
-    const result = await streamObject({
-      model,
-      schema: z.object({
-        text: z.string(),
-        reason: z.string(),
-      }),
-      prompt: "Tell me why you are so good",
-    });
-  } catch (error) {
-    console.error("🔄 Start handler error:", error);
-    throw error;
-  }
-};
-
-main();

package/test/llm/orchestrator.test.ts

@@ -1,47 +0,0 @@
-import { expect } from "chai";
-import { z } from "zod";
-import { Orchestrator } from "../../llm/orchestrator";
-import { ActionSchema } from "../../types";
-
-describe("Orchestrator", () => {
-  let orchestrator: Orchestrator;
-
-  const mockAction: ActionSchema = {
-    name: "prepare-transaction",
-    description: "Prepare a transfer transaction",
-    parameters: z.object({
-      walletAddress: z.string(),
-      amount: z.string(),
-      networkId: z.string(),
-    }),
-    execute: async ({ walletAddress, amount, networkId }) => {
-      return { walletAddress, amount, networkId };
-    },
-  };
-
-  beforeEach(() => {
-    orchestrator = new Orchestrator([mockAction]);
-  });
-
-  it("should process a prompt and return just the answer", async function () {
-    this.timeout(10000);
-
-    const prompt = "Hello how are you?";
-    const result = await orchestrator.process(prompt);
-
-    expect(result).to.have.property("answer").that.is.a("string");
-  });
-
-  it("should process a prompt and return valid actions", async function () {
-    this.timeout(10000);
-
-    const prompt = "Send 0.1 ETH to 0x123...456 on ethereum";
-    const result = await orchestrator.process(prompt);
-    console.dir(result, { depth: null });
-    expect(result).to.have.property("actions").that.is.an("array");
-    expect(result).to.have.property("answer").that.is.a("string");
-    expect(result.actions[0])
-      .to.have.property("parameters")
-      .that.is.an("object");
-  });
-});

package/test/llm/synthesizer.test.ts

@@ -1,31 +0,0 @@
-// import { expect } from "chai";
-// import { Summarizer } from "../../llm/synthesizer";
-
-// describe("Synthesizer", () => {
-//   let synthesizer: Summarizer;
-
-//   beforeEach(() => {
-//     synthesizer = new Summarizer();
-//   });
-
-//   it("should process results and return a summary", async function () {
-//     this.timeout(10000);
-
-//     const mockResults = JSON.stringify({
-//       result: [
-//         {
-//           name: "prepare-transaction",
-//           result: {
-//             to: "0x123...456",
-//             value: "0.1",
-//             chain: { id: 1, name: "ethereum" },
-//           },
-//         },
-//       ],
-//       initialPrompt: "Send 0.1 ETH to 0x123...456 on ethereum",
-//     });
-
-//     const result = await synthesizer.process(mockResults);
-//     expect(result).to.have.property("response").that.is.a("string");
-//   });
-// });