Enhancement: Control Flow Examples and Mapping Workflow Implementation

packages/cue/src/examples/control-flows/branch.ts

@@ -0,0 +1,64 @@
+import { Cue } from '../../../src/cue';
+import { z } from 'zod';
+import { log, monitorCue } from './utils/logger';
+
+// Create branch workflow
+const createBranchWorkflow = () => {
+  // Define blocks
+  const greaterThanBlock = Cue.createBlock({
+    id: 'greater-than',
+    inputSchema: z.number(),
+    outputSchema: z.string(),
+    execute: async ({ inputData }) => {
+      const result = `Number ${inputData} is greater than 10`;
+      log('Greater than block executed', { input: inputData, result });
+      return result;
+    },
+  });
+
+  const lessThanBlock = Cue.createBlock({
+    id: 'less-than',
+    inputSchema: z.number(),
+    outputSchema: z.string(),
+    execute: async ({ inputData }) => {
+      const result = `Number ${inputData} is less than or equal to 10`;
+      log('Less than block executed', { input: inputData, result });
+      return result;
+    },
+  });
+
+  const cue = Cue.createCue({
+    id: 'branch-workflow',
+    inputSchema: z.number(),
+    outputSchema: z.string(),
+  });
+
+  // Create conditional branches
+  cue.branch([
+    [async ({ inputData }) => inputData > 10, greaterThanBlock],
+    [async ({ inputData }) => inputData <= 10, lessThanBlock],
+  ]);
+
+  return cue;
+};
+
+// Example usage
+const main = async () => {
+  try {
+    const workflow = createBranchWorkflow();
+    const unsubscribeMain = monitorCue(workflow);
+
+    // Test with different numbers
+    const results = await Promise.all([
+      workflow.start(5), // Should use lessThanBlock
+      workflow.start(15), // Should use greaterThanBlock
+    ]);
+
+    log('Final results:', results);
+    unsubscribeMain();
+  } catch (error) {
+    console.error('Error:', error);
+  }
+};
+
+main();

packages/cue/src/examples/control-flows/loops/dountil.ts

@@ -0,0 +1,49 @@
+import { Cue } from '../../../../src/cue';
+import { z } from 'zod';
+import { log, monitorCue } from '../utils/logger';
+
+// Create do-until workflow
+const createDoUntilWorkflow = () => {
+  // Define block
+  const counterBlock = Cue.createBlock({
+    id: 'counter',
+    inputSchema: z.number(),
+    outputSchema: z.number(),
+    execute: async ({ inputData }) => {
+      const result = inputData + 1;
+      log('Counter block executed', { input: inputData, result });
+      return result;
+    },
+  });
+
+  const cue = Cue.createCue({
+    id: 'dountil-workflow',
+    inputSchema: z.number(),
+    outputSchema: z.number(),
+  });
+
+  // Execute block until condition becomes true
+  cue.dountil(
+    counterBlock,
+    async ({ inputData }) => inputData >= 5 // Stop when number reaches or exceeds 5
+  );
+
+  return cue;
+};
+
+// Example usage
+const main = async () => {
+  try {
+    const workflow = createDoUntilWorkflow();
+    const unsubscribeMain = monitorCue(workflow);
+
+    const result = await workflow.start(1); // Start from 1
+
+    log('Final result:', result);
+    unsubscribeMain();
+  } catch (error) {
+    console.error('Error:', error);
+  }
+};
+
+main();

packages/cue/src/examples/control-flows/loops/dowhile.ts

@@ -0,0 +1,49 @@
+import { Cue } from '../../../../src/cue';
+import { z } from 'zod';
+import { log, monitorCue } from '../utils/logger';
+
+// Create do-while workflow
+const createDoWhileWorkflow = () => {
+  // Define block
+  const counterBlock = Cue.createBlock({
+    id: 'counter',
+    inputSchema: z.number(),
+    outputSchema: z.number(),
+    execute: async ({ inputData }) => {
+      const result = inputData + 1;
+      log('Counter block executed', { input: inputData, result });
+      return result;
+    },
+  });
+
+  const cue = Cue.createCue({
+    id: 'dowhile-workflow',
+    inputSchema: z.number(),
+    outputSchema: z.number(),
+  });
+
+  // Execute block while condition is true
+  cue.dowhile(
+    counterBlock,
+    async ({ inputData }) => inputData < 5 // Continue while number is less than 5
+  );
+
+  return cue;
+};
+
+// Example usage
+const main = async () => {
+  try {
+    const workflow = createDoWhileWorkflow();
+    const unsubscribeMain = monitorCue(workflow);
+
+    const result = await workflow.start(1); // Start from 1
+
+    log('Final result:', result);
+    unsubscribeMain();
+  } catch (error) {
+    console.error('Error:', error);
+  }
+};
+
+main();

packages/cue/src/examples/control-flows/loops/foreach.ts

