fix: resolve CI failures (format, credo, dialyzer)

- Run mix format on all files
- Fix Credo alias ordering in index.ex
- Remove unreachable V1 build_backup clause (Dialyzer pattern_match_cov)
- Extract unwrap_command_result/evaluate_condition_then_cas helpers to
  reduce put_if/delete_if cyclomatic complexity below Credo threshold
- Fix ra_system.fetch pattern match in application.ex (returns map, not tuple)

Author: GSMLG-BOT

lib/concord.ex

@@ -205,40 +205,16 @@ defmodule Concord do
       result =
         cond do
           expected != nil ->
-            # Direct CAS — no functions in the command
-            case command({:put_if, key, compressed_value, expires_at, expected}, timeout) do
-              {:ok, :ok, _} -> :ok
-              {:ok, {:error, reason}, _} -> {:error, reason}
-              {:timeout, _} -> {:error, :timeout}
-              {:error, :noproc} -> {:error, :cluster_not_ready}
-              {:error, reason} -> {:error, reason}
-            end
+            unwrap_command_result({:put_if, key, compressed_value, expires_at, expected}, timeout)
 
           condition_fn != nil ->
-            # Evaluate condition pre-consensus, then CAS
-            case get(key, Keyword.take(opts, [:token, :timeout, :consistency])) do
-              {:ok, current_value} ->
-                if condition_fn.(current_value) do
-                  case command(
-                         {:put_if, key, compressed_value, expires_at, current_value},
-                         timeout
-                       ) do
-                    {:ok, :ok, _} -> :ok
-                    {:ok, {:error, reason}, _} -> {:error, reason}
-                    {:timeout, _} -> {:error, :timeout}
-                    {:error, :noproc} -> {:error, :cluster_not_ready}
-                    {:error, reason} -> {:error, reason}
-                  end
-                else
-                  {:error, :condition_failed}
-                end
-
-              {:error, :not_found} ->
-                {:error, :not_found}
-
-              {:error, reason} ->
-                {:error, reason}
-            end
+            evaluate_condition_then_cas(
+              key,
+              fn current -> {:put_if, key, compressed_value, expires_at, current} end,
+              condition_fn,
+              opts,
+              timeout
+            )
 
           true ->
             {:error, :missing_condition}
@@ -288,39 +264,19 @@ defmodule Concord do
 
       start_time = System.monotonic_time()
 
-      # Evaluate condition functions pre-consensus (same pattern as put_if)
       result =
         cond do
           expected != nil ->
-            case command({:delete_if, key, expected, nil}, timeout) do
-              {:ok, :ok, _} -> :ok
-              {:ok, {:error, reason}, _} -> {:error, reason}
-              {:timeout, _} -> {:error, :timeout}
-              {:error, :noproc} -> {:error, :cluster_not_ready}
-              {:error, reason} -> {:error, reason}
-            end
+            unwrap_command_result({:delete_if, key, expected, nil}, timeout)
 
           condition_fn != nil ->
-            case get(key, Keyword.take(opts, [:token, :timeout, :consistency])) do
-              {:ok, current_value} ->
-                if condition_fn.(current_value) do
-                  case command({:delete_if, key, current_value, nil}, timeout) do
-                    {:ok, :ok, _} -> :ok
-                    {:ok, {:error, reason}, _} -> {:error, reason}
-                    {:timeout, _} -> {:error, :timeout}
-                    {:error, :noproc} -> {:error, :cluster_not_ready}
-                    {:error, reason} -> {:error, reason}
-                  end
-                else
-                  {:error, :condition_failed}
-                end
-
-              {:error, :not_found} ->
-                {:error, :not_found}
-
-              {:error, reason} ->
-                {:error, reason}
-            end
+            evaluate_condition_then_cas(
+              key,
+              fn current -> {:delete_if, key, current, nil} end,
+              condition_fn,
+              opts,
+              timeout
+            )
 
           true ->
             {:error, :missing_condition}
@@ -806,6 +762,32 @@ defmodule Concord do
     :ra.process_command(server_id(), cmd, timeout)
   end
 
