feat: support delete operation in bare repositories

Author: usadamasa

README.md

@@ -19,10 +19,6 @@ The target can be specified as:
 
 When deleting, the same target types apply: `git wt -d feature-branch`, `git wt -d .`, `git wt -d ../sibling`
 
-> [!NOTE]
-> Bare repositories are not currently supported.
-> Bare repository support is planned: see [#130](https://github.com/k1LoW/git-wt/issues/130) for details.
-
 > [!NOTE]
 > The default branch (e.g., main, master) is protected from accidental deletion.
 > - If the default branch has a worktree, the worktree is deleted but the branch is preserved.

cmd/root.go

@@ -72,10 +72,6 @@ Note: The default branch (e.g., main, master) is protected from accidental delet
       - Without worktree: deletion is blocked entirely.
       Use --allow-delete-default to override and delete the branch.
 
-Note: Bare repositories are supported for list and add/switch operations.
-      Delete operation in bare repositories is not yet supported.
-      See https://github.com/k1LoW/git-wt/issues/130 for details.
-
 Shell Integration:
   Add the following to your shell config to enable worktree switching and completion:
 
@@ -217,8 +213,8 @@ func runRoot(cmd *cobra.Command, args []string) error {
 	}
 
 	// Detect repo context once and thread it through context.
-	// Subsequent calls to DetectRepoContext (via AssertNotBareRepository etc.)
-	// will reuse the cached value instead of spawning git processes again.
+	// Subsequent calls to DetectRepoContext will reuse the cached value
+	// instead of spawning git processes again.
 	rc, err := git.DetectRepoContext(ctx)
 	if err != nil {
 		return err
@@ -231,21 +227,11 @@ func runRoot(cmd *cobra.Command, args []string) error {
 	}
 
 	// Handle delete flags (multiple arguments allowed)
-	// Guard: bare repositories are not supported for delete operation.
-	// Remove this guard when bare delete support is implemented.
 	if forceDeleteFlag {
-		if err := git.AssertNotBareRepository(ctx); err != nil {
-			return err
-		}
-		// Remove duplicates while preserving order
 		args = uniqueArgs(args)
 		return deleteWorktrees(ctx, cmd, args, true)
 	}
 	if deleteFlag {
-		if err := git.AssertNotBareRepository(ctx); err != nil {
-			return err
-		}
-		// Remove duplicates while preserving order
 		args = uniqueArgs(args)
 		return deleteWorktrees(ctx, cmd, args, false)
 	}
@@ -662,6 +648,15 @@ func deleteWorktrees(ctx context.Context, cmd *cobra.Command, branches []string,
 			continue
 		}
 
+		// Check if the target matches the bare repository entry
+		isBareEntry, err := git.IsBareEntry(ctx, branch)
+		if err != nil {
+			return fmt.Errorf("failed to check bare entry: %w", err)
+		}
+		if isBareEntry {
+			return fmt.Errorf("cannot delete bare repository entry %q: the bare repository root cannot be removed as a worktree", branch)
+		}
+
 		// Case 2: No worktree - try to delete branch only
 		exists, err := git.LocalBranchExists(ctx, branch)
 		if err != nil {

e2e/bare_test.go

@@ -3,10 +3,11 @@
 // Covered scenarios:
 //   - List operation: supported in both bare root and worktrees from bare repos
 //   - Add/switch operations: supported in both bare root and worktrees from bare repos
-//   - Delete operation: not yet supported, should return errors
+//   - Delete operation: supported from bare-derived worktrees; bare entry itself is protected
 package e2e
 
 import (
+	"bytes"
 	"encoding/json"
 	"os"
 	"path/filepath"
@@ -392,41 +393,202 @@ func TestE2E_BareRepository(t *testing.T) {
 		}
 	})
 
-	// --- Tests for operations that still don't support bare repositories ---
+}
+
+// TestE2E_BareDelete tests delete operations in bare repository environments.
+func TestE2E_BareDelete(t *testing.T) {
+	t.Parallel()
+	binPath := buildBinary(t)
+
+	// --- Success: delete linked worktree from bare root ---
+
+	t.Run("bare_root_safe_delete", func(t *testing.T) {
+		t.Parallel()
+		bareRepo := testutil.NewBareTestRepo(t)
+		wtPath := createBareWorktree(t, binPath, bareRepo.Root, "feature-del")
+
+		// Safe delete from bare root
+		out, err := runGitWt(t, binPath, bareRepo.Root, "-d", "feature-del")
+		if err != nil {
+			t.Fatalf("git-wt -d failed: %v\noutput: %s", err, out)
+		}
+
+		// Worktree should be deleted
+		if _, err := os.Stat(wtPath); !os.IsNotExist(err) {
+			t.Error("worktree should have been deleted")
+		}
+		if !strings.Contains(out, "Deleted") {
+			t.Errorf("output should contain 'Deleted', got: %s", out)
+		}
+	})
+
+	t.Run("bare_root_force_delete", func(t *testing.T) {
+		t.Parallel()
+		bareRepo := testutil.NewBareTestRepo(t)
+		wtPath := createBareWorktree(t, binPath, bareRepo.Root, "unmerged-del")
+		commitUnmergedChange(t, wtPath)
+
+		// Force delete from bare root
+		out, err := runGitWt(t, binPath, bareRepo.Root, "-D", "unmerged-del")
+		if err != nil {
+			t.Fatalf("git-wt -D failed: %v\noutput: %s", err, out)
+		}
 
-	t.Run("direct_bare_delete", func(t *testing.T) {
+		// Worktree should be deleted
+		if _, err := os.Stat(wtPath); !os.IsNotExist(err) {
+			t.Error("worktree should have been force deleted")
+		}
+	})
+
+	// --- Error: attempting to delete bare entry itself ---
+
+	t.Run("bare_root_delete_self", func(t *testing.T) {
 		t.Parallel()
 		bareRepo := testutil.NewBareTestRepo(t)
 
-		// Run git-wt with -d flag (delete mode) inside the bare repo
+		// Try to delete main (the bare entry's branch) from bare root
 		out, err := runGitWt(t, binPath, bareRepo.Root, "-d", "main")
 		if err == nil {
-			t.Fatalf("expected error for bare repository, but succeeded with output: %s", out)
+			t.Fatalf("expected error when deleting bare entry, but succeeded with output: %s", out)
 		}
-		if !strings.Contains(out, "bare") {
-			t.Errorf("error message should mention 'bare', got: %s", out)
+		if !strings.Contains(out, "bare repository entry") {
+			t.Errorf("error message should mention 'bare repository entry', got: %s", out)
 		}
 	})
 
-	t.Run("worktree_from_bare_delete", func(t *testing.T) {
+	t.Run("bare_root_delete_self_dot", func(t *testing.T) {
 		t.Parallel()
 		bareRepo := testutil.NewBareTestRepo(t)
 
-		// Create a worktree from the bare repo
-		wtPath := filepath.Join(bareRepo.ParentDir(), "wt-main")
-		cmd := exec.Command("git", "-C", bareRepo.Root, "worktree", "add", wtPath, "main")
-		if out, err := cmd.CombinedOutput(); err != nil {
-			t.Fatalf("git worktree add failed: %v\noutput: %s", err, out)
+		// Try to delete "." (current directory = bare root) from bare root
+		out, err := runGitWt(t, binPath, bareRepo.Root, "-d", ".")
+		if err == nil {
+			t.Fatalf("expected error when deleting bare entry via '.', but succeeded with output: %s", out)
+		}
+		if !strings.Contains(out, "bare repository entry") {
+			t.Errorf("error message should mention 'bare repository entry', got: %s", out)
+		}
+	})
+
+	// --- Success: delete from bare-derived worktree ---
+
+	t.Run("bare_worktree_delete_other", func(t *testing.T) {
+		t.Parallel()
+		bareRepo := testutil.NewBareTestRepo(t)
+		wtPathA := createBareWorktree(t, binPath, bareRepo.Root, "wt-a")
+		wtPathB := createBareWorktree(t, binPath, bareRepo.Root, "wt-b")
+
+		// From worktree B, delete worktree A
+		out, err := runGitWt(t, binPath, wtPathB, "-d", "wt-a")
+		if err != nil {
+			t.Fatalf("git-wt -d failed: %v\noutput: %s", err, out)
+		}
+
+		// Worktree A should be deleted
+		if _, err := os.Stat(wtPathA); !os.IsNotExist(err) {
+			t.Error("worktree A should have been deleted")
+		}
+		// Worktree B should still exist
+		if _, err := os.Stat(wtPathB); os.IsNotExist(err) {
+			t.Error("worktree B should still exist")
+		}
+	})
+
+	t.Run("bare_worktree_delete_current", func(t *testing.T) {
+		t.Parallel()
+		bareRepo := testutil.NewBareTestRepo(t)
+		wtPath := createBareWorktree(t, binPath, bareRepo.Root, "current-del")
+
+		// Delete current worktree from inside it (with shell integration)
+		cmd := exec.Command(binPath, "-D", "current-del")
+		cmd.Dir = wtPath
+		cmd.Env = append(os.Environ(), "GIT_WT_SHELL_INTEGRATION=1")
+		var stdoutBuf, stderrBuf bytes.Buffer
+		cmd.Stdout = &stdoutBuf
+		cmd.Stderr = &stderrBuf
+		if err := cmd.Run(); err != nil {
+			t.Fatalf("git-wt -D failed: %v\nstderr: %s", err, stderrBuf.String())
+		}
+
+		// Worktree should be deleted
+		if _, err := os.Stat(wtPath); !os.IsNotExist(err) {
+			t.Error("worktree should have been deleted")
+		}
+
+		// Shell integration should output bare root path
+		assertLastLine(t, stdoutBuf.String(), bareRepo.Root)
+	})
+
+	// --- Delete last worktree, cd back to bare root ---
+
+	t.Run("bare_delete_last_worktree_cd", func(t *testing.T) {
+		t.Parallel()
+		bareRepo := testutil.NewBareTestRepo(t)
+		wtPath := createBareWorktree(t, binPath, bareRepo.Root, "only-wt")
+
+		// Delete from inside the worktree (with shell integration)
+		cmd := exec.Command(binPath, "-D", "only-wt")
+		cmd.Dir = wtPath
+		cmd.Env = append(os.Environ(), "GIT_WT_SHELL_INTEGRATION=1")
+		var stdoutBuf, stderrBuf bytes.Buffer
+		cmd.Stdout = &stdoutBuf
+		cmd.Stderr = &stderrBuf
+		if err := cmd.Run(); err != nil {
+			t.Fatalf("git-wt -D failed: %v\nstderr: %s", err, stderrBuf.String())
+		}
+
+		// Worktree should be deleted
+		if _, err := os.Stat(wtPath); !os.IsNotExist(err) {
+			t.Error("worktree should have been deleted")
 		}
-		t.Cleanup(func() { os.RemoveAll(wtPath) })
 
-		// Run git-wt with -d flag (delete mode) inside the worktree
-		out, err := runGitWt(t, binPath, wtPath, "-d", "main")
+		// Shell integration should output bare root path
+		assertLastLine(t, stdoutBuf.String(), bareRepo.Root)
+	})
+
+	// --- Error: modified files ---
+
+	t.Run("bare_worktree_delete_modified", func(t *testing.T) {
+		t.Parallel()
+		bareRepo := testutil.NewBareTestRepo(t)
+		wtPath := createBareWorktree(t, binPath, bareRepo.Root, "mod-wt")
+
+		// Add an untracked file
+		if err := os.WriteFile(filepath.Join(wtPath, "untracked.txt"), []byte("content"), 0600); err != nil {
+			t.Fatalf("failed to create untracked file: %v", err)
+		}
+
+		// Safe delete should fail
+		out, err := runGitWt(t, binPath, bareRepo.Root, "-d", "mod-wt")
 		if err == nil {
-			t.Fatalf("expected error for worktree from bare repo, but succeeded with output: %s", out)
+			t.Fatal("git-wt -d should fail when worktree has untracked files")
+		}
+		if !strings.Contains(out, "use -D to force deletion") {
+			t.Errorf("error should suggest '-D to force deletion', got: %s", out)
 		}
-		if !strings.Contains(out, "bare") {
-			t.Errorf("error message should mention 'bare', got: %s", out)
+
+		// Worktree should still exist
+		if _, err := os.Stat(wtPath); os.IsNotExist(err) {
+			t.Error("worktree should NOT have been deleted")
+		}
+	})
+
+	// --- dotgit bare variant ---
+
+	t.Run("dotgit_bare_delete", func(t *testing.T) {
+		t.Parallel()
+		bareRepo := testutil.NewDotGitBareTestRepo(t)
+		wtPath := createBareWorktree(t, binPath, bareRepo.Root, "dotgit-del")
+
+		// Safe delete from bare root
+		out, err := runGitWt(t, binPath, bareRepo.Root, "-d", "dotgit-del")
+		if err != nil {
+			t.Fatalf("git-wt -d failed: %v\noutput: %s", err, out)
+		}
+
+		// Worktree should be deleted
+		if _, err := os.Stat(wtPath); !os.IsNotExist(err) {
+			t.Error("worktree should have been deleted")
 		}
 	})
 }

e2e/helper_test.go

@@ -74,3 +74,59 @@ func worktreePath(output string) string {
 	}
 	return lines[len(lines)-1]
 }
+
+// createBareWorktree creates a worktree from the given directory using git-wt
+// and returns the worktree path.
+func createBareWorktree(t *testing.T, binPath, dir, branch string) string {
+	t.Helper()
+
+	stdout, _, err := runGitWtStdout(t, binPath, dir, branch)
+	if err != nil {
+		t.Fatalf("failed to create worktree %q: %v\nstdout: %s", branch, err, stdout)
+	}
+	return worktreePath(stdout)
+}
+
+// commitUnmergedChange creates a file and commits it in the given directory,
+// producing an unmerged commit relative to the parent branch.
+func commitUnmergedChange(t *testing.T, dir string) {
+	t.Helper()
+
+	// Ensure git user config is available (bare repo worktrees may not
+	// inherit user config when GIT_CONFIG_GLOBAL is /dev/null).
+	for _, args := range [][]string{
+		{"config", "user.email", "test@example.com"},
+		{"config", "user.name", "Test User"},
+	} {
+		cmd := exec.Command("git", args...)
+		cmd.Dir = dir
+		if err := cmd.Run(); err != nil {
+			t.Fatalf("git %s failed: %v", strings.Join(args, " "), err)
+		}
+	}
+
+	if err := os.WriteFile(filepath.Join(dir, "new.txt"), []byte("content"), 0600); err != nil {
+		t.Fatalf("failed to create file: %v", err)
+	}
+	cmd := exec.Command("git", "add", "-A")
+	cmd.Dir = dir
+	if err := cmd.Run(); err != nil {
+		t.Fatalf("git add failed: %v", err)
+	}
+	cmd = exec.Command("git", "commit", "-m", "unmerged commit")
+	cmd.Dir = dir
+	if err := cmd.Run(); err != nil {
+		t.Fatalf("git commit failed: %v", err)
+	}
+}
+
+// assertLastLine checks that the last line of output matches the expected string.
+func assertLastLine(t *testing.T, output, expected string) {
+	t.Helper()
+
+	lines := strings.Split(strings.TrimSpace(output), "\n")
+	lastLine := lines[len(lines)-1]
+	if lastLine != expected {
+		t.Errorf("last line should be %q, got %q", expected, lastLine)
+	}
+}

internal/git/branch.go

@@ -2,6 +2,7 @@ package git
 
 import (
 	"context"
+	"fmt"
 	"os"
 	"strings"
 )
@@ -187,6 +188,24 @@ func DefaultBranch(ctx context.Context) (string, error) {
 	return configBranch, nil
 }
 
+// HeadBranch returns the branch name that HEAD points to.
+// Returns an error if HEAD is detached or not a symbolic ref.
+func HeadBranch(ctx context.Context) (string, error) {
+	cmd, err := gitCommand(ctx, "symbolic-ref", "HEAD", "--short")
+	if err != nil {
+		return "", fmt.Errorf("failed to create git command: %w", err)
+	}
+	out, err := cmd.Output()
+	if err != nil {
+		return "", fmt.Errorf("failed to resolve HEAD (HEAD may be detached): %w", err)
+	}
+	branch := strings.TrimSpace(string(out))
+	if branch == "" {
+		return "", fmt.Errorf("symbolic-ref HEAD resolved to empty string")
+	}
+	return branch, nil
+}
+
 // IsDefaultBranch checks if the given branch name is the default branch.
 func IsDefaultBranch(ctx context.Context, branch string) (bool, error) {
 	defaultBranch, err := DefaultBranch(ctx)