@@ -0,0 +1,46 @@
+import { Cue } from '../../../../src/cue';
+import { z } from 'zod';
+import { log, monitorCue } from '../utils/logger';
+
+// Create foreach workflow
+const createForEachWorkflow = () => {
+  // Define block
+  const processItemBlock = Cue.createBlock({
+    id: 'process-item',
+    inputSchema: z.number(),
+    outputSchema: z.number(),
+    execute: async ({ inputData }) => {
+      const result = inputData * 3;
+      log('Process item block executed', { input: inputData, result });
+      return result;
+    },
+  });
+
+  const cue = Cue.createCue({
+    id: 'foreach-workflow',
+    inputSchema: z.array(z.number()),
+    outputSchema: z.array(z.number()),
+  });
+
+  // Process each item in the array
+  cue.foreach(processItemBlock);
+
+  return cue;
+};
+
+// Example usage
+const main = async () => {
+  try {
+    const workflow = createForEachWorkflow();
+    const unsubscribeMain = monitorCue(workflow);
+
+    const result = await workflow.start([1, 2, 3, 4, 5]);
+
+    log('Final result:', result);
+    unsubscribeMain();
+  } catch (error) {
+    console.error('Error:', error);
+  }
+};
+
+main();

packages/cue/src/examples/control-flows/map.ts

@@ -0,0 +1,82 @@
+import { Cue } from '../../cue';
+import { z } from 'zod';
+import { log, monitorCue } from './utils/logger';
+
+// Create mapping workflow
+const createMappingWorkflow = () => {
+  // Define blocks
+  const multiplyBlock = Cue.createBlock({
+    id: 'multiply',
+    inputSchema: z.number(),
+    outputSchema: z.object({
+      original: z.number(),
+      multiplied: z.number(),
+    }),
+    execute: async ({ inputData }) => {
+      const result = {
+        original: inputData,
+        multiplied: inputData * 2,
+      };
+      log('Multiply block executed', { input: inputData, result });
+      return result;
+    },
+  });
+
+  const addBlock = Cue.createBlock({
+    id: 'add',
+    inputSchema: z.object({
+      value: z.number(),
+      increment: z.number(),
+    }),
+    outputSchema: z.number(),
+    execute: async ({ inputData }) => {
+      const result = inputData.value + inputData.increment;
+      log('Add block executed', { input: inputData, result });
+      return result;
+    },
+  });
+
+  const cue = Cue.createCue({
+    id: 'mapping-workflow',
+    inputSchema: z.number(),
+    outputSchema: z.number(),
+  });
+
+  // Chain blocks with mapping
+  cue
+    .then(multiplyBlock)
+    .map({
+      value: {
+        block: multiplyBlock,
+        path: 'multiplied',
+      },
+      increment: {
+        value: 5,
+        schema: z.number(),
+      },
+    })
+    .then(addBlock);
+
+  return cue;
+};
+
+// Example usage
+const main = async () => {
+  try {
+    const workflow = createMappingWorkflow();
+    const unsubscribeMain = monitorCue(workflow);
+
+    const result = await workflow.start(3); // Input: 3
+    // Expected flow:
+    // 1. multiplyBlock: 3 -> { original: 3, multiplied: 6 }
+    // 2. map: { value: 6, increment: 5 }
+    // 3. addBlock: 6 + 5 -> 11
+
+    log('Final result:', result);
+    unsubscribeMain();
+  } catch (error) {
+    console.error('Error:', error);
+  }
+};
+
+main();

packages/cue/src/examples/control-flows/parallel.ts

@@ -0,0 +1,60 @@
+import { Cue } from '../../../src/cue';
+import { z } from 'zod';
+import { log, monitorCue } from './utils/logger';
+
+// Create parallel workflow
+const createParallelWorkflow = () => {
+  // Define blocks
+  const squareBlock = Cue.createBlock({
+    id: 'square',
+    inputSchema: z.number(),
+    outputSchema: z.number(),
+    execute: async ({ inputData }) => {
+      const result = inputData * inputData;
+      log('Square block executed', { input: inputData, result });
+      return result;
+    },
+  });
+
+  const cubeBlock = Cue.createBlock({
+    id: 'cube',
+    inputSchema: z.number(),
+    outputSchema: z.number(),
+    execute: async ({ inputData }) => {
+      const result = inputData * inputData * inputData;
+      log('Cube block executed', { input: inputData, result });
+      return result;
+    },
+  });
+
+  const cue = Cue.createCue({
+    id: 'parallel-workflow',
+    inputSchema: z.number(),
+    outputSchema: z.object({
+      square: z.number(),
+      cube: z.number(),
+    }),
+  });
+
+  // Execute blocks in parallel
+  cue.parallel([squareBlock, cubeBlock]);
+
+  return cue;
+};
+
+// Example usage
+const main = async () => {
+  try {
+    const workflow = createParallelWorkflow();
+    const unsubscribeMain = monitorCue(workflow);
+
+    const result = await workflow.start(5);
+
+    log('Final result:', result);
+    unsubscribeMain();
+  } catch (error) {
+    console.error('Error:', error);
+  }
+};
+
+main();