Fix separate-git-dir worktree entry detection

Author: crrowbot

internal/worktree/git.go

@@ -83,6 +83,7 @@ func List() ([]Entry, error) {
 
 	// Detect current working directory to mark the active worktree
 	cwd, _ := os.Getwd()
+	currentGitDir := currentWorktreeGitDir()
 
 	var entries []Entry
 	var cur Entry
@@ -91,10 +92,11 @@ func List() ([]Entry, error) {
 
 	// finalizeEntry fills computed fields and returns the entry ready for collection.
 	finalizeEntry := func(e Entry) Entry {
-		e.IsMain = isMainWorktree(e.Path)
+		entryGitDir := entryGitDir(e.Path)
+		e.IsMain = entryGitDir != "" && !isLinkedGitDir(entryGitDir)
 		e.Prunable = prunable
 		e.Locked = locked
-		e.IsCurrent = isSameOrChild(cwd, e.Path)
+		e.IsCurrent = isSameOrChild(cwd, e.Path) || samePath(currentGitDir, entryGitDir)
 		e.Status = classifyEntry(&e, merged)
 		// Populate computed fields for non-prunable entries with existing paths
 		if !e.Prunable {
@@ -168,12 +170,15 @@ func lastActiveTime(path string) time.Time {
 	var latest time.Time
 
 	// Resolve the actual git directory (handles both main checkout and linked worktrees)
-	gitDir := resolveGitDir(path)
-	candidates := []string{
-		filepath.Join(gitDir, "HEAD"),
-		filepath.Join(gitDir, "index"),
-		filepath.Join(path, ".git"), // mtime of .git itself (file or dir)
+	gitDir := entryGitDir(path)
+	var candidates []string
+	if gitDir != "" {
+		candidates = append(candidates,
+			filepath.Join(gitDir, "HEAD"),
+			filepath.Join(gitDir, "index"),
+		)
 	}
+	candidates = append(candidates, filepath.Join(path, ".git")) // mtime of .git itself (file or dir)
 	for _, c := range candidates {
 		if info, err := os.Stat(c); err == nil {
 			if info.ModTime().After(latest) {
@@ -190,6 +195,31 @@ func lastActiveTime(path string) time.Time {
 	return latest
 }
 
+func currentWorktreeGitDir() string {
+	out, err := exec.CommandContext(context.Background(), "git", "rev-parse", "--absolute-git-dir").Output()
+	if err != nil {
+		return ""
+	}
+	return strings.TrimSpace(string(out))
+}
+
+func entryGitDir(path string) string {
+	if isGitDir(path) {
+		return filepath.Clean(path)
+	}
+	dotGit := filepath.Join(path, ".git")
+	if _, err := os.Stat(dotGit); err != nil {
+		return ""
+	}
+	return resolveGitDir(path)
+}
+
+func isGitDir(path string) bool {
+	headInfo, headErr := os.Stat(filepath.Join(path, "HEAD"))
+	configInfo, configErr := os.Stat(filepath.Join(path, "config"))
+	return headErr == nil && !headInfo.IsDir() && configErr == nil && !configInfo.IsDir()
+}
+
 // resolveGitDir returns the path to the actual git directory for a worktree.
 // The worktree's .git metadata may be either a directory or a file containing
 // "gitdir: <path>" that points to the actual git metadata directory.
@@ -219,10 +249,11 @@ func resolveGitDir(worktreePath string) string {
 }
 
 func isMainWorktree(worktreePath string) bool {
-	if _, err := os.Stat(filepath.Join(worktreePath, ".git")); err != nil {
+	gitDir := entryGitDir(worktreePath)
+	if gitDir == "" {
 		return false
 	}
-	return !isLinkedGitDir(resolveGitDir(worktreePath))
+	return !isLinkedGitDir(gitDir)
 }
 
 func isLinkedGitDir(gitDir string) bool {
@@ -253,6 +284,18 @@ func isSameOrChild(child, parent string) bool {
 	return c == p || strings.HasPrefix(c, p+string(os.PathSeparator))
 }
 
+func samePath(a, b string) bool {
+	if a == "" || b == "" {
+		return false
+	}
+	x, err1 := filepath.EvalSymlinks(a)
+	y, err2 := filepath.EvalSymlinks(b)
+	if err1 != nil || err2 != nil {
+		return filepath.Clean(a) == filepath.Clean(b)
+	}
+	return x == y
+}
+
 // MergedBranches returns branch names that are fully merged into main.
 func MergedBranches() (map[string]bool, error) {
 	ctx, cancel := gitContext()

internal/worktree/git_test.go

@@ -2,7 +2,9 @@ package worktree
 
 import (
 	"os"
+	"os/exec"
 	"path/filepath"
+	"strings"
 	"testing"
 	"time"
 )
@@ -202,8 +204,6 @@ func TestEntryProtected(t *testing.T) {
 }
 
 func TestIsMainWorktree(t *testing.T) {
-	t.Parallel()
-
 	root := t.TempDir()
 	mainPath := filepath.Join(root, "main")
 	separateMainPath := filepath.Join(root, "separate-main")
@@ -224,6 +224,12 @@ func TestIsMainWorktree(t *testing.T) {
 	if err := os.MkdirAll(linkedGitDir, 0o750); err != nil {
 		t.Fatalf("mkdir linked gitdir: %v", err)
 	}
+	if err := os.WriteFile(filepath.Join(separateGitDir, "HEAD"), []byte("ref: refs/heads/main\n"), 0o600); err != nil {
+		t.Fatalf("write separate gitdir HEAD: %v", err)
+	}
+	if err := os.WriteFile(filepath.Join(separateGitDir, "config"), []byte("[core]\n"), 0o600); err != nil {
+		t.Fatalf("write separate gitdir config: %v", err)
+	}
 	if err := os.WriteFile(filepath.Join(separateMainPath, ".git"), []byte("gitdir: "+separateGitDir+"\n"), 0o600); err != nil {
 		t.Fatalf("write separate main .git file: %v", err)
 	}
@@ -237,10 +243,89 @@ func TestIsMainWorktree(t *testing.T) {
 	if !isMainWorktree(separateMainPath) {
 		t.Fatalf("expected %q with separate git dir to be detected as the main worktree", separateMainPath)
 	}
+	if !isMainWorktree(separateGitDir) {
+		t.Fatalf("expected %q gitdir path to be detected as the main worktree entry", separateGitDir)
+	}
 	if isMainWorktree(linkedPath) {
 		t.Fatalf("expected %q to be detected as a linked worktree", linkedPath)
 	}
 	if isMainWorktree(missingPath) {
 		t.Fatalf("expected %q without .git metadata to be non-main", missingPath)
 	}
 }
+
+func TestListProtectsSeparateGitDirMainWorktree(t *testing.T) {
+	root := t.TempDir()
+	mainPath := filepath.Join(root, "main")
+	gitDir := filepath.Join(root, "repo.git")
+	linkedPath := filepath.Join(root, "feature")
+
+	runGit(t, root, "init", "-b", "main", "--separate-git-dir", gitDir, mainPath)
+	runGit(t, mainPath, "config", "user.name", "Test User")
+	runGit(t, mainPath, "config", "user.email", "test@example.com")
+
+	if err := os.WriteFile(filepath.Join(mainPath, "README.md"), []byte("hello\n"), 0o600); err != nil {
+		t.Fatalf("write README.md: %v", err)
+	}
+	runGit(t, mainPath, "add", "README.md")
+	runGit(t, mainPath, "commit", "-m", "initial commit")
+	runGit(t, mainPath, "worktree", "add", "-b", "feature", linkedPath, "HEAD")
+
+	t.Chdir(mainPath)
+
+	entries, err := List()
+	if err != nil {
+		t.Fatalf("List(): %v", err)
+	}
+
+	var mainEntry *Entry
+	var linkedEntry *Entry
+	for i := range entries {
+		e := &entries[i]
+		switch {
+		case e.IsMain:
+			mainEntry = e
+		case samePath(e.Path, linkedPath):
+			linkedEntry = e
+		}
+	}
+
+	if mainEntry == nil {
+		t.Fatalf("expected a main worktree entry, got %+v", entries)
+	}
+	if !samePath(mainEntry.Path, gitDir) {
+		t.Fatalf("expected main entry path %q from git porcelain, got %q", gitDir, mainEntry.Path)
+	}
+	if !mainEntry.IsCurrent {
+		t.Fatalf("expected separate-git-dir main entry to be current: %+v", *mainEntry)
+	}
+	if !mainEntry.Protected() {
+		t.Fatalf("expected separate-git-dir main entry to be protected: %+v", *mainEntry)
+	}
+	merged := map[string]bool{mainEntry.Branch: true}
+	if shouldCleanEntry(*mainEntry, merged) {
+		t.Fatalf("expected main entry to be skipped by clean: %+v", *mainEntry)
+	}
+	if shouldNukeEntry(*mainEntry) {
+		t.Fatalf("expected main entry to be skipped by nuke: %+v", *mainEntry)
+	}
+
+	if linkedEntry == nil {
+		t.Fatalf("expected linked worktree entry, got %+v", entries)
+	}
+	if linkedEntry.IsMain {
+		t.Fatalf("expected linked entry to remain non-main: %+v", *linkedEntry)
+	}
+}
+
+func runGit(t *testing.T, dir string, args ...string) string {
+	t.Helper()
+
+	cmd := exec.Command("git", args...)
+	cmd.Dir = dir
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("git %s (dir=%s): %v\n%s", strings.Join(args, " "), dir, err, out)
+	}
+	return strings.TrimSpace(string(out))
+}