feat: worktree hooks, incl default mise hook

beeemT · beeemT · commit adc91f9f0915 · 2026-02-13T08:33:28.000+01:00
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -0,0 +1,27 @@
+name: ci
+
+on:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup mise
+        uses: jdx/mise-action@v2
+        with:
+          install: true
+
+      - name: Install dependencies
+        run: mix deps.get
+
+      - name: Run tests
+        run: mix test
diff --git a/.gitignore b/.gitignore
@@ -1,4 +1,4 @@
-git_work
+/git_work
 /_build
 /cover
 /deps
@@ -9,4 +9,4 @@ erl_crash.dump
 *.beam
 /config/*.secret.exs
 .elixir_ls/
-dist/
+dist/
diff --git a/AGENTS.md b/AGENTS.md
@@ -115,3 +115,8 @@ mix escript.build
   Supports `--dry-run` and `--force`.
 - **Shell integration** via `eval "$(git-work --shell-hook)"` which defines a
   `gw` shell function that wraps the binary and `cd`s into path output.
+
+## Agent Instructions
+
+- Always run the test suite yourself to verify new features work.
+- Always fix lint warnings and errors before finishing.
diff --git a/lib/git_work/commands/checkout.ex b/lib/git_work/commands/checkout.ex
@@ -4,7 +4,7 @@ defmodule GitWork.Commands.Checkout do
   Supports fuzzy matching against existing worktrees.
   """
 
-  alias GitWork.{Git, Project, Fuzzy}
+  alias GitWork.{Git, Project, Fuzzy, Hooks}
 
   def help do
     """
@@ -111,27 +111,69 @@ defmodule GitWork.Commands.Checkout do
           {:ok, _} ->
             # Local branch exists
             case Git.cmd(["worktree", "add", worktree_dir, branch], cd: bare_dir) do
-              {:ok, _} -> {:ok, worktree_dir}
-              {:error, msg} -> {:error, "worktree add failed: #{msg}"}
+              {:ok, _} ->
+                run_hooks(root, worktree_dir, branch)
+
+              {:error, msg} ->
+                {:error, "worktree add failed: #{msg}"}
             end
 
           {:error, _} ->
             # Brand new branch
             case Git.cmd(["worktree", "add", "-b", branch, worktree_dir], cd: bare_dir) do
-              {:ok, _} -> {:ok, worktree_dir}
-              {:error, msg} -> {:error, "worktree add failed: #{msg}"}
+              {:ok, _} ->
+                run_hooks(root, worktree_dir, branch)
+
+              {:error, msg} ->
+                {:error, "worktree add failed: #{msg}"}
             end
         end
 
       {:ok, _} ->
         # Remote branch exists — track it
         case Git.cmd(["worktree", "add", worktree_dir, branch], cd: bare_dir) do
-          {:ok, _} -> {:ok, worktree_dir}
-          {:error, msg} -> {:error, "worktree add failed: #{msg}"}
+          {:ok, _} ->
+            run_hooks(root, worktree_dir, branch)
+
+          {:error, msg} ->
+            {:error, "worktree add failed: #{msg}"}
         end
 
       {:error, msg} ->
         {:error, "failed to check remote branches: #{msg}"}
     end
   end
+
+  defp run_hooks(root, worktree_dir, branch) do
+    ctx = %{
+      root: root,
+      worktree_dir: worktree_dir,
+      branch: branch,
+      source_worktree: File.cwd!()
+    }
+
+    case Hooks.run(:post_worktree_create, ctx) do
+      :ok ->
+        {:ok, worktree_dir}
+
+      {:error, msg} ->
+        rollback_worktree(root, worktree_dir, branch, msg)
+    end
+  end
+
+  defp rollback_worktree(root, worktree_dir, branch, reason) do
+    bare_dir = Project.bare_path(root)
+
+    case Git.cmd(["worktree", "remove", worktree_dir], cd: bare_dir) do
+      {:ok, _} -> :ok
+      {:error, msg} -> IO.write(:stderr, "rollback: worktree remove failed: #{msg}\n")
+    end
+
+    case Git.cmd(["branch", "-D", branch], cd: bare_dir) do
+      {:ok, _} -> :ok
+      {:error, msg} -> IO.write(:stderr, "rollback: branch delete failed: #{msg}\n")
+    end
+
+    {:error, reason}
+  end
 end
diff --git a/lib/git_work/hooks.ex b/lib/git_work/hooks.ex
@@ -0,0 +1,111 @@
+defmodule GitWork.Hooks do
+  @moduledoc """
+  Hook runner for worktree lifecycle events.
+  """
+
+  alias GitWork.{Git, Project}
+
+  def run(:post_worktree_create, ctx) do
+    run_mise_hook(ctx)
+  end
+
+  def run(:post_checkout, _ctx), do: :ok
+
+  def run(_event, _ctx), do: :ok
+
+  defp run_mise_hook(%{root: root, worktree_dir: worktree_dir} = ctx) do
+    case System.find_executable("mise") do
+      nil ->
+        IO.write(:stderr, "hook: mise not found; skipping trust and task\n")
+        :ok
+
+      _path ->
+        trust_enabled = mise_trust_enabled?(root)
+        task = mise_task(root)
+
+        with :ok <- maybe_trust_mise(trust_enabled, ctx),
+             :ok <- maybe_run_task(task, worktree_dir) do
+          :ok
+        end
+    end
+  end
+
+  defp maybe_trust_mise(false, _ctx), do: :ok
+
+  defp maybe_trust_mise(true, %{source_worktree: nil}), do: :ok
+
+  defp maybe_trust_mise(true, %{source_worktree: source, worktree_dir: worktree_dir}) do
+    case cmd("mise", ["trust", "--show"], cd: source) do
+      {:ok, output} when output != "" ->
+        case cmd("mise", ["trust"], cd: worktree_dir) do
+          {:ok, _} -> :ok
+          {:error, msg} -> {:error, "mise trust failed: #{msg}"}
+        end
+
+      {:ok, _} ->
+        :ok
+
+      {:error, msg} ->
+        {:error, "mise trust --show failed: #{msg}"}
+    end
+  end
+
+  defp maybe_run_task(nil, _worktree_dir), do: :ok
+
+  defp maybe_run_task(task, worktree_dir) do
+    case cmd("mise", ["run", task], cd: worktree_dir) do
+      {:ok, _} -> :ok
+      {:error, msg} -> {:error, "mise run #{task} failed: #{msg}"}
+    end
+  end
+
+  defp mise_trust_enabled?(root) do
+    case config_get_bool(root, "git-work.hooks.mise.trust") do
+      {:ok, value} -> value
+      :unset -> true
+    end
+  end
+
+  defp mise_task(root) do
+    case config_get_string(root, "git-work.hooks.mise.task") do
+      {:ok, ""} -> nil
+      {:ok, value} -> value
+      :unset -> "worktree:setup"
+    end
+  end
+
+  defp config_get_bool(root, key) do
+    bare_dir = Project.bare_path(root)
+
+    case Git.cmd(["config", "--get", "--bool", key], cd: bare_dir) do
+      {:ok, "true"} -> {:ok, true}
+      {:ok, "false"} -> {:ok, false}
+      {:ok, value} -> {:ok, value == "true"}
+      {:error, _} -> :unset
+    end
+  end
+
+  defp config_get_string(root, key) do
+    bare_dir = Project.bare_path(root)
+
+    case Git.cmd(["config", "--get", key], cd: bare_dir) do
+      {:ok, value} -> {:ok, value}
+      {:error, _} -> :unset
+    end
+  end
+
+  defp cmd(bin, args, opts) do
+    cmd_opts = [stderr_to_stdout: true]
+
+    cmd_opts =
+      case Keyword.get(opts, :cd) do
+        nil -> cmd_opts
+        dir -> Keyword.put(cmd_opts, :cd, dir)
+      end
+
+    case System.cmd(bin, args, cmd_opts) do
+      {output, 0} -> {:ok, String.trim(output)}
+      {output, _code} -> {:error, String.trim(output)}
+    end
+  end
+end
diff --git a/test/git_work/commands/checkout_test.exs b/test/git_work/commands/checkout_test.exs
@@ -96,6 +96,11 @@ defmodule GitWork.Commands.CheckoutTest do
     project = Path.join(tmp, "project")
     {:ok, _} = GitWork.Commands.Clone.run([origin, project])
 
+    {_, 0} =
+      System.cmd("git", ["config", "git-work.hooks.mise.task", ""],
+        cd: Path.join(project, ".bare")
+      )
+
     # Create a branch on the remote
     GitWork.TestHelper.create_remote_branch(origin, "feature-remote")
 
@@ -114,6 +119,11 @@ defmodule GitWork.Commands.CheckoutTest do
     project = Path.join(tmp, "project")
     {:ok, _} = GitWork.Commands.Clone.run([origin, project])
 
+    {_, 0} =
+      System.cmd("git", ["config", "git-work.hooks.mise.task", ""],
+        cd: Path.join(project, ".bare")
+      )
+
     # Create a branch on the remote
     GitWork.TestHelper.create_remote_branch(origin, "feature-remote")
 
@@ -132,4 +142,59 @@ defmodule GitWork.Commands.CheckoutTest do
     {output, 0} = System.cmd("git", ["worktree", "list"], cd: Path.join(project, ".bare"))
     assert output =~ "feature-remote"
   end
+
+  test "post worktree hook runs on -b and can modify worktree", %{tmp: tmp} do
+    project = GitWork.TestHelper.create_gw_project(tmp)
+    bare = Path.join(project, ".bare")
+
+    GitWork.TestHelper.write_hook_script(tmp)
+    GitWork.TestHelper.prepend_path(tmp)
+
+    File.write!(Path.join([project, "main", ".trusted"]), "ok")
+
+    {_, 0} = System.cmd("git", ["config", "git-work.hooks.mise.task", "hook-task"], cd: bare)
+
+    File.cd!(Path.join(project, "main"))
+
+    assert {:ok, path} = Checkout.run(["-b", "feature-hook"])
+    assert File.regular?(Path.join(path, "hook-ran"))
+    assert File.regular?(Path.join(path, ".trusted"))
+  end
+
+  test "existing worktree checkout does not run hook", %{tmp: tmp} do
+    project = GitWork.TestHelper.create_gw_project(tmp)
+    bare = Path.join(project, ".bare")
+
+    GitWork.TestHelper.write_hook_script(tmp)
+    GitWork.TestHelper.prepend_path(tmp)
+
+    {_, 0} = System.cmd("git", ["config", "git-work.hooks.mise.task", "hook-task"], cd: bare)
+
+    File.cd!(Path.join(project, "main"))
+
+    assert {:ok, _} = Checkout.run(["-b", "feature-existing"])
+    File.rm!(Path.join([project, "feature-existing", "hook-ran"]))
+
+    assert {:ok, path} = Checkout.run(["feature-existing"])
+    refute File.regular?(Path.join(path, "hook-ran"))
+  end
+
+  test "post worktree hook failure triggers rollback", %{tmp: tmp} do
+    project = GitWork.TestHelper.create_gw_project(tmp)
+    bare = Path.join(project, ".bare")
+
+    GitWork.TestHelper.write_hook_script(tmp)
+    GitWork.TestHelper.prepend_path(tmp)
+
+    {_, 0} = System.cmd("git", ["config", "git-work.hooks.mise.task", "hook-fail"], cd: bare)
+
+    File.cd!(Path.join(project, "main"))
+
+    assert {:error, msg} = Checkout.run(["-b", "feature-fail"])
+    assert msg =~ "mise run"
+    refute File.dir?(Path.join(project, "feature-fail"))
+
+    {output, 0} = System.cmd("git", ["branch", "--list", "feature-fail"], cd: bare)
+    assert output == ""
+  end
 end
diff --git a/test/git_work/commands/sync_test.exs b/test/git_work/commands/sync_test.exs
@@ -17,9 +17,8 @@ defmodule GitWork.Commands.SyncTest do
   end
 
   test "prunes worktree whose remote branch was deleted", %{tmp: tmp} do
-    origin = GitWork.TestHelper.create_origin_repo(tmp)
-    project = Path.join(tmp, "project")
-    {:ok, _} = GitWork.Commands.Clone.run([origin, project])
+    project = GitWork.TestHelper.create_gw_project(tmp)
+    origin = Path.join(tmp, "origin.git")
 
     # Create remote branch, fetch, checkout
     GitWork.TestHelper.create_remote_branch(origin, "feature-stale")
@@ -43,9 +42,8 @@ defmodule GitWork.Commands.SyncTest do
   end
 
   test "--dry-run shows candidates without removing", %{tmp: tmp} do
-    origin = GitWork.TestHelper.create_origin_repo(tmp)
-    project = Path.join(tmp, "project")
-    {:ok, _} = GitWork.Commands.Clone.run([origin, project])
+    project = GitWork.TestHelper.create_gw_project(tmp)
+    origin = Path.join(tmp, "origin.git")
 
     GitWork.TestHelper.create_remote_branch(origin, "feature-dry")
     System.cmd("git", ["fetch", "--all"], cd: Path.join(project, ".bare"))
@@ -65,9 +63,7 @@ defmodule GitWork.Commands.SyncTest do
   end
 
   test "never prunes HEAD branch", %{tmp: tmp} do
-    origin = GitWork.TestHelper.create_origin_repo(tmp)
-    project = Path.join(tmp, "project")
-    {:ok, _} = GitWork.Commands.Clone.run([origin, project])
+    project = GitWork.TestHelper.create_gw_project(tmp)
 
     File.cd!(Path.join(project, "main"))
 
diff --git a/test/support/test_helper.ex b/test/support/test_helper.ex
