feat: simplify branch selection with smart conflict resolution

Author: wasabeef

CLAUDE.md

@@ -54,6 +54,7 @@ cargo check --all-features
 cargo doc --no-deps --open
 ```
 
+
 ### Installation
 
 ```bash
@@ -67,13 +68,25 @@ cargo install --path .
 source /path/to/git-workers/shell/gw.sh
 ```
 
+## Recent Changes
+
+### Branch Option Simplification
+- Reduced from 3 options to 2: "Create from current HEAD" and "Select branch (smart mode)"
+- Smart mode automatically handles branch conflicts and offers appropriate actions
+
+### Key Methods Added/Modified
+- **`get_branch_worktree_map()`**: Maps branch names to worktree names, including main worktree detection
+- **`list_all_branches()`**: Returns both local and remote branches (remote without "origin/" prefix)
+- **`create_worktree_with_new_branch()`**: Creates worktree with new branch from base branch (supports git-flow style workflows)
+
 ## Architecture
 
 ### Core Module Structure
 
 ```
 src/
 ├── main.rs              # CLI entry point and main menu loop
+├── lib.rs               # Library exports
 ├── commands.rs          # Command implementations for menu items
 ├── git.rs               # Git worktree operations (git2 + process::Command)
 ├── menu.rs              # MenuItem enum and icon definitions
@@ -114,12 +127,14 @@ post-switch = ["echo 'Switched to {{worktree_name}}'"]
 ```
 
 Template variables:
+
 - `{{worktree_name}}`: The worktree name
 - `{{worktree_path}}`: Absolute path to worktree
 
 ### Worktree Patterns
 
 First worktree creation offers two options:
+
 1. Same level as repository: `../worktree-name`
 2. In subdirectory (recommended): `../repo/worktrees/worktree-name`
 
@@ -128,13 +143,15 @@ Subsequent worktrees follow the established pattern automatically.
 ### ESC Key Handling
 
 All interactive prompts support ESC cancellation through custom `input_esc_raw` module:
+
 - `input_esc_raw()` returns `Option<String>` (None on ESC)
 - `Select::interact_opt()` for menu selections
 - `Confirm::interact_opt()` for confirmations
 
 ### Worktree Rename Implementation
 
 Since Git lacks native rename functionality:
+
 1. Move directory with `fs::rename`
 2. Update `.git/worktrees/<name>` metadata directory
 3. Update gitdir files in both directions
@@ -149,9 +166,11 @@ Since Git lacks native rename functionality:
 
 ### Testing Considerations
 
+- Integration tests in `tests/` directory (27 test files)
 - Some tests are flaky in parallel execution (marked with `#[ignore]`)
 - CI sets `CI=true` environment variable to skip flaky tests
 - Run with `--test-threads=1` for reliable results
+- Use `--nocapture` to see test output for debugging
 
 ### Important Constraints
 
@@ -161,3 +180,4 @@ Since Git lacks native rename functionality:
 - Cannot rename worktrees with detached HEAD
 - Shell integration supports Bash/Zsh only
 - No Windows support (macOS and Linux only)
+- Recent breaking change: CLI arguments removed in favor of menu-only interface

README.md

@@ -56,7 +56,12 @@ Git Workers provides an interactive menu-driven interface. Simply run `gw` and n
 
 - **List worktrees** (`•`): Display all worktrees with branch, changes, and sync status
 - **Search worktrees** (`?`): Fuzzy search through worktree names and branches
-- **Create worktree** (`+`): Create a new worktree from existing branch or create a new branch
+- **Create worktree** (`+`): Create a new worktree with two options:
+  - **Create from current HEAD**: Creates a new worktree with a new branch from the current HEAD
+  - **Select branch (smart mode)**: Choose from local/remote branches with automatic conflict resolution:
+    - Shows both local and remote branches with usage status
+    - Automatically handles branch conflicts (offers to create new branch if already in use)
+    - Remote branches are prefixed with `↑` for easy identification
 - **Delete worktree** (`-`): Delete a single worktree with safety checks
 - **Batch delete** (`=`): Select and delete multiple worktrees at once (optionally deletes orphaned branches)
 - **Cleanup old worktrees** (`~`): Remove worktrees older than specified days

src/commands.rs

@@ -27,7 +27,7 @@ use indicatif::{ProgressBar, ProgressStyle};
 use std::time::Duration;
 use unicode_width::UnicodeWidthStr;
 
