From b15ab00e85013ccc9bf7079a3546b663961eea60 Mon Sep 17 00:00:00 2001
From: Jose Luis Latorre Millas <joslat@gmail.com>
Date: Tue, 17 Dec 2024 15:01:45 +0100
Subject: [PATCH] improved fluent syntax  and test

---
 .../Step00/Step00_Processes.cs                | 36 ++--------
 .../Process.Core/ProcessBuilder.cs            | 72 +++++++++++++++++++
 2 files changed, 79 insertions(+), 29 deletions(-)

diff --git a/dotnet/samples/GettingStartedWithProcesses/Step00/Step00_Processes.cs b/dotnet/samples/GettingStartedWithProcesses/Step00/Step00_Processes.cs
index 1fce9ca23921..4896586472ac 100644
--- a/dotnet/samples/GettingStartedWithProcesses/Step00/Step00_Processes.cs
+++ b/dotnet/samples/GettingStartedWithProcesses/Step00/Step00_Processes.cs
@@ -25,43 +25,21 @@ public async Task UseSimplestProcessAsync()
     {
         // Create a simple kernel 
         Kernel kernel = Kernel.CreateBuilder()
-            .Build();
+        .Build();
 
         ProcessBuilder processBuilder = new(nameof(Step00_Processes));
 
-        // Create a process that will interact with the chat completion service
-        ProcessBuilder process = new("ChatBot");
-        var startStep = processBuilder.AddStepFromType<StartStep>();
-        var doSomeWorkStep = processBuilder.AddStepFromType<DoSomeWorkStep>();
-        var doMoreWorkStep = processBuilder.AddStepFromType<DoMoreWorkStep>();
-        var lastStep = processBuilder.AddStepFromType<LastStep>();
-
-        // Define the process flow
         processBuilder
-            .OnInputEvent(ProcessEvents.StartProcess)
-            .SendEventTo(new ProcessFunctionTargetBuilder(startStep));
-
-        startStep
-            .OnFunctionResult()
-            .SendEventTo(new ProcessFunctionTargetBuilder(doSomeWorkStep));
-
-        doSomeWorkStep
-            .OnFunctionResult()
-            .SendEventTo(new ProcessFunctionTargetBuilder(doMoreWorkStep));
-
-        doMoreWorkStep
-            .OnFunctionResult()
-            .SendEventTo(new ProcessFunctionTargetBuilder(lastStep));
-
-        lastStep
-            .OnFunctionResult()
-            .StopProcess();
+            .StartWith<StartStep>(ProcessEvents.StartProcess)
+            .AndThen<DoSomeWorkStep>()
+            .AndThen<DoMoreWorkStep>()
+            .AndFinally<LastStep>();
 
         // Build the process to get a handle that can be started
-        KernelProcess kernelProcess = process.Build();
+        KernelProcess kernelProcess = processBuilder.Build();
 
         // Start the process with an initial external event
-        using var runningProcess = await kernelProcess.StartAsync(
+        using var runningProcess = await kernelProcess!.StartAsync(
             kernel,
                 new KernelProcessEvent()
                 {
diff --git a/dotnet/src/Experimental/Process.Core/ProcessBuilder.cs b/dotnet/src/Experimental/Process.Core/ProcessBuilder.cs
index e475017af6ba..2ed5be73dfbf 100644
--- a/dotnet/src/Experimental/Process.Core/ProcessBuilder.cs
+++ b/dotnet/src/Experimental/Process.Core/ProcessBuilder.cs
@@ -315,5 +315,77 @@ public ProcessBuilder(string name)
     {
     }
 
+    /// <summary>
+    /// Starts the process with the specified step and binds it to the given input event.
+    /// </summary>
+    /// <typeparam name="TStep">The step type to start the process.</typeparam>
+    /// <param name="eventName">The name of the input event that triggers the start.</param>
+    /// <param name="name">Optional: The name of the step.</param>
+    /// <returns>The current ProcessBuilder instance.</returns>
+    public ProcessBuilder StartWith<TStep>(string eventName, string? name = null) where TStep : KernelProcessStep
+    {
+        Verify.NotNullOrWhiteSpace(eventName, nameof(eventName));
+
+        // Add the first step
+        var stepBuilder = this.AddStepFromType<TStep>(name);
+
+        // Bind the step to the input event
+        this.OnInputEvent(eventName)
+            .SendEventTo(new ProcessFunctionTargetBuilder(stepBuilder));
+
+        return this;
+    }
+
+    /// <summary>
+    /// Chains the next step in the process using an input event or a function result.
+    /// </summary>
+    /// <typeparam name="TStep">The step type to add next.</typeparam>
+    /// <param name="eventOrFunctionName">The event name or function name that triggers this transition.</param>
+    /// <param name="name">Optional: The name of the step.</param>
+    /// <returns>The current ProcessBuilder instance.</returns>
+    public ProcessBuilder AndThen<TStep>(string? eventOrFunctionName = null, string? name = null) where TStep : KernelProcessStep
+    {
+        // Ensure there is a previous step
+        if (this._steps.Count == 0)
+        {
+            throw new InvalidOperationException("AndThen cannot be called before StartWith.");
+        }
+
+        // Get the previous step
+        var previousStepBuilder = this._steps.Last();
+
+        // Add the next step
+        var nextStepBuilder = this.AddStepFromType<TStep>(name);
+
+        // Determine the edge builder from the previous step
+        ProcessStepEdgeBuilder edgeBuilder = string.IsNullOrWhiteSpace(eventOrFunctionName)
+            ? previousStepBuilder.OnFunctionResult() // Default to OnFunctionResult
+            : previousStepBuilder.OnEvent(eventOrFunctionName); // Use OnEvent if specified
+
+        // Link the edge to the next step
+        edgeBuilder.SendEventTo(new ProcessFunctionTargetBuilder(nextStepBuilder));
+
+        return this;
+    }
+
+    /// <summary>
+    /// Marks the final step in the process and stops the process automatically.
+    /// </summary>
+    /// <typeparam name="TStep">The step type to add as the final step.</typeparam>
+    /// <param name="eventOrFunctionName">The event name or function name that triggers this transition.</param>
+    /// <param name="name">Optional: The name of the step.</param>
+    /// <returns>The current ProcessBuilder instance.</returns>
+    public ProcessBuilder AndFinally<TStep>(string? eventOrFunctionName = null, string? name = null) where TStep : KernelProcessStep
+    {
+        this.AndThen<TStep>(eventOrFunctionName, name);
+
+        // Get the final step
+        var finalStepBuilder = this._steps.Last();
+
+        finalStepBuilder.OnFunctionResult().StopProcess();
+
+        return this;
+    }
+
     #endregion
 }