Merge pull request #176 from glasser/branch-name-flag

feat: add `-b`/`--branch` flag to specify branch name independently from worktree directory name

Author: k1LoW

README.md

@@ -8,6 +8,7 @@ A Git subcommand that makes `git worktree` simple.
 $ git wt                            # List all worktrees
 $ git wt --json                     # List all worktrees in JSON format
 $ git wt <branch|worktree|path>     # Switch to worktree (create worktree/branch if needed)
+$ git wt -b <branch> <worktree>     # Create worktree with a different branch name
 $ git wt -d <branch|worktree|path>  # Delete worktree and branch (safe)
 $ git wt -D <branch|worktree|path>  # Force delete worktree and branch
 ```
@@ -19,6 +20,19 @@ 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`
 
+Use `-b`/`--branch` to give the branch a different name from the worktree directory:
+
+``` console
+$ git wt -b user/my-feature my-feature
+```
+
+You can later switch to the worktree by either branch name or directory name:
+
+``` console
+$ git wt user/my-feature  # switch by branch name
+$ git wt my-feature       # switch by directory name
+```
+
 > [!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

@@ -40,6 +40,7 @@ var (
 	forceDeleteFlag bool
 	initShell       string
 	nocd            bool
+	branchFlag      string
 	// Config override flags.
 	basedirFlag       string
 	copyignoredFlag   bool
@@ -62,11 +63,12 @@ var rootCmd = &cobra.Command{
 	Long: `git-wt is a Git subcommand that makes 'git worktree' simple.
 
 Examples:
-  git wt                                    List all worktrees
-  git wt <branch|worktree|path>              Switch to worktree (create worktree/branch if needed)
+  git wt                                         List all worktrees
+  git wt <branch|worktree|path>                  Switch to worktree (create worktree/branch if needed)
   git wt <branch|worktree|path> <start-point>    Create worktree from start-point (e.g., origin/main)
-  git wt -d <branch|worktree|path>...       Delete worktree and branch (safe)
-  git wt -D <branch|worktree|path>...       Force delete worktree and branch
+  git wt -b <branch> <worktree>                  Create worktree with a different branch name
+  git wt -d <branch|worktree|path>...            Delete worktree and branch (safe)
+  git wt -D <branch|worktree|path>...            Force delete worktree and branch
 
 Note: The default branch (e.g., main, master) is protected from accidental deletion.
       - With worktree: worktree is deleted, but branch is preserved.
@@ -197,6 +199,7 @@ func init() {
 	if err := rootCmd.Flags().MarkDeprecated("no-switch-directory", "use --nocd instead"); err != nil {
 		panic(err) //nostyle:dontpanic
 	}
+	rootCmd.Flags().StringVarP(&branchFlag, "branch", "b", "", "Use a different branch name than the worktree directory name")
 	// Config override flags.
 	rootCmd.Flags().StringVar(&basedirFlag, "basedir", "", "Override wt.basedir config (worktree base directory)")
 	rootCmd.Flags().BoolVar(&copyignoredFlag, "copyignored", false, "Override wt.copyignored config (copy .gitignore'd files)")
@@ -237,10 +240,16 @@ func runRoot(cmd *cobra.Command, args []string) error {
 
 	// Handle delete flags (multiple arguments allowed)
 	if forceDeleteFlag {
+		if branchFlag != "" {
+			return fmt.Errorf("cannot use -b/--branch with -D/--force-delete")
+		}
 		args = uniqueArgs(args)
 		return deleteWorktrees(ctx, cmd, args, true)
 	}
 	if deleteFlag {
+		if branchFlag != "" {
+			return fmt.Errorf("cannot use -b/--branch with -d/--delete")
+		}
 		args = uniqueArgs(args)
 		return deleteWorktrees(ctx, cmd, args, false)
 	}
@@ -251,14 +260,19 @@ func runRoot(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("too many arguments: expected <branch> [<start-point>], got %d arguments", len(args))
 	}
 
-	branch := args[0]
+	wtName := args[0]
 	var startPoint string
 	if len(args) == 2 {
 		startPoint = args[1]
 	}
 
+	branchName := branchFlag
+	if branchName == "" {
+		branchName = wtName
+	}
+
 	// Default: create or switch to worktree
-	return handleWorktree(ctx, cmd, branch, startPoint)
+	return handleWorktree(ctx, cmd, wtName, branchName, startPoint)
 }
 
 // loadConfig loads config from git config and applies flag overrides.
@@ -704,7 +718,7 @@ func deleteWorktrees(ctx context.Context, cmd *cobra.Command, branches []string,
 	return nil
 }
 
-func handleWorktree(ctx context.Context, cmd *cobra.Command, branch, startPoint string) error {
+func handleWorktree(ctx context.Context, cmd *cobra.Command, wtName, branchName, startPoint string) error {
 	// Load config with flag overrides
 	cfg, err := loadConfig(ctx, cmd)
 	if err != nil {
@@ -733,10 +747,17 @@ func handleWorktree(ctx context.Context, cmd *cobra.Command, branch, startPoint
 	}
 
 	// Check if worktree already exists for this branch or directory name
-	wt, err := git.FindWorktreeByBranchOrDir(ctx, branch)
+	wt, err := git.FindWorktreeByBranchOrDir(ctx, branchName)
 	if err != nil {
 		return fmt.Errorf("failed to find worktree: %w", err)
 	}
+	if wt == nil && branchName != wtName {
+		// Also try finding by worktree directory name
+		wt, err = git.FindWorktreeByBranchOrDir(ctx, wtName)
+		if err != nil {
+			return fmt.Errorf("failed to find worktree: %w", err)
+		}
+	}
 
 	if wt != nil {
 		// Worktree exists, print path to stdout
@@ -745,27 +766,27 @@ func handleWorktree(ctx context.Context, cmd *cobra.Command, branch, startPoint
 		return nil
 	}
 
-	// Get worktree path
-	wtPath, err := git.WorktreePathFor(ctx, cfg.BaseDir, branch)
+	// Get worktree path using the worktree name (not the branch name)
+	wtPath, err := git.WorktreePathFor(ctx, cfg.BaseDir, wtName)
 	if err != nil {
 		return fmt.Errorf("failed to get worktree path: %w", err)
 	}
 
 	// Check if branch exists
-	exists, err := git.BranchExists(ctx, branch)
+	exists, err := git.BranchExists(ctx, branchName)
 	if err != nil {
 		return fmt.Errorf("failed to check branch: %w", err)
 	}
 
 	if exists {
 		// Branch exists, create worktree with existing branch
 		// start-point is ignored when using existing branch
-		if err := git.AddWorktree(ctx, wtPath, branch, copyOpts); err != nil {
+		if err := git.AddWorktree(ctx, wtPath, branchName, copyOpts); err != nil {
 			return fmt.Errorf("failed to create worktree: %w", err)
 		}
 	} else {
 		// Branch doesn't exist, create new branch and worktree
-		if err := git.AddWorktreeWithNewBranch(ctx, wtPath, branch, startPoint, copyOpts); err != nil {
+		if err := git.AddWorktreeWithNewBranch(ctx, wtPath, branchName, startPoint, copyOpts); err != nil {
 			return fmt.Errorf("failed to create worktree with new branch: %w", err)
 		}
 	}

e2e/basic_test.go

@@ -482,6 +482,125 @@ func TestE2E_CreateWorktree(t *testing.T) {
 			t.Errorf("second worktree path = %q, want %q", wt2Path, expectedWt2Path)
 		}
 	})
+
+	t.Run("branch_flag_new_branch", func(t *testing.T) {
+		t.Parallel()
+		repo := testutil.NewTestRepo(t)
+		repo.CreateFile("README.md", "# Test")
+		repo.Commit("initial commit")
+
+		stdout, stderr, err := runGitWtStdout(t, binPath, repo.Root, "-b", "glasser/my-feature", "my-feature")
+		if err != nil {
+			t.Fatalf("git-wt -b failed: %v\nstderr: %s", err, stderr)
+		}
+
+		wtPath := strings.TrimSpace(stdout)
+		// Worktree directory should be named "my-feature", not "glasser/my-feature"
+		expectedPath := filepath.Join(repo.Root, ".wt", "my-feature")
+		if wtPath != expectedPath {
+			t.Errorf("worktree path = %q, want %q", wtPath, expectedPath)
+		}
+		if _, err := os.Stat(wtPath); os.IsNotExist(err) {
+			t.Fatalf("worktree directory was not created at %s", wtPath)
+		}
+
+		// Verify the branch name is "glasser/my-feature"
+		restore := repo.Chdir()
+		defer restore()
+		cmd := exec.Command("git", "branch", "--list", "glasser/my-feature")
+		branchOut, err := cmd.Output()
+		if err != nil {
+			t.Fatalf("git branch --list failed: %v", err)
+		}
+		if !strings.Contains(string(branchOut), "glasser/my-feature") {
+			t.Errorf("branch glasser/my-feature should exist, got: %s", branchOut)
+		}
+	})
+
+	t.Run("branch_flag_with_start_point", func(t *testing.T) {
+		t.Parallel()
+		repo := testutil.NewTestRepo(t)
+		repo.CreateFile("README.md", "# Test")
+		repo.Commit("initial commit")
+
+		repo.CreateFile("main-file.txt", "main content")
+		repo.Commit("main commit")
+
+		repo.Git("branch", "old-base", "HEAD~1")
+
+		stdout, stderr, err := runGitWtStdout(t, binPath, repo.Root, "-b", "glasser/from-old", "from-old", "old-base")
+		if err != nil {
+			t.Fatalf("git-wt -b with start-point failed: %v\nstderr: %s", err, stderr)
+		}
+
+		wtPath := strings.TrimSpace(stdout)
+		expectedPath := filepath.Join(repo.Root, ".wt", "from-old")
+		if wtPath != expectedPath {
+			t.Errorf("worktree path = %q, want %q", wtPath, expectedPath)
+		}
+
+		// Verify the worktree is based on old-base (should NOT have main-file.txt)
+		mainFilePath := filepath.Join(wtPath, "main-file.txt")
+		if _, err := os.Stat(mainFilePath); !os.IsNotExist(err) {
+			t.Error("worktree should NOT have main-file.txt (should be based on old-base)")
+		}
+	})
+
+	t.Run("branch_flag_existing_branch", func(t *testing.T) {
+		t.Parallel()
+		repo := testutil.NewTestRepo(t)
+		repo.CreateFile("README.md", "# Test")
+		repo.Commit("initial commit")
+
+		// Create an existing branch
+		repo.Git("branch", "glasser/existing")
+
+		stdout, stderr, err := runGitWtStdout(t, binPath, repo.Root, "-b", "glasser/existing", "existing")
+		if err != nil {
+			t.Fatalf("git-wt -b with existing branch failed: %v\nstderr: %s", err, stderr)
+		}
+
+		wtPath := strings.TrimSpace(stdout)
+		expectedPath := filepath.Join(repo.Root, ".wt", "existing")
+		if wtPath != expectedPath {
+			t.Errorf("worktree path = %q, want %q", wtPath, expectedPath)
+		}
+		if _, err := os.Stat(wtPath); os.IsNotExist(err) {
+			t.Fatalf("worktree directory was not created at %s", wtPath)
+		}
+	})
+
+	t.Run("branch_flag_switch_by_branch", func(t *testing.T) {
+		t.Parallel()
+		repo := testutil.NewTestRepo(t)
+		repo.CreateFile("README.md", "# Test")
+		repo.Commit("initial commit")
+
+		// Create worktree with -b
+		stdout1, stderr, err := runGitWtStdout(t, binPath, repo.Root, "-b", "glasser/feat", "feat")
+		if err != nil {
+			t.Fatalf("git-wt -b create failed: %v\nstderr: %s", err, stderr)
+		}
+		wtPath := strings.TrimSpace(stdout1)
+
+		// Switch to it by branch name
+		stdout2, stderr, err := runGitWtStdout(t, binPath, repo.Root, "glasser/feat")
+		if err != nil {
+			t.Fatalf("git-wt switch by branch failed: %v\nstderr: %s", err, stderr)
+		}
+		if strings.TrimSpace(stdout2) != wtPath {
+			t.Errorf("switch by branch returned %q, want %q", strings.TrimSpace(stdout2), wtPath)
+		}
+
+		// Switch to it by directory name
+		stdout3, stderr, err := runGitWtStdout(t, binPath, repo.Root, "feat")
+		if err != nil {
+			t.Fatalf("git-wt switch by dir failed: %v\nstderr: %s", err, stderr)
+		}
+		if strings.TrimSpace(stdout3) != wtPath {
+			t.Errorf("switch by dir returned %q, want %q", strings.TrimSpace(stdout3), wtPath)
+		}
+	})
 }
 
 func TestE2E_SwitchWorktree(t *testing.T) {