manifold-workflow-engine/dist/cli.js

for building dynamic, LLM-driven workflows using a region-based execution model

#!/usr/bin/env node
import {
  DummyIntentMap,
  ManifoldRegion,
  NestedManifoldRegion,
  WorkflowFunctionManifold,
  WorkflowOperator
} from "./index.js";
import {
  logger_default
} from "./logger.js";

// src/cli.ts
async function demonstrateNestedManifold() {
  logger_default.info("Starting demonstration of nested manifold.");
  const nestedIntentService = new DummyIntentMap;
  const nestedManifold = new WorkflowFunctionManifold(nestedIntentService);
  const validateOp = new WorkflowOperator("validation", async (state) => {
    logger_default.debug("Validating state.");
    await new Promise((resolve) => setTimeout(resolve, 1000));
    return { ...state, validated: true };
  });
  const cleanOp = new WorkflowOperator("cleaning", async (state) => {
    logger_default.debug("Cleaning state.");
    await new Promise((resolve) => setTimeout(resolve, 1000));
    return { ...state, cleaned: true };
  });
  const validateRegion = new ManifoldRegion("validation", [validateOp]);
  const cleanRegion = new ManifoldRegion("cleaning", [cleanOp]);
  validateRegion.connectTo(cleanRegion);
  nestedManifold.addRegion(validateRegion);
  nestedManifold.addRegion(cleanRegion);
  const mainIntentService = new DummyIntentMap;
  const mainManifold = new WorkflowFunctionManifold(mainIntentService);
  const analysisOp = new WorkflowOperator("analysis", async (state) => {
    logger_default.debug("Analyzing state.");
    await new Promise((resolve) => setTimeout(resolve, 1000));
    return { ...state, analyzed: true };
  });
  const transformOp = new WorkflowOperator("transformation", async (state) => {
    logger_default.debug("Transforming state.");
    await new Promise((resolve) => setTimeout(resolve, 1000));
    return { ...state, transformed: true };
  });
  const nestedPreprocessRegion = new NestedManifoldRegion("preprocessing", nestedManifold);
  const analysisRegion = new ManifoldRegion("analysis", [analysisOp]);
  const transformRegion = new ManifoldRegion("transformation", [transformOp]);
  nestedPreprocessRegion.connectTo(analysisRegion);
  analysisRegion.connectTo(transformRegion);
  mainManifold.addRegion(nestedPreprocessRegion);
  mainManifold.addRegion(analysisRegion);
  mainManifold.addRegion(transformRegion);
  const prompts = [
    { text: "validate the input", description: "Nested: Data Validation" },
    { text: "clean the data", description: "Nested: Data Cleaning" },
    { text: "analyze the results", description: "Main: Data Analysis" },
    { text: "transform the output", description: "Main: Data Transformation" }
  ];
  const errorSink = [];
  for (const { text } of prompts) {
    try {
      logger_default.info(`Navigating with prompt: ${text}`);
      await mainManifold.navigate(text);
      logger_default.info(`Executing workflow with prompt: ${text}`);
      await mainManifold.executeWorkflow(text);
    } catch (error) {
      logger_default.error(`Error during workflow execution: ${error}`);
      errorSink.push(error);
    }
  }
  logger_default.info("Nested manifold demonstration completed.");
}
demonstrateNestedManifold().catch((error) => {
  logger_default.error(`Unhandled error: ${error}`);
  process.exit(1);
});