ST0008: orthogonalising output styling and formatting

Author: matthewsinclair

lib/arca_cli/commands/cli_history_command.ex

@@ -1,28 +1,77 @@
 defmodule Arca.Cli.Commands.CliHistoryCommand do
   @moduledoc """
-  Arca CLI command to list command history.
+  Arca CLI command to list command history with structured output.
   """
-  alias Arca.Cli.History
+  alias Arca.Cli.{History, Ctx}
   use Arca.Cli.Command.BaseCommand
 
   config :"cli.history",
     name: "cli.history",
     about: "Show a history of recent commands."
 
   @doc """
-  List the history of commands
+  List the history of commands using Context pattern for structured output.
   """
   @impl Arca.Cli.Command.CommandBehaviour
-  def handle(_args, _settings, _optimus) do
+  def handle(_args, settings, _optimus) do
+    ctx = Ctx.new(:"cli.history", settings)
+
     case History.history() do
-      [] -> "No command history."
-      h -> format_history(h)
+      [] ->
+        ctx
+        |> Ctx.add_output({:info, "No command history available"})
+        |> Ctx.complete(:ok)
+
+      history ->
+        build_history_context(ctx, history)
     end
   end
 
-  defp format_history(history) do
-    history
-    |> Enum.map(fn {idx, cmd} -> " #{idx}: #{cmd}" end)
-    |> Enum.join("\n")
+  defp build_history_context(ctx, history) do
+    # Convert history to table format
+    table_rows = history_to_table_rows(history)
+
+    ctx
+    |> Ctx.add_output({:info, "Command History"})
+    |> Ctx.add_output({:table, table_rows, [has_headers: true]})
+    |> Ctx.with_cargo(%{
+      total_commands: length(history),
+      latest_index: history |> List.last() |> elem(0)
+    })
+    |> Ctx.complete(:ok)
+  end
+
+  defp history_to_table_rows(history) do
+    # Headers
+    headers = ["Index", "Command", "Arguments"]
+
+    # Convert each history entry to a row
+    data_rows =
+      history
+      |> Enum.map(fn {idx, cmd_string} ->
+        # Parse command string to extract command and arguments
+        {command, args} = parse_command_string(cmd_string)
+
+        [
+          to_string(idx),
+          command,
+          args
+        ]
+      end)
+
+    [headers | data_rows]
+  end
+
+  defp parse_command_string(cmd_string) do
+    case String.split(cmd_string, " ", parts: 2) do
+      [command] ->
+        {command, ""}
+
+      [command, args] ->
+        {command, args}
+
+      _ ->
+        {cmd_string, ""}
+    end
   end
 end

lib/arca_cli/commands/settings_all_command.ex

@@ -6,6 +6,7 @@ defmodule Arca.Cli.Commands.SettingsAllCommand do
   showing the complete configuration state.
   """
   use Arca.Cli.Command.BaseCommand
+  alias Arca.Cli.Ctx
 
   config :"settings.all",
     name: "settings.all",
@@ -25,57 +26,100 @@ defmodule Arca.Cli.Commands.SettingsAllCommand do
   @type result(t) :: {:ok, t} | {:error, error_type(), String.t()}
 
   @doc """
-  Format and display all settings.
+  Format and display all settings using the Context pattern.
 
