Release version 0.2.2 with enhanced flow control features

Author: madawei2699

.formatter.exs

@@ -1,4 +1,4 @@
 # Used by "mix format"
 [
-  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
+  inputs: ["{mix,.formatter}.exs", "{config,lib,test,examples}/**/*.{ex,exs}"]
 ]

CHANGELOG.md

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.2] - 2025-03-30
+### Added
+- Enhanced flow control with signal strategies:
+  - Forward strategy (default) - passes signals unchanged to next handler
+  - Transform strategy - modifies signals before passing to next handler
+  - Restart strategy - allows handlers to restart the flow with a new signal
+- Added `continue_on_skip` option to allow flow continuation after a skip result
+- Improved function flow processing with more robust result normalization
+- New enhanced_flow_control.exs example demonstrating all flow control features
+- Added comprehensive flow control documentation in guides/flow_control.md
+
+### Fixed
+- Resolved potential infinite loop issue in restart strategy with termination conditions
+- Fixed minor code formatting and style issues throughout the codebase
+
 ## [0.2.1] - 2025-03-27
 ### Changed
 - Improved code quality and readability throughout the codebase
@@ -48,5 +63,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Tool registry for extensible command execution
 - Comprehensive documentation and examples
 
-[Unreleased]: https://github.com/USERNAME/agent_forge/compare/v0.1.0...HEAD
+[Unreleased]: https://github.com/USERNAME/agent_forge/compare/v0.2.2...HEAD
+[0.2.2]: https://github.com/USERNAME/agent_forge/releases/tag/v0.2.2
 [0.1.0]: https://github.com/USERNAME/agent_forge/releases/tag/v0.1.0

README.md

