fix: smallfix workflow

Author: decebal

apps/core/.cargo/audit.toml

@@ -19,12 +19,8 @@ ignore = [
     # tokio-tar PAX header parsing - no fix available, used by datafusion/arrow
     # https://rustsec.org/advisories/RUSTSEC-2025-0111
     "RUSTSEC-2025-0111",
-]
 
-[warnings]
-# Warnings to ignore
-ignore = [
-    # rustls-pemfile unmaintained - used by testcontainers, not critical
+    # rustls-pemfile unmaintained - used by testcontainers, not critical (warning)
     # https://rustsec.org/advisories/RUSTSEC-2025-0134
     "RUSTSEC-2025-0134",
 ]

apps/mcp-server-elixir/lib/mcp_server_elixir/protocol/json_rpc.ex

@@ -24,13 +24,11 @@ defmodule McpServerElixir.Protocol.JsonRpc do
 
   defp validate_request(%{"jsonrpc" => "2.0"} = request) do
     # Validate required fields
-    cond do
-      not Map.has_key?(request, "method") ->
-        {:error, "Missing 'method' field"}
-
+    if Map.has_key?(request, "method") do
       # Request (has id) or notification (no id)
-      true ->
-        {:ok, normalize_request(request)}
+      {:ok, normalize_request(request)}
+    else
+      {:error, "Missing 'method' field"}
     end
   end
 

apps/mcp-server-elixir/lib/mcp_server_elixir/protocol/mcp_tools.ex

@@ -8,7 +8,7 @@ defmodule McpServerElixir.Protocol.McpTools do
 
   require Logger
 
-  alias McpServerElixir.Infrastructure.{CoreClient, ControlPlaneClient}
+  alias McpServerElixir.Infrastructure.{ControlPlaneClient, CoreClient}
   alias McpServerElixir.Protocol.ToonEncoder
 
   @doc """
@@ -30,6 +30,23 @@ defmodule McpServerElixir.Protocol.McpTools do
     ]
   end
 
+  @tool_handlers %{
+    "query_events" => :handle_query_events,
+    "reconstruct_state" => :handle_reconstruct_state,
+    "get_snapshot" => :handle_get_snapshot,
+    "analyze_changes" => :handle_analyze_changes,
+    "find_patterns" => :handle_find_patterns,
+    "compare_entities" => :handle_compare_entities,
+    "event_timeline" => :handle_event_timeline,
+    "explain_entity" => :handle_explain_entity,
+    "ingest_event" => :handle_ingest_event
+  }
+
+  @stateless_tool_handlers %{
+    "get_stats" => :handle_get_stats,
+    "get_cluster_status" => :handle_get_cluster_status
+  }
+
   @doc """
   Call a tool by name with arguments.
 
@@ -42,19 +59,19 @@ defmodule McpServerElixir.Protocol.McpTools do
     format = Map.get(args, "format", nil)
     args_without_format = Map.delete(args, "format")
 
-    case tool_name do
-      "query_events" -> handle_query_events(args_without_format, state, format)
-      "reconstruct_state" -> handle_reconstruct_state(args_without_format, state, format)
-      "get_snapshot" -> handle_get_snapshot(args_without_format, state, format)
-      "analyze_changes" -> handle_analyze_changes(args_without_format, state, format)
-      "find_patterns" -> handle_find_patterns(args_without_format, state, format)
-      "compare_entities" -> handle_compare_entities(args_without_format, state, format)
-      "event_timeline" -> handle_event_timeline(args_without_format, state, format)
-      "explain_entity" -> handle_explain_entity(args_without_format, state, format)
-      "ingest_event" -> handle_ingest_event(args_without_format, state, format)
-      "get_stats" -> handle_get_stats(state, format)
-      "get_cluster_status" -> handle_get_cluster_status(state, format)
-      _ -> {:error, "Unknown tool: #{tool_name}"}
+    dispatch_tool(tool_name, args_without_format, state, format)
+  end
+
+  defp dispatch_tool(tool_name, args, state, format) do
+    cond do
+      handler = Map.get(@tool_handlers, tool_name) ->
+        apply(__MODULE__, handler, [args, state, format])
+
+      handler = Map.get(@stateless_tool_handlers, tool_name) ->
+        apply(__MODULE__, handler, [state, format])
+
+      true ->
+        {:error, "Unknown tool: #{tool_name}"}
     end
   end
 
@@ -273,7 +290,8 @@ defmodule McpServerElixir.Protocol.McpTools do
   # Tool Handlers
   # ============================================================================
 
