feat(git_work): enabled upstream tracking for worktrees

- Centralized bare repo config and upstream helpers in GitWork.Project.
- Set push.autoSetupRemote during clone and init repair.
- Set upstream tracking when checkout auto-created a worktree from origin.
- Added tests for clone, init repair, and checkout auto-create flows.

Author: beeemT

lib/git_work/commands/checkout.ex

@@ -302,6 +302,7 @@ defmodule GitWork.Commands.Checkout do
 
     case Hooks.run(:post_worktree_create, ctx) do
       :ok ->
+        Project.ensure_upstream(worktree_dir, branch)
         {:ok, worktree_dir}
 
       {:error, msg} ->

lib/git_work/commands/clone.ex

@@ -48,9 +48,9 @@ defmodule GitWork.Commands.Clone do
            {:ok, branch} <- detect_head_branch(bare_dir),
            :ok <- fix_head(bare_dir, branch),
            :ok <- add_main_worktree(dir, branch),
-           :ok <- configure_bare(bare_dir),
+           :ok <- Project.configure_bare(bare_dir),
            :ok <- fetch_refs(bare_dir),
-           :ok <- ensure_upstream(dir, branch) do
+           :ok <- Project.ensure_upstream(Path.join(dir, branch), branch) do
         {:ok, Path.join(dir, branch)}
       end
     end
@@ -67,16 +67,6 @@ defmodule GitWork.Commands.Clone do
     File.write(Path.join(dir, ".git"), "gitdir: ./.bare\n")
   end
 
-  defp configure_bare(bare_dir) do
-    with {:ok, _} <- Git.cmd(["config", "core.bare", "true"], cd: bare_dir),
-         {:ok, _} <-
-           Git.cmd(
-             ["config", "remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*"],
-             cd: bare_dir
-           ) do
-      :ok
-    end
-  end
 
   defp fetch_refs(bare_dir) do
     case Git.cmd(["fetch", "--all"], cd: bare_dir) do
@@ -135,32 +125,4 @@ defmodule GitWork.Commands.Clone do
     end
   end
 
-  defp ensure_upstream(dir, branch) do
-    worktree_dir = Path.join(dir, branch)
-
-    case Git.cmd(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], cd: worktree_dir) do
-      {:ok, _} ->
-        :ok
-
-      {:error, _} ->
-        case Git.cmd(["show-ref", "--verify", "--quiet", "refs/remotes/origin/#{branch}"],
-               cd: worktree_dir
-             ) do
-          {:ok, _} ->
-            case Git.cmd(["branch", "--set-upstream-to=origin/#{branch}", branch],
-                   cd: worktree_dir
-                 ) do
-              {:ok, _} ->
-                :ok
-
-              {:error, msg} ->
-                IO.write(:stderr, "warning: failed to set upstream for #{branch}: #{msg}\n")
-                :ok
-            end
-
-          {:error, _} ->
-            :ok
-        end
-    end
-  end
 end

lib/git_work/commands/init.ex

@@ -65,7 +65,7 @@ defmodule GitWork.Commands.Init do
 
   defp do_repair(dir, git_dir, bare_dir) do
     with :ok <- ensure_gitdir_pointer(dir, git_dir),
-         :ok <- configure_bare(bare_dir),
+         :ok <- Project.configure_bare(bare_dir),
          {:ok, branch} <- Project.head_branch(dir),
          :ok <- ensure_worktree_dir(dir, branch) do
       {:ok, Project.worktree_path(dir, branch)}
@@ -119,12 +119,12 @@ defmodule GitWork.Commands.Init do
 
   defp do_init_steps(dir, branch, stashed?, git_dir, bare_dir) do
     with :ok <- move_git_to_bare(git_dir, bare_dir),
-         :ok <- configure_bare(bare_dir),
+         :ok <- Project.configure_bare(bare_dir),
          :ok <- move_files_to_worktree(dir, branch),
          :ok <- setup_worktree_linkage(dir, branch),
          :ok <- write_gitdir_pointer(dir),
          :ok <- reset_worktree_index(dir, branch),
-         :ok <- ensure_upstream(dir, branch),
+         :ok <- Project.ensure_upstream(Path.join(dir, branch), branch),
          :ok <- validate_init(dir, branch, bare_dir),
          :ok <- maybe_pop_stash(dir, branch, stashed?) do
       :ok
@@ -168,27 +168,6 @@ defmodule GitWork.Commands.Init do
     end
   end
 
