Add mix desktop.check_toolchain and .tool-versions parsing

Introduce Desktop.ToolVersions and Desktop.Toolchain to compare the
running OTP major and Elixir semver against project .tool-versions
without shelling out to mise/asdf. Mix task fails fast with actionable
messages when mismatched.

Adds ExUnit coverage for parsing edge cases and verification behavior.

Refs #67

Co-authored-by: Dominic Letz <dominicletz@users.noreply.github.com>

Author: cursoragent

lib/desktop/tool_versions.ex

@@ -0,0 +1,40 @@
+defmodule Desktop.ToolVersions do
+  @moduledoc false
+
+  @doc """
+  Parses a `.tool-versions` file body (asdf/mise format).
+
+  Returns a map with optional string values for `:erlang` and `:elixir` keys
+  (raw version fields from the file, e.g. `"26.2.5.5 system"`, `"1.19.1-otp-26"`).
+  """
+  @spec parse(String.t()) :: %{optional(:erlang) => String.t(), optional(:elixir) => String.t()}
+  def parse(content) when is_binary(content) do
+    content
+    |> String.split("\n")
+    |> Enum.reduce(%{}, &parse_line/2)
+  end
+
+  defp parse_line(line, acc) do
+    line = String.trim(line)
+
+    cond do
+      line == "" ->
+        acc
+
+      String.starts_with?(line, "#") ->
+        acc
+
+      true ->
+        case Regex.run(~r/^(elixir|erlang)\s+(.+)$/, line) do
+          [_, "elixir", rest] ->
+            Map.put(acc, :elixir, String.trim(rest))
+
+          [_, "erlang", rest] ->
+            Map.put(acc, :erlang, String.trim(rest))
+
+          _ ->
+            acc
+        end
+    end
+  end
+end

lib/desktop/toolchain.ex

@@ -0,0 +1,114 @@
+defmodule Desktop.Toolchain do
+  @moduledoc false
+
+  alias Desktop.ToolVersions
+
+  @doc """
+  Verifies that running OTP major and Elixir version match entries parsed from `.tool-versions`.
+
+  `requirements` is the map returned by `Desktop.ToolVersions.parse/1`.
+
+  Optional `otp_release` and `elixir_version` override `System` values (for testing).
+
+  Returns `:ok` or `{:error, message}` where `message` is human-readable.
+  """
+  @spec verify(map(), keyword()) :: :ok | {:error, String.t()}
+  def verify(requirements, opts \\ []) when is_map(requirements) do
+    otp_actual = Keyword.get_lazy(opts, :otp_release, fn -> System.otp_release() end)
+    elixir_actual = Keyword.get_lazy(opts, :elixir_version, fn -> System.version() end)
+
+    errors =
+      []
+      |> maybe_check_erlang(Map.get(requirements, :erlang), otp_actual)
+      |> maybe_check_elixir(Map.get(requirements, :elixir), elixir_actual)
+
+    case errors do
+      [] -> :ok
+      msgs -> {:error, Enum.join(msgs, "\n")}
+    end
+  end
+
+  defp maybe_check_erlang(acc, nil, _otp_actual), do: acc
+
+  defp maybe_check_erlang(acc, raw, otp_actual) when is_binary(raw) do
+    expected_major = erlang_major(raw)
+
+    case Integer.parse(to_string(otp_actual)) do
+      {actual_major, _} when actual_major == expected_major ->
+        acc
+
+      {actual_major, _} ->
+        [
+          "Erlang/OTP major mismatch: running OTP #{actual_major}, `.tool-versions` expects OTP #{expected_major} (from erlang #{inspect(raw)})."
+          | acc
+        ]
+
+      :error ->
+        ["Could not parse running OTP release #{inspect(otp_actual)}." | acc]
+    end
+  end
+
+  defp maybe_check_elixir(acc, nil, _elixir_actual), do: acc
+
+  defp maybe_check_elixir(acc, raw, elixir_actual) when is_binary(raw) do
+    expected_base = elixir_base_version(raw)
+
+    case Version.parse(expected_base) do
+      {:ok, expected_ver} ->
+        case Version.parse(elixir_actual) do
+          {:ok, actual_ver} ->
+            if Version.compare(actual_ver, expected_ver) == :eq do
+              acc
+            else
+              [
+                "Elixir version mismatch: running #{elixir_actual}, `.tool-versions` expects #{expected_base} (from elixir #{inspect(raw)})."
+                | acc
+              ]
+            end
+
+          :error ->
+            ["Could not parse running Elixir version #{inspect(elixir_actual)}." | acc]
+        end
+
+      :error ->
+        ["Could not parse Elixir version in `.tool-versions`: #{inspect(raw)}." | acc]
+    end
+  end
+
+  @doc false
+  def erlang_major(raw) when is_binary(raw) do
+    raw
+    |> String.split()
+    |> hd()
+    |> String.split(".")
+    |> hd()
+    |> String.to_integer()
+  end
+
+  @doc false
+  def elixir_base_version(raw) when is_binary(raw) do
+    case Regex.run(~r/^(\d+\.\d+\.\d+)/, raw) do
+      [_, base] ->
+        base
+
+      nil ->
+        raw
+        |> String.split("-")
+        |> hd()
+    end
+  end
+
+  @doc """
+  Loads `.tool-versions` from `path`, parses it, and verifies the toolchain.
+  """
+  @spec verify_file(String.t(), keyword()) :: :ok | {:error, String.t()}
+  def verify_file(path, opts \\ []) do
+    case File.read(path) do
+      {:ok, content} ->
+        content |> ToolVersions.parse() |> verify(opts)
+
+      {:error, reason} ->
+        {:error, "Could not read #{inspect(path)}: #{inspect(reason)}"}
+    end
+  end
+end