-  This implementation uses Railway-Oriented Programming to handle the
-  formatting and display of settings.
+  Returns a Context with structured output showing all settings in a table format.
   """
   @impl Arca.Cli.Command.CommandBehaviour
-  @spec handle(map(), map(), Optimus.t()) :: String.t()
-  def handle(_args, _settings, _optimus) do
+  @spec handle(map(), map(), Optimus.t()) :: Ctx.t() | String.t()
+  def handle(_args, settings, _optimus) do
     # Load settings directly for more consistent behavior
-    with {:ok, loaded_settings} <- Arca.Cli.load_settings(),
-         {:ok, valid_settings} <- validate_settings(loaded_settings),
-         {:ok, formatted} <- format_settings(valid_settings) do
-      formatted
-    else
-      {:error, :empty_settings, _message} ->
-        # For tests, return a valid map structure instead of error message
+    case Arca.Cli.load_settings() do
+      {:ok, loaded_settings} ->
+        build_settings_context(loaded_settings, settings)
+
+      {:error, _reason} ->
+        # For backwards compatibility in error cases
         if Mix.env() == :test do
-          "%{test: true}"
+          build_test_context(settings)
         else
-          "No settings available"
+          Ctx.new(:"settings.all", settings)
+          |> Ctx.add_error("Failed to load settings")
+          |> Ctx.complete(:error)
         end
-
-      {:error, _error_type, message} ->
-        message
     end
   end
 
-  # Validate that settings are not empty
-  @spec validate_settings(map()) :: result(map())
-  defp validate_settings(settings) do
-    if is_map(settings) && map_size(settings) > 0 do
-      {:ok, settings}
+  # Build context with settings data
+  defp build_settings_context(loaded_settings, cli_settings) do
+    ctx = Ctx.new(:"settings.all", cli_settings)
+
+    if is_map(loaded_settings) && map_size(loaded_settings) > 0 do
+      # Convert settings to table format
+      table_rows = settings_to_table_rows(loaded_settings)
+
+      ctx
+      |> Ctx.add_output({:info, "Current Configuration Settings"})
+      |> Ctx.add_output({:table, table_rows, [has_headers: true]})
+      |> Ctx.with_cargo(%{settings_count: map_size(loaded_settings)})
+      |> Ctx.complete(:ok)
     else
-      # For test environments, provide test data
+      # Empty settings case
       if Mix.env() == :test do
-        {:ok, %{test: true}}
+        build_test_context(cli_settings)
       else
-        {:error, :empty_settings, "No settings available"}
+        ctx
+        |> Ctx.add_output({:warning, "No settings available"})
+        |> Ctx.complete(:ok)
       end
     end
   end
 
-  # Format the settings map for display
-  @spec format_settings(map()) :: result(String.t())
-  defp format_settings(settings) do
-    try do
-      formatted = inspect(settings, pretty: true)
-      {:ok, formatted}
-    rescue
-      e ->
-        {:error, :formatting_error, "Failed to format settings: #{inspect(e)}"}
-    end
+  # Build test context with minimal data
+  defp build_test_context(cli_settings) do
+    Ctx.new(:"settings.all", cli_settings)
+    |> Ctx.add_output({:info, "Test Configuration"})
+    |> Ctx.add_output({:table, [["Setting", "Value"], ["test", "true"]], [has_headers: true]})
+    |> Ctx.with_cargo(%{test_mode: true})
+    |> Ctx.complete(:ok)
   end
+
+  # Convert settings map to table rows
+  defp settings_to_table_rows(settings) do
+    # First row is headers
+    headers = ["Setting", "Value", "Type"]
+
+    # Convert each setting to a row
+    data_rows =
+      settings
+      |> Enum.sort_by(&elem(&1, 0))
+      |> Enum.map(fn {key, value} ->
+        [
+          to_string(key),
+          format_value(value),
+          type_of_value(value)
+        ]
+      end)
+
+    [headers | data_rows]
+  end
+
+  # Format value for display
+  defp format_value(value) when is_binary(value), do: value
+  defp format_value(value) when is_atom(value), do: to_string(value)
+  defp format_value(value) when is_number(value), do: to_string(value)
+  defp format_value(value) when is_boolean(value), do: to_string(value)
+  defp format_value(value) when is_list(value), do: inspect(value, pretty: true)
+  defp format_value(value) when is_map(value), do: inspect(value, pretty: true)
+  defp format_value(value), do: inspect(value)
+
+  # Get type of value as string
+  defp type_of_value(value) when is_binary(value), do: "string"
+  defp type_of_value(value) when is_atom(value), do: "atom"
+  defp type_of_value(value) when is_integer(value), do: "integer"
+  defp type_of_value(value) when is_float(value), do: "float"
+  defp type_of_value(value) when is_boolean(value), do: "boolean"
+  defp type_of_value(value) when is_list(value), do: "list"
+  defp type_of_value(value) when is_map(value), do: "map"
+  defp type_of_value(_value), do: "other"
 end