-  defp handle_query_events(args, state, format) do
+  @doc false
+  def handle_query_events(args, state, format) do
     params = Map.take(args, ["entity_id", "event_type", "as_of", "since", "until", "limit"])
 
     case CoreClient.query_events(state.core_client, params) do
@@ -298,7 +316,8 @@ defmodule McpServerElixir.Protocol.McpTools do
     end
   end
 
-  defp handle_reconstruct_state(args, state, format) do
+  @doc false
+  def handle_reconstruct_state(args, state, format) do
     entity_id = Map.fetch!(args, "entity_id")
     as_of = Map.get(args, "as_of")
 
@@ -334,7 +353,8 @@ defmodule McpServerElixir.Protocol.McpTools do
     end
   end
 
-  defp handle_get_snapshot(args, state, format) do
+  @doc false
+  def handle_get_snapshot(args, state, format) do
     entity_id = Map.fetch!(args, "entity_id")
 
     case CoreClient.get_snapshot(state.core_client, entity_id) do
@@ -358,7 +378,8 @@ defmodule McpServerElixir.Protocol.McpTools do
     end
   end
 
-  defp handle_analyze_changes(args, state, format) do
+  @doc false
+  def handle_analyze_changes(args, state, format) do
     entity_id = Map.fetch!(args, "entity_id")
     from_time = Map.fetch!(args, "from_time")
     to_time = Map.get(args, "to_time")
@@ -406,7 +427,8 @@ defmodule McpServerElixir.Protocol.McpTools do
     end
   end
 
-  defp handle_find_patterns(args, state, format) do
+  @doc false
+  def handle_find_patterns(args, state, format) do
     params = Map.take(args, ["entity_id", "event_type", "since"])
 
     case CoreClient.query_events(state.core_client, params) do
@@ -441,7 +463,8 @@ defmodule McpServerElixir.Protocol.McpTools do
     end
   end
 
-  defp handle_compare_entities(args, state, format) do
+  @doc false
+  def handle_compare_entities(args, state, format) do
     entity_ids = Map.fetch!(args, "entity_ids")
     timeframe = Map.get(args, "timeframe")
 
@@ -491,7 +514,8 @@ defmodule McpServerElixir.Protocol.McpTools do
      }}
   end
 
-  defp handle_event_timeline(args, state, format) do
+  @doc false
+  def handle_event_timeline(args, state, format) do
     entity_id = Map.fetch!(args, "entity_id")
     params = Map.take(args, ["since", "until"])
     params = Map.put(params, "entity_id", entity_id)
@@ -543,7 +567,8 @@ defmodule McpServerElixir.Protocol.McpTools do
     end
   end
 
-  defp handle_explain_entity(args, state, format) do
+  @doc false
+  def handle_explain_entity(args, state, format) do
     entity_id = Map.fetch!(args, "entity_id")
 
     # Get current state
@@ -603,7 +628,8 @@ defmodule McpServerElixir.Protocol.McpTools do
     end
   end
 
