Refactor code for improved readability and consistency in formatting across multiple files

Author: madawei2699

lib/agent_forge/config.ex

@@ -36,9 +36,11 @@ defmodule AgentForge.Config do
           {:ok, handlers} ->
             # Return an executable flow function
             Runtime.configure(handlers)
+
           {:error, reason} ->
             fn _signal -> {:error, reason} end
         end
+
       {:error, reason} ->
         fn _signal -> {:error, reason} end
     end
@@ -71,6 +73,7 @@ defmodule AgentForge.Config do
       String.starts_with?(String.trim(content), "{") ->
         # Looks like JSON
         parse_json(content)
+
       true ->
         # Assume YAML
         parse_yaml(content)
@@ -131,22 +134,31 @@ defmodule AgentForge.Config do
   defp build_transform_step(step) do
     fn_def = step["fn"] || step[:fn]
 
-    transform_fn = case fn_def do
-      "upcase" -> &String.upcase/1
-      "downcase" -> &String.downcase/1
-      "reverse" -> &String.reverse/1
-      custom when is_binary(custom) ->
-        # Safely handle custom function strings
-        fn data ->
-          try do
-            {result, _} = Code.eval_string(custom, [data: data])
-            result
-          rescue
-            e -> raise "Transform evaluation error: #{Exception.message(e)}"
+    transform_fn =
+      case fn_def do
+        "upcase" ->
+          &String.upcase/1
+
+        "downcase" ->
+          &String.downcase/1
+
+        "reverse" ->
+          &String.reverse/1
+
+        custom when is_binary(custom) ->
+          # Safely handle custom function strings
+          fn data ->
+            try do
+              {result, _} = Code.eval_string(custom, data: data)
+              result
+            rescue
+              e -> raise "Transform evaluation error: #{Exception.message(e)}"
+            end
           end
-        end
-      _ -> raise "Invalid transform function: #{inspect(fn_def)}"
-    end
+
+        _ ->
+          raise "Invalid transform function: #{inspect(fn_def)}"
+      end
 
     Primitives.transform(transform_fn)
   end
@@ -174,10 +186,12 @@ defmodule AgentForge.Config do
           data: signal.data,
           signal: signal,
           state: state,
-          String: String  # Allow String module in conditions
+          # Allow String module in conditions
+          String: String
         ]
 
         {result, _} = Code.eval_string(condition_def, bindings)
+
         if is_boolean(result) do
           result
         else
@@ -207,7 +221,8 @@ defmodule AgentForge.Config do
   end
 
   defp build_loop_step(step) do
-    _items_def = step["items"] || step[:items]  # Prefix with _ since it's not used yet
+    # Prefix with _ since it's not used yet
+    _items_def = step["items"] || step[:items]
     action_steps = step["action"] || step[:action] || []
 
     unless is_list(action_steps) do

lib/agent_forge/flow.ex

@@ -61,7 +61,8 @@ defmodule AgentForge.Flow do
   # Private functions
 
   defp process_handlers(handlers, signal, state) do