lib/mix/tasks/desktop.check_toolchain.ex

@@ -0,0 +1,38 @@
+defmodule Mix.Tasks.Desktop.CheckToolchain do
+  @shortdoc "Checks running Erlang/OTP and Elixir against `.tool-versions`"
+
+  @moduledoc """
+  #{@shortdoc}
+
+  Compares the **currently running** BEAM (`System.otp_release/0`, `System.version/0`)
+  to `erlang` and `elixir` lines in `.tool-versions`. It does not invoke mise, asdf, or
+  other installers—activate your toolchain however you prefer, then run this task to fail fast.
+
+  ## Examples
+
+      mix desktop.check_toolchain
+
+  """
+
+  use Mix.Task
+
+  @impl Mix.Task
+  def run(_argv) do
+    root = Mix.Project.config()[:root] || File.cwd!()
+    path = Path.join(root, ".tool-versions")
+
+    unless File.exists?(path) do
+      Mix.shell().error("No `.tool-versions` found at #{path}.")
+      exit({:shutdown, 1})
+    end
+
+    case Desktop.Toolchain.verify_file(path) do
+      :ok ->
+        Mix.shell().info("Toolchain matches `.tool-versions`.")
+
+      {:error, msg} ->
+        Mix.shell().error(msg)
+        exit({:shutdown, 1})
+    end
+  end
+end

test/desktop/tool_versions_test.exs

@@ -0,0 +1,29 @@
+defmodule Desktop.ToolVersionsTest do
+  use ExUnit.Case, async: true
+
+  alias Desktop.ToolVersions
+
+  test "parse ignores comments and blank lines" do
+    content = """
+    # comment
+    erlang 26.2.5.5 system
+
+    elixir 1.19.1-otp-26
+    """
+
+    assert ToolVersions.parse(content) == %{
+             erlang: "26.2.5.5 system",
+             elixir: "1.19.1-otp-26"
+           }
+  end
+
+  test "parse handles extra whitespace on values" do
+    content = "elixir  1.12.3 \n"
+
+    assert ToolVersions.parse(content) == %{elixir: "1.12.3"}
+  end
+
+  test "parse empty file" do
+    assert ToolVersions.parse("") == %{}
+  end
+end

test/desktop/toolchain_test.exs

@@ -0,0 +1,115 @@
+defmodule Desktop.ToolchainTest do
+  use ExUnit.Case, async: true
+
+  alias Desktop.Toolchain
+
+  describe "verify/2" do
+    test "ok when erlang major matches and elixir semver matches" do
+      req = %{erlang: "26.2.5.5 system", elixir: "1.19.1-otp-26"}
+
+      assert Toolchain.verify(req,
+               otp_release: 26,
+               elixir_version: "1.19.1"
+             ) == :ok
+    end
+
+    test "error when OTP major mismatches" do
+      req = %{erlang: "26.2.5.5 system", elixir: "1.19.1-otp-26"}
+
+      assert {:error, msg} =
+               Toolchain.verify(req,
+                 otp_release: 25,
+                 elixir_version: "1.19.1"
+               )
+
+      assert msg =~ "OTP"
+      assert msg =~ "25"
+      assert msg =~ "26"
+    end
+
+    test "error when Elixir semver mismatches" do
+      req = %{erlang: "26.2.5.5 system", elixir: "1.19.1-otp-26"}
+
+      assert {:error, msg} =
+               Toolchain.verify(req,
+                 otp_release: 26,
+                 elixir_version: "1.18.0"
+               )
+
+      assert msg =~ "Elixir"
+      assert msg =~ "1.18.0"
+      assert msg =~ "1.19.1"
+    end
+
+    test "ok when only erlang line present" do
+      req = %{erlang: "24.0.1"}
+
+      assert Toolchain.verify(req, otp_release: 24, elixir_version: "9.9.9") == :ok
+    end
+
+    test "ok when only elixir line present" do
+      req = %{elixir: "1.12.0"}
+
+      assert Toolchain.verify(req, otp_release: 99, elixir_version: "1.12.0") == :ok
+    end
+
+    test "empty requirements always ok" do
+      assert Toolchain.verify(%{}, otp_release: 1, elixir_version: "0.1.0") == :ok
+    end
+  end
+
+  describe "verify_file/2" do
+    test "reads and verifies temp file" do
+      path =
+        Path.join(
+          System.tmp_dir!(),
+          "desktop-tool-versions-test-#{:erlang.unique_integer([:positive])}"
+        )
+
+      content = """
+      erlang 26.0.1
+      elixir 1.14.0
+      """
+
+      :ok = File.write(path, content)
+
+      try do
+        assert Toolchain.verify_file(path,
+                 otp_release: 26,
+                 elixir_version: "1.14.0"
+               ) == :ok
+
+        assert {:error, _} =
+                 Toolchain.verify_file(path,
+                   otp_release: 25,
+                   elixir_version: "1.14.0"
+                 )
+      after
+        File.rm(path)
+      end
+    end
+
+    test "missing file returns error" do
+      path =
+        Path.join(
+          System.tmp_dir!(),
+          "nonexistent-tool-versions-#{:erlang.unique_integer([:positive])}"
+        )
+
+      assert {:error, msg} = Toolchain.verify_file(path)
+      assert msg =~ "Could not read"
+    end
+  end
+
+  describe "helpers" do
+    test "erlang_major/1" do
+      assert Toolchain.erlang_major("26.2.5.5 system") == 26
+      assert Toolchain.erlang_major("24.0.1") == 24
+    end
+
+    test "elixir_base_version/1" do
+      assert Toolchain.elixir_base_version("1.19.1-otp-26") == "1.19.1"
+      assert Toolchain.elixir_base_version("1.12.0") == "1.12.0"
+    end
+  end
+end