-  defp handle_ingest_event(args, state, format) do
+  @doc false
+  def handle_ingest_event(args, state, format) do
     event_data = %{
       "event_type" => Map.fetch!(args, "event_type"),
       "entity_id" => Map.fetch!(args, "entity_id"),
@@ -641,7 +667,8 @@ defmodule McpServerElixir.Protocol.McpTools do
     end
   end
 
-  defp handle_get_stats(state, format) do
+  @doc false
+  def handle_get_stats(state, format) do
     case CoreClient.get_stats(state.core_client) do
       {:ok, stats} ->
         summary = "📊 AllSource Statistics\n\n"
@@ -663,7 +690,8 @@ defmodule McpServerElixir.Protocol.McpTools do
     end
   end
 
-  defp handle_get_cluster_status(state, format) do
+  @doc false
+  def handle_get_cluster_status(state, format) do
     case ControlPlaneClient.get_cluster_status(state.control_client) do
       {:ok, status} ->
         summary = "🎯 Cluster Status\n\n"

apps/mcp-server-elixir/lib/mcp_server_elixir/protocol/toon_encoder.ex

@@ -55,7 +55,7 @@ defmodule McpServerElixir.Protocol.ToonEncoder do
     # Find the list of items to encode
     items = find_tabular_items(data)
 
-    if items != nil and length(items) > 0 do
+    if is_list(items) and items != [] do
       encode_items_as_toon(items)
     else
       {:error, :not_tabular}
@@ -74,7 +74,7 @@ defmodule McpServerElixir.Protocol.ToonEncoder do
   defp find_tabular_items(data) when is_map(data) do
     # Find the first list value that looks tabular
     Enum.find_value(data, fn
-      {_key, value} when is_list(value) and length(value) > 0 ->
+      {_key, [_ | _] = value} ->
         if uniform_list?(value), do: value, else: nil
 
       _ ->
@@ -84,22 +84,13 @@ defmodule McpServerElixir.Protocol.ToonEncoder do
 
   defp find_tabular_items(_), do: nil
 
-  defp encode_items_as_toon(items) when is_list(items) and length(items) > 0 do
-    first_item = List.first(items)
-
+  defp encode_items_as_toon([first_item | _] = items) do
     case first_item do
       item when is_map(item) ->
         keys = Map.keys(item) |> Enum.sort()
         header = "[" <> Enum.join(keys, "|") <> "]"
 
-        rows =
-          Enum.map(items, fn item ->
-            Enum.map(keys, fn key ->
-              value = Map.get(item, key, "")
-              encode_value(value)
-            end)
-            |> Enum.join("|")
-          end)
+        rows = Enum.map(items, fn item -> encode_row(item, keys) end)
 
         {:ok, Enum.join([header | rows], "\n")}
 
@@ -108,8 +99,16 @@ defmodule McpServerElixir.Protocol.ToonEncoder do
     end
   end
 
+  defp encode_items_as_toon([]), do: {:error, :empty_list}
   defp encode_items_as_toon(_), do: {:error, :empty_list}
 
+  defp encode_row(item, keys) do
+    Enum.map_join(keys, "|", fn key ->
+      value = Map.get(item, key, "")
+      encode_value(value)
+    end)
+  end
+
   defp encode_value(nil), do: ""
   defp encode_value(value) when is_binary(value), do: escape_toon_value(value)
   defp encode_value(value) when is_number(value), do: to_string(value)
@@ -147,22 +146,22 @@ defmodule McpServerElixir.Protocol.ToonEncoder do
   def detect_tabular_structure(_), do: {:mixed, nil}
 
   # Check for "events" array with uniform structure
-  defp has_uniform_events?(%{"events" => events}) when is_list(events) and length(events) > 0 do
+  defp has_uniform_events?(%{"events" => [_ | _] = events}) do
     uniform_event_list?(events)
   end
 
-  defp has_uniform_events?(%{events: events}) when is_list(events) and length(events) > 0 do
+  defp has_uniform_events?(%{events: [_ | _] = events}) do
     uniform_event_list?(events)
   end
 
   defp has_uniform_events?(_), do: false
 
   # Check for "items" array with uniform structure
-  defp has_uniform_items?(%{"items" => items}) when is_list(items) and length(items) > 0 do
+  defp has_uniform_items?(%{"items" => [_ | _] = items}) do
     uniform_list?(items)
   end
 
-  defp has_uniform_items?(%{items: items}) when is_list(items) and length(items) > 0 do
+  defp has_uniform_items?(%{items: [_ | _] = items}) do
     uniform_list?(items)
   end
 
@@ -171,7 +170,7 @@ defmodule McpServerElixir.Protocol.ToonEncoder do
   # Check for comparison arrays (entity comparisons, etc.)
   defp has_uniform_comparisons?(data) when is_map(data) do
     Enum.any?(data, fn
-      {_key, value} when is_list(value) and length(value) > 0 ->
+      {_key, [_ | _] = value} ->
         uniform_list?(value)
 
       _ ->
@@ -182,8 +181,7 @@ defmodule McpServerElixir.Protocol.ToonEncoder do
   defp has_uniform_comparisons?(_), do: false
 
   # Check if event list has uniform structure
-  defp uniform_event_list?(events) when length(events) > 0 do
-    first_event = List.first(events)
+  defp uniform_event_list?([first_event | _] = events) do
     first_keys = extract_keys(first_event) |> Enum.sort()
 
     Enum.all?(events, fn event ->
@@ -195,9 +193,7 @@ defmodule McpServerElixir.Protocol.ToonEncoder do
   defp uniform_event_list?(_), do: false
 
   # Check if list has uniform structure
-  defp uniform_list?(items) when length(items) > 0 do
-    first_item = List.first(items)
-
+  defp uniform_list?([first_item | _] = items) do
     case first_item do
       item when is_map(item) ->
         first_keys = extract_keys(item) |> Enum.sort()

apps/mcp-server-elixir/lib/mcp_server_elixir/server.ex

@@ -9,8 +9,8 @@ defmodule McpServerElixir.Server do
   use GenServer
   require Logger
 
+  alias McpServerElixir.Infrastructure.{ControlPlaneClient, CoreClient}
   alias McpServerElixir.Protocol.{JsonRpc, McpTools}
-  alias McpServerElixir.Infrastructure.{CoreClient, ControlPlaneClient}
 
   @server_info %{
     name: "allsource-mcp-elixir",
@@ -89,7 +89,7 @@ defmodule McpServerElixir.Server do
 
           {:error, reason} ->
             Logger.warning("Failed to parse JSON-RPC request: #{inspect(reason)}")
-            send_error(nil, -32700, "Parse error", nil)
+            send_error(nil, -32_700, "Parse error", nil)
         end
     end
   end
@@ -141,7 +141,7 @@ defmodule McpServerElixir.Server do
         send_response(response)
 
       {:error, reason} ->
-        send_error(id, -32603, "Internal error", reason)
+        send_error(id, -32_603, "Internal error", reason)
     end
 
     {:noreply, state}
@@ -154,13 +154,13 @@ defmodule McpServerElixir.Server do
 
   defp process_request(%{method: method, id: id}, state) do
     Logger.warning("Unknown method: #{method}")
-    send_error(id, -32601, "Method not found", nil)
+    send_error(id, -32_601, "Method not found", nil)
     {:noreply, state}
   end
 
   defp process_request(request, state) do
     Logger.warning("Invalid request format: #{inspect(request)}")
-    send_error(nil, -32600, "Invalid Request", nil)
+    send_error(nil, -32_600, "Invalid Request", nil)
     {:noreply, state}
   end
 

apps/query-service/mix.lock

@@ -4,9 +4,6 @@
   "bunt": {:hex, :bunt, "1.0.0", "081c2c665f086849e6d57900292b3a161727ab40431219529f13c4ddcf3e7a44", [:mix], [], "hexpm", "dc5f86aa08a5f6fa6b8096f0735c4e76d54ae5c9fa2c143e5a1fc7c1cd9bb6b5"},
   "certifi": {:hex, :certifi, "2.15.0", "0e6e882fcdaaa0a5a9f2b3db55b1394dba07e8d6d9bcad08318fb604c6839712", [:rebar3], [], "hexpm", "b147ed22ce71d72eafdad94f055165c1c182f61a2ff49df28bcc71d1d5b94a60"},
   "cors_plug": {:hex, :cors_plug, "3.0.3", "7c3ac52b39624bc616db2e937c282f3f623f25f8d550068b6710e58d04a0e330", [:mix], [{:plug, "~> 1.13", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "3f2d759e8c272ed3835fab2ef11b46bddab8c1ab9528167bd463b6452edf830d"},
-  "cowboy": {:hex, :cowboy, "2.14.2", "4008be1df6ade45e4f2a4e9e2d22b36d0b5aba4e20b0a0d7049e28d124e34847", [:make, :rebar3], [{:cowlib, ">= 2.16.0 and < 3.0.0", [hex: :cowlib, repo: "hexpm", optional: false]}, {:ranch, ">= 1.8.0 and < 3.0.0", [hex: :ranch, repo: "hexpm", optional: false]}], "hexpm", "569081da046e7b41b5df36aa359be71a0c8874e5b9cff6f747073fc57baf1ab9"},
-  "cowboy_telemetry": {:hex, :cowboy_telemetry, "0.4.0", "f239f68b588efa7707abce16a84d0d2acf3a0f50571f8bb7f56a15865aae820c", [:rebar3], [{:cowboy, "~> 2.7", [hex: :cowboy, repo: "hexpm", optional: false]}, {:telemetry, "~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "7d98bac1ee4565d31b62d59f8823dfd8356a169e7fcbb83831b8a5397404c9de"},
-  "cowlib": {:hex, :cowlib, "2.16.0", "54592074ebbbb92ee4746c8a8846e5605052f29309d3a873468d76cdf932076f", [:make, :rebar3], [], "hexpm", "7f478d80d66b747344f0ea7708c187645cfcc08b11aa424632f78e25bf05db51"},
   "credo": {:hex, :credo, "1.7.13", "126a0697df6b7b71cd18c81bc92335297839a806b6f62b61d417500d1070ff4e", [:mix], [{:bunt, "~> 0.2.1 or ~> 1.0", [hex: :bunt, repo: "hexpm", optional: false]}, {:file_system, "~> 0.2 or ~> 1.0", [hex: :file_system, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm", "47641e6d2bbff1e241e87695b29f617f1a8f912adea34296fb10ecc3d7e9e84f"},
   "db_connection": {:hex, :db_connection, "2.8.1", "9abdc1e68c34c6163f6fb96a96532272d13ad7ca45262156ae8b7ec6d9dc4bec", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "a61a3d489b239d76f326e03b98794fb8e45168396c925ef25feb405ed09da8fd"},
   "decimal": {:hex, :decimal, "2.3.0", "3ad6255aa77b4a3c4f818171b12d237500e63525c2fd056699967a3e7ea20f62", [:mix], [], "hexpm", "a4d66355cb29cb47c3cf30e71329e58361cfcb37c34235ef3bf1d7bf3773aeac"},
@@ -44,10 +41,8 @@
   "phoenix_pubsub": {:hex, :phoenix_pubsub, "2.2.0", "ff3a5616e1bed6804de7773b92cbccfc0b0f473faf1f63d7daf1206c7aeaaa6f", [:mix], [], "hexpm", "adc313a5bf7136039f63cfd9668fde73bba0765e0614cba80c06ac9460ff3e96"},
   "phoenix_template": {:hex, :phoenix_template, "1.0.4", "e2092c132f3b5e5b2d49c96695342eb36d0ed514c5b252a77048d5969330d639", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}], "hexpm", "2c0c81f0e5c6753faf5cca2f229c9709919aba34fab866d3bc05060c9c444206"},
   "plug": {:hex, :plug, "1.18.1", "5067f26f7745b7e31bc3368bc1a2b818b9779faa959b49c934c17730efc911cf", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "57a57db70df2b422b564437d2d33cf8d33cd16339c1edb190cd11b1a3a546cc2"},
-  "plug_cowboy": {:hex, :plug_cowboy, "2.7.4", "729c752d17cf364e2b8da5bdb34fb5804f56251e88bb602aff48ae0bd8673d11", [:mix], [{:cowboy, "~> 2.7", [hex: :cowboy, repo: "hexpm", optional: false]}, {:cowboy_telemetry, "~> 0.3", [hex: :cowboy_telemetry, repo: "hexpm", optional: false]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "9b85632bd7012615bae0a5d70084deb1b25d2bcbb32cab82d1e9a1e023168aa3"},
   "plug_crypto": {:hex, :plug_crypto, "2.1.1", "19bda8184399cb24afa10be734f84a16ea0a2bc65054e23a62bb10f06bc89491", [:mix], [], "hexpm", "6470bce6ffe41c8bd497612ffde1a7e4af67f36a15eea5f921af71cf3e11247c"},
   "postgrex": {:hex, :postgrex, "0.21.1", "2c5cc830ec11e7a0067dd4d623c049b3ef807e9507a424985b8dcf921224cd88", [:mix], [{:db_connection, "~> 2.1", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.5 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:table, "~> 0.1.0", [hex: :table, repo: "hexpm", optional: true]}], "hexpm", "27d8d21c103c3cc68851b533ff99eef353e6a0ff98dc444ea751de43eb48bdac"},
-  "ranch": {:hex, :ranch, "2.2.0", "25528f82bc8d7c6152c57666ca99ec716510fe0925cb188172f41ce93117b1b0", [:make, :rebar3], [], "hexpm", "fa0b99a1780c80218a4197a59ea8d3bdae32fbff7e88527d7d8a4787eff4f8e7"},
   "redix": {:hex, :redix, "1.5.2", "ab854435a663f01ce7b7847f42f5da067eea7a3a10c0a9d560fa52038fd7ab48", [:mix], [{:castore, "~> 0.1.0 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}, {:nimble_options, "~> 0.5.0 or ~> 1.0", [hex: :nimble_options, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.0 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "78538d184231a5d6912f20567d76a49d1be7d3fca0e1aaaa20f4df8e1142dcb8"},
   "ssl_verify_fun": {:hex, :ssl_verify_fun, "1.1.7", "354c321cf377240c7b8716899e182ce4890c5938111a1296add3ec74cf1715df", [:make, :mix, :rebar3], [], "hexpm", "fe4c190e8f37401d30167c8c405eda19469f34577987c76dde613e838bbc67f8"},
   "telemetry": {:hex, :telemetry, "1.3.0", "fedebbae410d715cf8e7062c96a1ef32ec22e764197f70cda73d82778d61e7a2", [:rebar3], [], "hexpm", "7015fc8919dbe63764f4b4b87a95b7c0996bd539e0d499be6ec9d7f3875b79e6"},