-  defp configure_bare(bare_dir) do
-    with {:ok, _} <- Git.cmd(["config", "core.bare", "true"], cd: bare_dir) do
-      # Only set fetch refspec if remote origin exists
-      case Git.cmd(["remote", "get-url", "origin"], cd: bare_dir) do
-        {:ok, _} ->
-          Git.cmd(
-            ["config", "remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*"],
-            cd: bare_dir
-          )
-          |> case do
-            {:ok, _} -> :ok
-            {:error, msg} -> {:error, "failed to configure fetch: #{msg}"}
-          end
-
-        {:error, _} ->
-          IO.write(:stderr, "warning: no remote 'origin' configured\n")
-          :ok
-      end
-    end
-  end
-
   defp move_files_to_worktree(dir, branch) do
     worktree_dir = Path.join(dir, branch)
 
@@ -249,36 +228,6 @@ defmodule GitWork.Commands.Init do
     end
   end
 
-  defp ensure_upstream(dir, branch) do
-    worktree_dir = Path.join(dir, branch)
-
-    case Git.cmd(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"],
-           cd: worktree_dir
-         ) do
-      {:ok, _} ->
-        :ok
-
-      {:error, _} ->
-        case Git.cmd(["show-ref", "--verify", "--quiet", "refs/remotes/origin/#{branch}"],
-               cd: worktree_dir
-             ) do
-          {:ok, _} ->
-            case Git.cmd(["branch", "--set-upstream-to=origin/#{branch}", branch],
-                   cd: worktree_dir
-                 ) do
-              {:ok, _} ->
-                :ok
-
-              {:error, msg} ->
-                IO.write(:stderr, "warning: failed to set upstream for #{branch}: #{msg}\n")
-                :ok
-            end
-
-          {:error, _} ->
-            :ok
-        end
-    end
-  end
 
   defp validate_init(dir, branch, bare_dir) do
     worktree_dir = Path.join(dir, branch)

lib/git_work/project.ex

@@ -1,8 +1,11 @@
 defmodule GitWork.Project do
   @moduledoc """
-  Project root discovery, path helpers, and branch name sanitization.
+  Project root discovery, path helpers, branch name sanitization,
+  and shared configuration for bare repos and worktrees.
   """
 