+  defp unwrap_command_result(cmd, timeout) do
+    case command(cmd, timeout) do
+      {:ok, :ok, _} -> :ok
+      {:ok, {:error, reason}, _} -> {:error, reason}
+      {:timeout, _} -> {:error, :timeout}
+      {:error, :noproc} -> {:error, :cluster_not_ready}
+      {:error, reason} -> {:error, reason}
+    end
+  end
+
+  # Evaluate a condition function pre-consensus, then issue a CAS command.
+  # Keeps anonymous functions out of the Raft log.
+  defp evaluate_condition_then_cas(key, build_cmd, condition_fn, opts, timeout) do
+    case get(key, Keyword.take(opts, [:token, :timeout, :consistency])) do
+      {:ok, current_value} ->
+        if condition_fn.(current_value) do
+          unwrap_command_result(build_cmd.(current_value), timeout)
+        else
+          {:error, :condition_failed}
+        end
+
+      {:error, reason} ->
+        {:error, reason}
+    end
+  end
+
   defp query(query, timeout, consistency) do
     query_fun = fun(query)
 

lib/concord/application.ex

@@ -188,10 +188,10 @@ defmodule Concord.Application do
 
   defp wait_for_ra_system(attempts) do
     case :ra_system.fetch(:default) do
-      {:ok, _} ->
+      %{} ->
         :ok
 
-      other when other in [:error, :undefined] ->
+      _ ->
         Process.sleep(200)
         wait_for_ra_system(attempts - 1)
     end

lib/concord/backup.ex

@@ -332,21 +332,6 @@ defmodule Concord.Backup do
     {:ok, backup}
   end
 
-  # V1 backward compatibility: bare list of KV tuples
-  defp build_backup(snapshot_data) when is_list(snapshot_data) do
-    metadata = %{
-      timestamp: DateTime.utc_now(),
-      node: node(),
-      cluster_name: Application.get_env(:concord, :cluster_name, :concord_cluster),
-      entry_count: length(snapshot_data),
-      memory_bytes: :erlang.external_size(snapshot_data),
-      version: Application.spec(:concord, :vsn) |> to_string(),
-      checksum: compute_checksum(snapshot_data)
-    }
-
-    {:ok, %{metadata: metadata, data: snapshot_data}}
-  end
-
   defp write_backup(backup_dir, backup_data, compress) do
     timestamp = DateTime.utc_now() |> DateTime.to_iso8601(:basic) |> String.replace(":", "")
     filename = "concord_backup_#{timestamp}#{@backup_extension}"

lib/concord/index.ex