-use crate::constants::section_header;
+use crate::constants::{section_header, GIT_REMOTE_PREFIX, WORKTREES_SUBDIR};
 use crate::git::{GitWorktreeManager, WorktreeInfo};
 use crate::hooks::{self, HookContext};
 use crate::input_esc_raw::{
@@ -524,7 +524,7 @@ fn create_worktree_internal(manager: &GitWorktreeManager) -> Result<bool> {
 
         let options = vec![
             format!("Same level as repository (../{name})"),
-            format!("In subdirectory ({repo_name}/worktrees/{name})"),
+            format!("In subdirectory ({repo_name}/{}/{name})", WORKTREES_SUBDIR),
         ];
 
         let selection = match Select::with_theme(&get_theme())
@@ -538,16 +538,16 @@ fn create_worktree_internal(manager: &GitWorktreeManager) -> Result<bool> {
         };
 
         match selection {
-            0 => format!("../{}", name),        // Same level
-            _ => format!("worktrees/{}", name), // Subdirectory pattern
+            0 => format!("../{}", name),                   // Same level
+            _ => format!("{}/{}", WORKTREES_SUBDIR, name), // Subdirectory pattern
         }
     } else {
         name.clone()
     };
 
     // Branch handling
     println!();
-    let branch_options = vec!["Create from current HEAD", "Create from existing branch"];
+    let branch_options = vec!["Create from current HEAD", "Select branch (smart mode)"];
 
     let branch_choice = match Select::with_theme(&get_theme())
         .with_prompt("Select branch option")
@@ -558,32 +558,221 @@ fn create_worktree_internal(manager: &GitWorktreeManager) -> Result<bool> {
         None => return Ok(false),
     };
 
-    let branch = if branch_choice == 1 {
-        // Show existing branches
-        let branches = manager.list_branches()?;
-        if branches.is_empty() {
-            utils::print_warning("No branches found, creating from HEAD");
-            None
-        } else {
-            println!();
-            match Select::with_theme(&get_theme())
-                .with_prompt("Select a branch")
-                .items(&branches)
-                .interact_opt()?
-            {
-                Some(selection) => Some(branches[selection].clone()),
-                None => return Ok(false),
+    let (branch, new_branch_name) = match branch_choice {
+        1 => {
+            // Select branch (smart mode)
+            let (local_branches, remote_branches) = manager.list_all_branches()?;
+            if local_branches.is_empty() && remote_branches.is_empty() {
+                utils::print_warning("No branches found, creating from HEAD");
+                (None, None)
+            } else {
+                // Get branch to worktree mapping
+                let branch_worktree_map = manager.get_branch_worktree_map()?;
+
+                // Create display items without section headers
+                let mut branch_items: Vec<String> = Vec::new();
+                let mut branch_refs: Vec<(String, bool)> = Vec::new(); // (branch_name, is_remote)
+
+                // Add local branches
+                for branch in &local_branches {
+                    if let Some(worktree) = branch_worktree_map.get(branch) {
+                        branch_items.push(format!(
+                            "  {} {}",
+                            branch.white(),
+                            format!("(in use by '{}')", worktree).bright_red()
+                        ));
+                    } else {
+                        branch_items.push(format!("  {}", branch.white()));
+                    }
+                    branch_refs.push((branch.clone(), false));
+                }
+
+                // Add remote branches with clear distinction
+                for branch in &remote_branches {
+                    let full_remote_name = format!("{}{}", GIT_REMOTE_PREFIX, branch);
+                    if let Some(worktree) = branch_worktree_map.get(&full_remote_name) {
+                        branch_items.push(format!(
+                            "↑ {} {}",
+                            full_remote_name.bright_blue(),
+                            format!("(in use by '{}')", worktree).bright_red()
+                        ));
+                    } else {
+                        branch_items.push(format!("↑ {}", full_remote_name.bright_blue()));
+                    }
+                    branch_refs.push((branch.clone(), true));
+                }
+
+                println!();
+                match Select::with_theme(&get_theme())
+                    .with_prompt("Select a branch")
+                    .items(&branch_items)
+                    .interact_opt()?
+                {
+                    Some(selection) => {
+                        let (selected_branch, is_remote) = &branch_refs[selection];
+
+                        if !is_remote {
+                            // Local branch - check if already checked out
+                            if let Some(worktree) = branch_worktree_map.get(selected_branch) {
+                                // Branch is in use, offer to create a new branch
+                                println!();
+                                utils::print_warning(&format!(
+                                    "Branch '{}' is already checked out in worktree '{}'",
+                                    selected_branch.yellow(),
+                                    worktree.bright_red()
+                                ));
+                                println!();
+
+                                let action_options = vec![
+                                    format!(
+                                        "Create new branch '{}' from '{}'",
+                                        name, selected_branch
+                                    ),
+                                    "Change the branch name".to_string(),
+                                    "Cancel".to_string(),
+                                ];
+
+                                match Select::with_theme(&get_theme())
+                                    .with_prompt("What would you like to do?")
+                                    .items(&action_options)
+                                    .interact_opt()?
+                                {
+                                    Some(0) => {
+                                        // Use worktree name as new branch name
+                                        (Some(selected_branch.clone()), Some(name.clone()))
+                                    }
+                                    Some(1) => {
+                                        // Ask for custom branch name
+                                        println!();
+                                        let new_branch = match input_esc_with_default(
+                                            &format!(
+                                                "Enter new branch name (base: {})",
+                                                selected_branch.yellow()
+                                            ),
+                                            &name,
+                                        ) {
+                                            Some(name) => name.trim().to_string(),
+                                            None => return Ok(false),
+                                        };
+
+                                        if new_branch.is_empty() {
+                                            utils::print_error("Branch name cannot be empty");
+                                            return Ok(false);
+                                        }
+
+                                        if local_branches.contains(&new_branch) {
+                                            utils::print_error(&format!(
+                                                "Branch '{}' already exists",
+                                                new_branch
+                                            ));
+                                            return Ok(false);
+                                        }
+
+                                        (Some(selected_branch.clone()), Some(new_branch))
+                                    }
+                                    _ => return Ok(false),
+                                }
+                            } else {
+                                (Some(selected_branch.clone()), None)
+                            }
+                        } else {
+                            // Remote branch - check if local branch with same name exists
+                            if local_branches.contains(selected_branch) {
+                                // Local branch with same name exists
+                                println!();
+                                utils::print_warning(&format!(
+                                    "A local branch '{}' already exists for remote '{}'",
+                                    selected_branch.yellow(),
+                                    format!("{}{}", GIT_REMOTE_PREFIX, selected_branch)
+                                        .bright_blue()
+                                ));
+                                println!();
+
+                                let use_local_option = if let Some(worktree) =
+                                    branch_worktree_map.get(selected_branch)
+                                {
+                                    format!(
+                                        "Use the existing local branch instead (in use by '{}')",
+                                        worktree.bright_red()
+                                    )
+                                } else {
+                                    "Use the existing local branch instead".to_string()
+                                };
+
+                                let action_options = vec![
+                                    format!(
+                                        "Create new branch '{}' from '{}{}'",
+                                        name, GIT_REMOTE_PREFIX, selected_branch
+                                    ),
+                                    use_local_option,
+                                    "Cancel".to_string(),
+                                ];
+
+                                match Select::with_theme(&get_theme())
+                                    .with_prompt("What would you like to do?")
+                                    .items(&action_options)
+                                    .interact_opt()?
+                                {
+                                    Some(0) => {
+                                        // Create new branch with worktree name
+                                        (
+                                            Some(format!(
+                                                "{}{}",
+                                                GIT_REMOTE_PREFIX, selected_branch
+                                            )),
+                                            Some(name.clone()),
+                                        )
+                                    }
+                                    Some(1) => {
+                                        // Use local branch instead - but check if it's already in use
+                                        if let Some(worktree) =
+                                            branch_worktree_map.get(selected_branch)
+                                        {
+                                            println!();
+                                            utils::print_error(&format!(
+                                                "Branch '{}' is already checked out in worktree '{}'",
+                                                selected_branch.yellow(),
+                                                worktree.bright_red()
+                                            ));
+                                            println!("Please select a different option.");
+                                            return Ok(false);
+                                        }
+                                        (Some(selected_branch.clone()), None)
+                                    }
+                                    _ => return Ok(false),
+                                }
+                            } else {
+                                // No conflict, proceed normally
+                                (
+                                    Some(format!("{}{}", GIT_REMOTE_PREFIX, selected_branch)),
+                                    None,
+                                )
+                            }
+                        }
+                    }
+                    None => return Ok(false),
+                }
             }
         }
-    } else {
-        None
+        _ => {
+            // Create from current HEAD
+            (None, None)
+        }
     };
 
     // Show preview
     println!();
     println!("{}", "Preview:".bright_white());
     println!("  {} {}", "Name:".bright_black(), final_name.bright_green());
-    if let Some(branch_name) = &branch {
+    if let Some(new_branch) = &new_branch_name {
+        let base_branch_name = branch.as_ref().unwrap();
+        println!(
+            "  {} {} (from {})",
+            "New Branch:".bright_black(),
+            new_branch.yellow(),
+            base_branch_name.bright_black()
+        );
+    } else if let Some(branch_name) = &branch {
         println!("  {} {}", "Branch:".bright_black(), branch_name.yellow());
     } else {
         println!("  {} Current HEAD", "From:".bright_black());
@@ -600,7 +789,15 @@ fn create_worktree_internal(manager: &GitWorktreeManager) -> Result<bool> {
     pb.set_message("Creating worktree...");
     pb.enable_steady_tick(Duration::from_millis(100));
 
-    match manager.create_worktree(&final_name, branch.as_deref()) {
+    let result = if let Some(new_branch) = &new_branch_name {
+        // Create worktree with new branch from base branch
+        manager.create_worktree_with_new_branch(&final_name, new_branch, branch.as_ref().unwrap())
+    } else {
+        // Create worktree with existing branch or from HEAD
+        manager.create_worktree(&final_name, branch.as_deref())
+    };
+
+    match result {
         Ok(path) => {
             pb.finish_and_clear();
             utils::print_success(&format!(