@@ -32,15 +32,15 @@ graph TB
 # Add to mix.exs
 def deps do
   [
-    {:agent_forge, "~> 0.2.1"}
+    {:agent_forge, "~> 0.2.2"}
   ]
 end
 
 # Run
 mix deps.get
 ```
 
-> **Note**: AgentForge 0.2.1 introduces the plugin system with improved code quality! See the [Plugin System Guide](guides/plugin_system.md) for more details.
+> **Note**: AgentForge 0.2.2 introduces enhanced flow control features! See the [Flow Control Guide](guides/flow_control.md) for more details.
 
 ### Simple Example
 
@@ -146,6 +146,9 @@ See the documentation for more details.
 - [Data Processing](examples/data_processing.exs): Basic data transformation pipeline
 - [Async Workflow](examples/async_workflow.exs): Handling async operations
 - [Configuration-based](examples/config_workflow.exs): YAML-defined workflows
+- [Flow Control](examples/enhanced_flow_control.exs): Advanced flow control features
+- [Limited Workflow](examples/limited_workflow.exs): Execution limits example
+- [Plugin System](examples/plugin_system.exs): Plugin system example
 
 ## Design Philosophy
 

examples/async_workflow.exs

@@ -11,7 +11,8 @@ defmodule AsyncWorkflow do
   def simulate_async_job(caller) do
     # Simulate a background job
     spawn(fn ->
-      Process.sleep(100)  # Very short sleep for example
+      # Very short sleep for example
+      Process.sleep(100)
       send(caller, {:job_complete, %{result: "Completed"}})
     end)
   end
@@ -30,7 +31,8 @@ defmodule AsyncWorkflow do
           message = "Job completed with result: #{inspect(result.result)}"
           {Signal.emit(:notification, message), state}
       after
-        2000 -> # Longer timeout to ensure we catch the message
+        # Longer timeout to ensure we catch the message
+        2000 ->
           {Signal.emit(:error, "Job timed out"), state}
       end
     end

examples/config_workflow.exs

@@ -10,32 +10,39 @@ defmodule ConfigWorkflow do
 
   def validate_field(data, field, rules) do
     value = Map.get(data, String.to_atom(field))
+
     cond do
       rules["required"] && is_nil(value) ->
         {:error, "#{field} is required"}
+
       rules["type"] == "number" && not is_number(value) ->
         {:error, "#{field} must be a number"}
+
       rules["min"] && value < rules["min"] ->
         {:error, "#{field} must be at least #{rules["min"]}"}
+
       true ->
         {:ok, value}
     end
   end
 
   def create_validation_transform(config) do
     fn signal, state ->
-      result = Enum.reduce_while(config["validate"], {:ok, signal.data}, fn rule, {:ok, acc} ->
-        case validate_field(acc, rule["field"], rule) do
-          {:ok, _} ->
-            {:cont, {:ok, acc}}
-          {:error, reason} ->
-            {:halt, {:error, reason}}
-        end
-      end)
+      result =
+        Enum.reduce_while(config["validate"], {:ok, signal.data}, fn rule, {:ok, acc} ->
+          case validate_field(acc, rule["field"], rule) do
+            {:ok, _} ->
+              {:cont, {:ok, acc}}
+
+            {:error, reason} ->
+              {:halt, {:error, reason}}
+          end
+        end)
 
       case result do
         {:ok, data} ->
           {Signal.emit(:validated, data), state}
+
         {:error, reason} ->
           {Signal.halt(reason), state}
       end
@@ -45,12 +52,15 @@ defmodule ConfigWorkflow do
   def create_enrichment_transform(config) do
     fn signal, state ->
       try do
-        enriched_data = Enum.reduce(config["add_fields"], signal.data, fn
-          %{"timestamp" => "now()"}, acc ->
-            Map.put(acc, :timestamp, DateTime.utc_now())
-          field, acc ->
-            Map.merge(acc, field)
-        end)
+        enriched_data =
+          Enum.reduce(config["add_fields"], signal.data, fn
+            %{"timestamp" => "now()"}, acc ->
+              Map.put(acc, :timestamp, DateTime.utc_now())
+
+            field, acc ->
+              Map.merge(acc, field)
+          end)
+
         {Signal.emit(:enriched, enriched_data), state}
       rescue
         e in RuntimeError -> {Signal.emit(:error, e.message), state}
@@ -59,26 +69,30 @@ defmodule ConfigWorkflow do
   end
 
   def create_branch(config, flows) do
-    condition = case config["condition"] do
-      "age >= 18" ->
-        fn signal, _ -> Map.get(signal.data, :age) >= 18 end
-    end
+    condition =
+      case config["condition"] do
+        "age >= 18" ->
+          fn signal, _ -> Map.get(signal.data, :age) >= 18 end
+      end
 
-    then_flow = flows[config["then_flow"]]
-    |> Enum.map(fn step -> create_handler(step, flows) end)
+    then_flow =
+      flows[config["then_flow"]]
+      |> Enum.map(fn step -> create_handler(step, flows) end)
 
-    else_flow = flows[config["else_flow"]]
-    |> Enum.map(fn step -> create_handler(step, flows) end)
+    else_flow =
+      flows[config["else_flow"]]
+      |> Enum.map(fn step -> create_handler(step, flows) end)
 
     Primitives.branch(condition, then_flow, else_flow)
   end
 
   def create_notification(config) do
     fn signal, state ->
       try do
-        message = config["message"]
-        |> String.replace("{name}", to_string(Map.get(signal.data, :name)))
-        |> String.replace("{age}", to_string(Map.get(signal.data, :age)))
+        message =
+          config["message"]
+          |> String.replace("{name}", to_string(Map.get(signal.data, :name)))
+          |> String.replace("{age}", to_string(Map.get(signal.data, :age)))
 
         {Signal.emit(:notification, message), state}
       rescue
@@ -91,10 +105,13 @@ defmodule ConfigWorkflow do
     case {step["type"], step["name"]} do
       {"transform", "validate_input"} ->
         create_validation_transform(step["config"])
+
       {"transform", "enrich_data"} ->
         create_enrichment_transform(step["config"])
+
       {"branch", _} ->
         create_branch(step["config"], flows)
+
       {"notify", _} ->
         create_notification(step["config"])
     end
@@ -180,7 +197,7 @@ defmodule ConfigWorkflow do
     IO.puts("\nUsing #{if File.exists?(yaml_path), do: "YAML configuration", else: "stub data"}")
 
     # Create handlers from configuration
-    handlers = Enum.map(workflow["steps"], & create_handler(&1, workflow["flows"]))
+    handlers = Enum.map(workflow["steps"], &create_handler(&1, workflow["flows"]))
 
     # Test data
     test_cases = [
@@ -200,6 +217,7 @@ defmodule ConfigWorkflow do
       case process_with_error_handling(handlers, signal, state) do
         {:ok, result} ->
           IO.puts("Success: #{inspect(result)}")
+
         {:error, reason} ->
           IO.puts("Error: #{reason}")
       end
@@ -210,11 +228,15 @@ defmodule ConfigWorkflow do
     case Flow.process(handlers, signal, state) do
       {:ok, result, _} ->
         {:ok, result}
+
       {:error, {:badmap, msg}} ->
-        clean_msg = msg
-        |> String.replace(~r/Transform error: expected a map got: "/, "")
-        |> String.replace(~r/"$/, "")
+        clean_msg =
+          msg
+          |> String.replace(~r/Transform error: expected a map got: "/, "")
+          |> String.replace(~r/"$/, "")
+
         {:error, clean_msg}
+
       {:error, reason} ->
         {:error, format_error(reason)}
     end

examples/data_processing.exs

@@ -10,32 +10,36 @@ defmodule DataProcessing do
 
   def process_orders do
     # Define data validation
-    validate_order = Primitives.transform(fn order ->
-      cond do
-        is_nil(order.id) -> raise "Order ID is required"
-        order.amount <= 0 -> raise "Invalid order amount"
-        true -> order
-      end
-    end)
+    validate_order =
+      Primitives.transform(fn order ->
+        cond do
+          is_nil(order.id) -> raise "Order ID is required"
+          order.amount <= 0 -> raise "Invalid order amount"
+          true -> order
+        end
+      end)
 
     # Transform orders to add tax
-    add_tax = Primitives.transform(fn order ->
-      tax = order.amount * 0.1
-      Map.put(order, :total, order.amount + tax)
-    end)
+    add_tax =
+      Primitives.transform(fn order ->
+        tax = order.amount * 0.1
+        Map.put(order, :total, order.amount + tax)
+      end)
 
     # Branch based on order size
-    route_order = Primitives.branch(
-      fn signal, _ -> signal.data.total > 1000 end,
-      [fn signal, state -> {Signal.emit(:large_order, signal.data), state} end],
-      [fn signal, state -> {Signal.emit(:standard_order, signal.data), state} end]
-    )
+    route_order =
+      Primitives.branch(
+        fn signal, _ -> signal.data.total > 1000 end,
+        [fn signal, state -> {Signal.emit(:large_order, signal.data), state} end],
+        [fn signal, state -> {Signal.emit(:standard_order, signal.data), state} end]
+      )
 
     # Create notification for large orders
-    notify_large_order = Primitives.notify(
-      [:console],
-      format: fn order -> "Large order received: ##{order.id} (Total: $#{order.total})" end
-    )
+    notify_large_order =
+      Primitives.notify(
+        [:console],
+        format: fn order -> "Large order received: ##{order.id} (Total: $#{order.total})" end
+      )
 
     # Compose the workflow
     large_order_flow = [
@@ -69,6 +73,7 @@ defmodule DataProcessing do
           case Flow.process(large_order_flow, signal, state2) do
             {:ok, result, _final_state} ->
               IO.puts("Large order processed: #{inspect(result)}")
+
             {:error, reason} ->
               IO.puts("Error processing large order: #{reason}")
           end
@@ -77,6 +82,7 @@ defmodule DataProcessing do
           case Flow.process(standard_order_flow, signal, state2) do
             {:ok, result, _final_state} ->
               IO.puts("Standard order processed: #{inspect(result)}")
+
             {:error, reason} ->
               IO.puts("Error processing standard order: #{reason}")
           end