-    Enum.reduce_while(handlers, {:ok, signal, state}, fn handler, {:ok, current_signal, current_state} ->
+    Enum.reduce_while(handlers, {:ok, signal, state}, fn handler,
+                                                         {:ok, current_signal, current_state} ->
       case process_handler(handler, current_signal, current_state) do
         {{:emit, new_signal}, new_state} ->
           {:cont, {:ok, new_signal, new_state}}

lib/agent_forge/runtime.ex

@@ -6,11 +6,11 @@ defmodule AgentForge.Runtime do
   alias AgentForge.{Flow, Signal, Store, Debug}
 
   @type runtime_options :: [
-    debug: boolean(),
-    name: String.t(),
-    store_prefix: String.t(),
-    store_name: atom()
-  ]
+          debug: boolean(),
+          name: String.t(),
+          store_prefix: String.t(),
+          store_name: atom()
+        ]
 
   @doc """
   Executes a flow with the given signal and options.
@@ -36,14 +36,16 @@ defmodule AgentForge.Runtime do
       "Processed: test"
   """
   @spec execute(Flow.flow(), Signal.t(), runtime_options()) ::
-    {:ok, Signal.t() | term(), term()} | {:error, term()}
+          {:ok, Signal.t() | term(), term()} | {:error, term()}
   def execute(flow, signal, opts \\ []) do
     opts = Keyword.merge([debug: false, name: "flow", store_prefix: "flow"], opts)
 
     # Initialize store if needed
     initial_state =
       case {Keyword.get(opts, :store_key), Keyword.get(opts, :store_name, Store)} do
-        {nil, _} -> %{}
+        {nil, _} ->
+          %{}
+
         {store_key, store_name} ->
           case Store.get(store_name, store_key) do
             {:ok, stored_state} -> stored_state
@@ -64,7 +66,9 @@ defmodule AgentForge.Runtime do
       {:ok, result, final_state} ->
         # Update store if needed
         case {Keyword.get(opts, :store_key), Keyword.get(opts, :store_name, Store)} do
-          {nil, _} -> {:ok, result, final_state}
+          {nil, _} ->
+            {:ok, result, final_state}
+
           {store_key, store_name} ->
             Store.put(store_name, store_key, final_state)
             {:ok, result, final_state}
@@ -88,7 +92,8 @@ defmodule AgentForge.Runtime do
       iex> is_function(runtime, 1)
       true
   """
-  @spec configure(Flow.flow(), runtime_options()) :: (Signal.t() -> {:ok, term(), term()} | {:error, term()})
+  @spec configure(Flow.flow(), runtime_options()) :: (Signal.t() ->
+                                                        {:ok, term(), term()} | {:error, term()})
   def configure(flow, opts \\ []) do
     fn signal -> execute(flow, signal, opts) end
   end
@@ -111,12 +116,13 @@ defmodule AgentForge.Runtime do
       true
   """
   @spec configure_stateful(Flow.flow(), runtime_options()) ::
-    (Signal.t() -> {:ok, term(), term()} | {:error, term()})
+          (Signal.t() -> {:ok, term(), term()} | {:error, term()})
   def configure_stateful(flow, opts \\ []) do
     # Generate a unique store name if not provided
-    store_name = Keyword.get_lazy(opts, :store_name, fn ->
-      :"store_#{:crypto.strong_rand_bytes(4) |> Base.encode16(case: :lower)}"
-    end)
+    store_name =
+      Keyword.get_lazy(opts, :store_name, fn ->
+        :"store_#{:crypto.strong_rand_bytes(4) |> Base.encode16(case: :lower)}"
+      end)
 
     # Generate a unique store key if not provided
     opts =
@@ -135,6 +141,7 @@ defmodule AgentForge.Runtime do
           {:error, {:already_started, _pid}} -> configure(flow, opts)
           error -> error
         end
+
       _pid ->
         configure(flow, opts)
     end

lib/agent_forge/signal.ex

@@ -5,22 +5,22 @@ defmodule AgentForge.Signal do
   """
 
   @type t :: %{
-    type: atom(),
-    data: term(),
-    meta: %{
-      source: String.t() | nil,
-      timestamp: DateTime.t() | nil,
-      trace_id: String.t() | nil,
-      correlation_id: String.t() | nil,
-      custom: map()
-    }
-  }
+          type: atom(),
+          data: term(),
+          meta: %{
+            source: String.t() | nil,
+            timestamp: DateTime.t() | nil,
+            trace_id: String.t() | nil,
+            correlation_id: String.t() | nil,
+            custom: map()
+          }
+        }
 
   @type signal_result ::
-    {:emit, t()} |
-    {:emit_many, [t()]} |
-    {:halt, term()} |
-    :skip
+          {:emit, t()}
+          | {:emit_many, [t()]}
+          | {:halt, term()}
+          | :skip
 
   @doc """
   Creates a new signal with the given type and data.
@@ -115,10 +115,11 @@ defmodule AgentForge.Signal do
       true
   """
   def emit_many(signals) when is_list(signals) do
-    {:emit_many, Enum.map(signals, fn
-      {type, data} -> new(type, data)
-      {type, data, meta} -> new(type, data, meta)
-    end)}
+    {:emit_many,
+     Enum.map(signals, fn
+       {type, data} -> new(type, data)
+       {type, data, meta} -> new(type, data, meta)
+     end)}
   end
 
   @doc """

lib/agent_forge/store.ex

@@ -92,10 +92,12 @@ defmodule AgentForge.Store do
 
   @impl true
   def handle_cast({:update, key, default, fun}, state) do
-    value = case Map.fetch(state, key) do
-      {:ok, current} -> fun.(current)
-      :error -> fun.(default)
-    end
+    value =
+      case Map.fetch(state, key) do
+        {:ok, current} -> fun.(current)
+        :error -> fun.(default)
+      end
+
     {:noreply, Map.put(state, key, value)}
   end
 

lib/agent_forge/tools.ex

@@ -15,7 +15,8 @@ defmodule AgentForge.Tools do
   @doc """
   Registers a tool function with a given name.
   """
-  def register(name, function, registry \\ __MODULE__) when is_binary(name) and is_function(function, 1) do
+  def register(name, function, registry \\ __MODULE__)
+      when is_binary(name) and is_function(function, 1) do
     GenServer.call(registry, {:register, name, function})
   end
 
@@ -49,17 +50,21 @@ defmodule AgentForge.Tools do
         {:ok, tool_fn} ->
           try do
             result = tool_fn.(signal.data)
-            meta = Map.merge(signal.meta, %{
-              tool: name,
-              parent_trace_id: signal.meta.trace_id,
-              last_tool: name
-            })
+
+            meta =
+              Map.merge(signal.meta, %{
+                tool: name,
+                parent_trace_id: signal.meta.trace_id,
+                last_tool: name
+              })
+
             {{:emit, Signal.new(:tool_result, result, meta)}, state}
           rescue
             e ->
               meta = Map.merge(signal.meta, %{tool: name})
               {{:emit, Signal.new(:error, "Tool error: #{Exception.message(e)}", meta)}, state}
           end
+
         {:error, reason} ->
           meta = Map.merge(signal.meta, %{tool: name})
           {{:emit, Signal.new(:error, reason, meta)}, state}
@@ -72,34 +77,40 @@ defmodule AgentForge.Tools do
   """
   def execute_pipeline(tool_names, registry \\ __MODULE__) when is_list(tool_names) do
     fn signal, state ->
-      results = Enum.reduce_while(tool_names, [], fn name, acc ->
-        case get(name, registry) do
-          {:ok, tool_fn} ->
-            try do
-              result = tool_fn.(signal.data)
-              meta = Map.merge(signal.meta, %{
-                tool: name,
-                last_tool: name,
-                parent_trace_id: signal.meta.trace_id
-              })
-              new_signal = Signal.new(:tool_result, result, meta)
-              {:cont, [new_signal | acc]}
-            rescue
-              e ->
-                meta = Map.merge(signal.meta, %{tool: name})
-                signal = Signal.new(:error, "Tool error: #{Exception.message(e)}", meta)
-                {:halt, {:error, signal}}
-            end
-          {:error, reason} ->
-            meta = Map.merge(signal.meta, %{tool: name})
-            signal = Signal.new(:error, reason, meta)
-            {:halt, {:error, signal}}
-        end
-      end)
+      results =
+        Enum.reduce_while(tool_names, [], fn name, acc ->
+          case get(name, registry) do
+            {:ok, tool_fn} ->
+              try do
+                result = tool_fn.(signal.data)
+
+                meta =
+                  Map.merge(signal.meta, %{
+                    tool: name,
+                    last_tool: name,
+                    parent_trace_id: signal.meta.trace_id
+                  })
+
+                new_signal = Signal.new(:tool_result, result, meta)
+                {:cont, [new_signal | acc]}
+              rescue
+                e ->
+                  meta = Map.merge(signal.meta, %{tool: name})
+                  signal = Signal.new(:error, "Tool error: #{Exception.message(e)}", meta)
+                  {:halt, {:error, signal}}
+              end
+
+            {:error, reason} ->
+              meta = Map.merge(signal.meta, %{tool: name})
+              signal = Signal.new(:error, reason, meta)
+              {:halt, {:error, signal}}
+          end
+        end)
 
       case results do
         {:error, error_signal} ->
           {{:emit, error_signal}, state}
+
         signals when is_list(signals) ->
           {{:emit_many, Enum.reverse(signals)}, state}
       end

mix.exs

@@ -43,8 +43,10 @@ defmodule AgentForge.MixProject do
     [
       {:jason, "~> 1.4"},
       {:excoveralls, "~> 0.18", only: :test},
-      {:yaml_elixir, "~> 2.9"},  # YAML support
-      {:meck, "~> 0.9", only: :test},  # For mocking in tests
+      # YAML support
+      {:yaml_elixir, "~> 2.9"},
+      # For mocking in tests
+      {:meck, "~> 0.9", only: :test},
       {:ex_doc, "~> 0.29", only: :dev, runtime: false}
     ]
   end
@@ -64,25 +66,25 @@ defmodule AgentForge.MixProject do
       extras: ["README.md", "CHANGELOG.md", "LICENSE"] ++ Path.wildcard("guides/*.md"),
       extra_section: "GUIDES",
       groups_for_extras: [
-        "Guides": Path.wildcard("guides/*.md")
+        Guides: Path.wildcard("guides/*.md")
       ],
       groups_for_modules: [
-        "Core": [
+        Core: [
           AgentForge,
           AgentForge.Signal,
           AgentForge.Flow,
           AgentForge.Store
         ],
-        "Primitives": [
+        Primitives: [
           AgentForge.Primitives
         ],
         "Dynamic Flows": [
           AgentForge.DynamicFlow
         ],
-        "Configuration": [
+        Configuration: [
           AgentForge.Config
         ],
-        "Utilities": [
+        Utilities: [
           AgentForge.Debug,
           AgentForge.Tools,
           AgentForge.Runtime