@@ -32,8 +32,8 @@ defmodule Concord.Index do
       :ok = Concord.Index.create("by_email", fn u -> u.email end)
   """
 
-  alias Concord.StateMachine
   alias Concord.Index.Extractor
+  alias Concord.StateMachine
 
   @timeout 5_000
   @cluster_name :concord_cluster

lib/concord/index/extractor.ex

@@ -52,7 +52,10 @@ defmodule Concord.Index.Extractor do
   def extract({:map_get, key}, value) when is_map(value), do: Map.get(value, key)
   def extract({:nested, keys}, value) when is_map(value), do: get_in(value, keys)
   def extract({:identity}, value), do: value
-  def extract({:element, n}, value) when is_tuple(value) and tuple_size(value) > n, do: elem(value, n)
+
+  def extract({:element, n}, value) when is_tuple(value) and tuple_size(value) > n,
+    do: elem(value, n)
+
   # Backward compatibility: evaluate anonymous functions during migration
   def extract(extractor, value) when is_function(extractor, 1) do
     extractor.(value)

lib/concord/rbac.ex

@@ -285,7 +285,9 @@ defmodule Concord.RBAC do
 
   defp fallback_create_role(role, permissions) do
     case get_role(role) do
-      {:ok, _} -> {:error, :role_exists}
+      {:ok, _} ->
+        {:error, :role_exists}
+
       {:error, :not_found} ->
         :ets.insert(:concord_roles, {role, permissions})
         :ok

test/concord/backup_test.exs

@@ -14,7 +14,10 @@ defmodule Concord.BackupTest do
 
       backup_state = %{
         version: 2,
-        kv_data: [{"key1", %{value: "val1", expires_at: nil}}, {"key2", %{value: "val2", expires_at: nil}}],
+        kv_data: [
+          {"key1", %{value: "val1", expires_at: nil}},
+          {"key2", %{value: "val2", expires_at: nil}}
+        ],
         tokens: %{"tok1" => %{permissions: [:read, :write]}},
         roles: %{admin: %{permissions: [:read, :write, :admin]}},
         role_grants: %{"tok1" => [:admin]},
@@ -39,7 +42,10 @@ defmodule Concord.BackupTest do
 
       # Verify RBAC roles in state
       assert data.roles == %{admin: %{permissions: [:read, :write, :admin]}}
-      assert :ets.lookup(:concord_roles, :admin) == [{:admin, %{permissions: [:read, :write, :admin]}}]
+
+      assert :ets.lookup(:concord_roles, :admin) == [
+               {:admin, %{permissions: [:read, :write, :admin]}}
+             ]
 
       # Verify role grants
       assert data.role_grants == %{"tok1" => [:admin]}
@@ -51,7 +57,10 @@ defmodule Concord.BackupTest do
 
       # Verify tenants
       assert data.tenants == %{"tenant1" => %{id: "tenant1", namespace: "t1:*"}}
-      assert :ets.lookup(:concord_tenants, "tenant1") == [{"tenant1", %{id: "tenant1", namespace: "t1:*"}}]
+
+      assert :ets.lookup(:concord_tenants, "tenant1") == [
+               {"tenant1", %{id: "tenant1", namespace: "t1:*"}}
+             ]
     end
 
     test "V2 restore_backup with indexes rebuilds index ETS", %{state: state} do
@@ -75,7 +84,8 @@ defmodule Concord.BackupTest do
       backup_state = %{
         version: 2,
         kv_data: [
-          {"user:1", %{value: :erlang.term_to_binary(%{email: "alice@test.com"}), expires_at: nil}},
+          {"user:1",
+           %{value: :erlang.term_to_binary(%{email: "alice@test.com"}), expires_at: nil}},
           {"user:2", %{value: :erlang.term_to_binary(%{email: "bob@test.com"}), expires_at: nil}}
         ],
         tokens: %{},
@@ -135,7 +145,9 @@ defmodule Concord.BackupTest do
       # Old data should be gone
       assert :ets.lookup(:concord_store, "old_key") == []
       # New data should be present
-      assert :ets.lookup(:concord_store, "new_key") == [{"new_key", %{value: "new_val", expires_at: nil}}]
+      assert :ets.lookup(:concord_store, "new_key") == [
+               {"new_key", %{value: "new_val", expires_at: nil}}
+             ]
     end
   end
 end

test/concord/determinism_test.exs

@@ -21,7 +21,13 @@ defmodule Concord.DeterminismTest do
   defp clear_ets do
     :ets.delete_all_objects(:concord_store)
 
-    for table <- [:concord_tokens, :concord_roles, :concord_role_grants, :concord_acls, :concord_tenants] do
+    for table <- [
+          :concord_tokens,
+          :concord_roles,
+          :concord_role_grants,
+          :concord_acls,
+          :concord_tenants
+        ] do
       if :ets.whereis(table) != :undefined, do: :ets.delete_all_objects(table)
     end
 

test/concord/snapshot_test.exs

@@ -224,7 +224,11 @@ defmodule Concord.SnapshotTest do
 
       # 6. ACL
       {s7, _, _} =
-        StateMachine.apply_command(%{index: 7}, {:rbac_create_acl, "snap:*", :snaprole, [:read]}, s6)
+        StateMachine.apply_command(
+          %{index: 7},
+          {:rbac_create_acl, "snap:*", :snaprole, [:read]},
+          s6
+        )
 
       # 7. Tenant
       {s8, _, _} =