+  alias GitWork.Git
+
   @doc """
   Find the project root by walking up from `start_dir` looking for `.bare/`.
   Returns {:ok, path} or {:error, message}.
@@ -76,4 +79,64 @@ defmodule GitWork.Project do
       {:error, _} -> {:error, "could not determine HEAD branch"}
     end
   end
+
+  @doc """
+  Configure the bare repo: mark as bare, enable push.autoSetupRemote,
+  and set the fetch refspec for origin (if origin exists).
+  """
+  def configure_bare(bare_dir) do
+    with {:ok, _} <- Git.cmd(["config", "core.bare", "true"], cd: bare_dir),
+         {:ok, _} <- Git.cmd(["config", "push.autoSetupRemote", "true"], cd: bare_dir) do
+      # Only set fetch refspec if remote origin exists
+      case Git.cmd(["remote", "get-url", "origin"], cd: bare_dir) do
+        {:ok, _} ->
+          case Git.cmd(
+                 ["config", "remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*"],
+                 cd: bare_dir
+               ) do
+            {:ok, _} -> :ok
+            {:error, msg} -> {:error, "failed to configure fetch: #{msg}"}
+          end
+
+        {:error, _} ->
+          IO.write(:stderr, "warning: no remote 'origin' configured\n")
+          :ok
+      end
+    end
+  end
+
+  @doc """
+  Set upstream tracking for a branch if its remote counterpart exists.
+  No-ops when the branch has no remote ref (e.g. brand-new, not yet pushed).
+  """
+  def ensure_upstream(worktree_dir, branch) do
+    case Git.cmd(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"],
+           cd: worktree_dir
+         ) do
+      {:ok, _} ->
+        # Already has upstream tracking
+        :ok
+
+      {:error, _} ->
+        case Git.cmd(["show-ref", "--verify", "--quiet", "refs/remotes/origin/#{branch}"],
+               cd: worktree_dir
+             ) do
+          {:ok, _} ->
+            case Git.cmd(["branch", "--set-upstream-to=origin/#{branch}", branch],
+                   cd: worktree_dir
+                 ) do
+              {:ok, _} ->
+                :ok
+
+              {:error, msg} ->
+                IO.write(:stderr, "warning: failed to set upstream for #{branch}: #{msg}\n")
+                :ok
+            end
+
+          {:error, _} ->
+            # No remote ref — nothing to track (will be set on first push via autoSetupRemote)
+            :ok
+        end
+    end
+  end
 end

test/git_work/commands/checkout_test.exs

@@ -351,4 +351,73 @@ defmodule GitWork.Commands.CheckoutTest do
     assert {:ok, path} = Checkout.run(["feature-trust-remote"], :text)
     assert File.regular?(Path.join(path, ".trusted"))
   end
+
+  test "checkout auto-create from remote sets upstream tracking", %{tmp: tmp} do
+    origin = GitWork.TestHelper.create_origin_repo(tmp)
+    project = Path.join(tmp, "project")
+    {:ok, _} = GitWork.Commands.Clone.run([origin, project], :text)
+
+    {_, 0} =
+      System.cmd("git", ["config", "git-work.hooks.mise.task", ""],
+        cd: Path.join(project, ".bare")
+      )
+
+    GitWork.TestHelper.create_remote_branch(origin, "feature-tracking")
+    System.cmd("git", ["fetch", "--all"], cd: Path.join(project, ".bare"))
+
+    File.cd!(Path.join(project, "main"))
+
+    # Auto-create worktree from remote branch (no -b)
+    assert {:ok, path} = Checkout.run(["feature-tracking"], :text)
+    assert File.dir?(path)
+
+    # Upstream tracking should be set to the remote branch
+    {upstream, 0} =
+      System.cmd("git", ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"],
+        cd: path
+      )
+
+    assert String.trim(upstream) == "origin/feature-tracking"
+  end
+
+  test "checkout -b new branch has push.autoSetupRemote configured", %{tmp: tmp} do
+    origin = GitWork.TestHelper.create_origin_repo(tmp)
+    project = Path.join(tmp, "project")
+    {:ok, _} = GitWork.Commands.Clone.run([origin, project], :text)
+
+    {_, 0} =
+      System.cmd("git", ["config", "git-work.hooks.mise.task", ""],
+        cd: Path.join(project, ".bare")
+      )
+
+    File.cd!(Path.join(project, "main"))
+
+    assert {:ok, path} = Checkout.run(["-b", "feature-fresh"], :text)
+    assert File.dir?(path)
+
+    # push.autoSetupRemote should be set on the bare repo so that
+    # `git push` from any worktree automatically sets upstream tracking
+    {auto_setup, 0} =
+      System.cmd("git", ["config", "push.autoSetupRemote"], cd: Path.join(project, ".bare"))
+
+    assert String.trim(auto_setup) == "true"
+
+    # New branch has no upstream yet (nothing on remote)
+    {_, exit_code} =
+      System.cmd("git", ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"],
+        cd: path
+      )
+
+    assert exit_code != 0
+
+    # Default push with autoSetupRemote — should set upstream automatically
+    {_, 0} = System.cmd("git", ["push"], cd: path)
+
+    {upstream, 0} =
+      System.cmd("git", ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"],
+        cd: path
+      )
+
+    assert String.trim(upstream) == "origin/feature-fresh"
+  end
 end

test/git_work/commands/clone_test.exs

@@ -74,4 +74,16 @@ defmodule GitWork.Commands.CloneTest do
     assert {:error, msg} = Clone.run([origin, project], :text)
     assert msg =~ "already exists"
   end
+
+  test "clone sets push.autoSetupRemote on bare repo", %{tmp: tmp} do
+    origin = GitWork.TestHelper.create_origin_repo(tmp)
+    project = Path.join(tmp, "project")
+
+    assert {:ok, _} = Clone.run([origin, project], :text)
+
+    {auto_setup, 0} =
+      System.cmd("git", ["config", "push.autoSetupRemote"], cd: Path.join(project, ".bare"))
+
+    assert String.trim(auto_setup) == "true"
+  end
 end

test/git_work/commands/init_test.exs

@@ -69,6 +69,12 @@ defmodule GitWork.Commands.InitTest do
       System.cmd("git", ["config", "--bool", "core.bare"], cd: Path.join(repo, ".bare"))
 
     assert String.trim(value) == "true"
+
+    # push.autoSetupRemote should be set by repair
+    {auto_setup, 0} =
+      System.cmd("git", ["config", "push.autoSetupRemote"], cd: Path.join(repo, ".bare"))
+
+    assert String.trim(auto_setup) == "true"
   end
 
   test "recreates missing HEAD worktree on rerun", %{tmp: tmp} do