perf(worktree): optimize lightweight selection flows

Author: Test User

src/adapters/git/git_worktree_repository.rs

@@ -1 +1,3 @@
-pub use crate::infrastructure::git::{CommitInfo, GitWorktreeManager, WorktreeInfo};
+pub use crate::infrastructure::git::{
+    BasicWorktreeInfo, CommitInfo, GitWorktreeManager, WorktreeInfo,
+};

src/adapters/git/mod.rs

@@ -2,6 +2,8 @@ pub mod git_worktree_repository;
 pub mod repo_discovery;
 pub mod worktree_lock;
 
-pub use git_worktree_repository::{CommitInfo, GitWorktreeManager, WorktreeInfo};
+pub use git_worktree_repository::{
+    BasicWorktreeInfo, CommitInfo, GitWorktreeManager, WorktreeInfo,
+};
 pub use repo_discovery::{open_repository_at_path, open_repository_from_env};
 pub use worktree_lock::WorktreeLock;

src/domain/worktree.rs

@@ -1 +1 @@
-pub use crate::adapters::git::WorktreeInfo;
+pub use crate::adapters::git::{BasicWorktreeInfo, WorktreeInfo};

src/infrastructure/git.rs

@@ -293,6 +293,65 @@ impl GitWorktreeManager {
         Ok(worktrees)
     }
 
+    /// Returns whether the repository has any linked worktrees.
+    ///
+    /// This intentionally does not count the main worktree. Its semantics must
+    /// stay aligned with `list_worktrees()` and the `create` first-worktree flow.
+    pub fn has_linked_worktrees(&self) -> Result<bool> {
+        let worktree_names = self.repo.worktrees()?;
+        Ok(worktree_names.iter().flatten().next().is_some())
+    }
+
+    /// Lists linked worktrees without loading status or commit metadata.
+    ///
+    /// This preserves the same ordering and identity fields as `list_worktrees()`,
+    /// but avoids the expensive per-worktree status scan used by detailed views.
+    pub fn list_worktrees_basic(&self) -> Result<Vec<BasicWorktreeInfo>> {
+        let mut worktrees = Vec::new();
+        let worktree_names = self.repo.worktrees()?;
+
+        for name in worktree_names.iter().flatten() {
+            if let Ok(worktree) = self.repo.find_worktree(name) {
+                let path = worktree.path();
+                let is_current = self.is_current_worktree(path);
+                let is_locked = worktree.is_locked().is_ok();
+
+                let branch = if let Ok(wt_repo) = Repository::open(path) {
+                    if let Ok(head) = wt_repo.head() {
+                        if let Some(shorthand) = head.shorthand() {
+                            shorthand.to_string()
+                        } else {
+                            String::from(DEFAULT_BRANCH_DETACHED)
+                        }
+                    } else {
+                        String::from(DEFAULT_BRANCH_DETACHED)
+                    }
+                } else {
+                    String::from(DEFAULT_BRANCH_UNKNOWN)
+                };
+
+                let display_name = path
+                    .file_name()
+                    .and_then(|name| name.to_str())
+                    .unwrap_or(name)
+                    .to_string();
+
+                worktrees.push(BasicWorktreeInfo {
+                    name: display_name,
+                    git_name: name.to_string(),
+                    path: path.to_path_buf(),
+                    branch,
+                    is_locked,
+                    is_current,
+                });
+            }
+        }
+
+        worktrees.sort_by(|a, b| a.name.cmp(&b.name));
+
+        Ok(worktrees)
+    }
+
     /// Checks if the given path is the current worktree
     ///
     /// # Arguments
@@ -1158,7 +1217,7 @@ impl GitWorktreeManager {
         branch_name: &str,
         worktree_name: &str,
     ) -> Result<bool> {
-        let worktrees = self.list_worktrees()?;
+        let worktrees = self.list_worktrees_basic()?;
         let mut count = 0;
         let mut found_in_target = false;
 
@@ -1583,6 +1642,26 @@ pub struct WorktreeInfo {
     pub ahead_behind: Option<(usize, usize)>, // (ahead, behind)
 }
 
+/// Lightweight information about a Git worktree.
+///
+/// This keeps only the fields needed for selection UIs and identity resolution,
+/// without opening each worktree to inspect status or commit metadata.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct BasicWorktreeInfo {
+    /// The display name of the worktree (derived from the directory name)
+    pub name: String,
+    /// The internal Git name of the worktree (from .git/worktrees/)
+    pub git_name: String,
+    /// The absolute filesystem path to the worktree
+    pub path: PathBuf,
+    /// The current branch name or "detached" if in detached HEAD state
+    pub branch: String,
+    /// Whether the worktree is locked (prevents deletion)
+    pub is_locked: bool,
+    /// Whether this is the currently active worktree
+    pub is_current: bool,
+}
+
 /// Information about a Git commit
 ///
 /// Contains basic information about a commit for display purposes.

src/usecases/create_worktree.rs

@@ -85,8 +85,7 @@ pub fn create_worktree_with_ui(
     println!("{header}");
     println!();
 
-    let existing_worktrees = manager.list_worktrees()?;
-    let has_worktrees = !existing_worktrees.is_empty();
+    let has_linked_worktrees = manager.has_linked_worktrees()?;
 
     let name = match ui.input(PROMPT_WORKTREE_NAME) {
         Ok(name) => name.trim().to_string(),
@@ -106,7 +105,7 @@ pub fn create_worktree_with_ui(
         }
     };
 
-    let final_name = if !has_worktrees {
+    let final_name = if !has_linked_worktrees {
         println!();
         let msg = MSG_FIRST_WORKTREE_CHOOSE.bright_cyan();
         println!("{msg}");

src/usecases/delete_worktree.rs

@@ -5,7 +5,7 @@ use dialoguer::{Confirm, MultiSelect};
 use crate::adapters::git::GitWorktreeManager;
 use crate::adapters::hooks::{self, HookContext};
 use crate::constants::{section_header, DEFAULT_MENU_SELECTION, HOOK_PRE_REMOVE};
-use crate::domain::worktree::WorktreeInfo;
+use crate::domain::worktree::{BasicWorktreeInfo, WorktreeInfo};
 use crate::ui::{DialoguerUI, UserInterface};
 use crate::utils::{self, get_theme, press_any_key_to_continue};
 
@@ -71,6 +71,20 @@ pub fn prepare_batch_delete_items(worktrees: &[WorktreeInfo]) -> Vec<String> {
         .collect()
 }
 
+/// Pure business logic for filtering deletable worktrees for batch operations.
+pub fn get_deletable_worktrees_basic(worktrees: &[BasicWorktreeInfo]) -> Vec<&BasicWorktreeInfo> {
+    worktrees.iter().filter(|w| !w.is_current).collect()
+}
+
+/// Pure business logic for preparing batch delete labels from lightweight worktrees.
+pub fn prepare_batch_delete_items_basic(worktrees: &[BasicWorktreeInfo]) -> Vec<String> {
+    worktrees
+        .iter()
+        .filter(|w| !w.is_current)
+        .map(|w| format!("{} ({})", w.name, w.branch))
+        .collect()
+}
+
 /// Pure business logic for analyzing deletion requirements
 pub fn analyze_deletion(
     worktree: &WorktreeInfo,
@@ -238,7 +252,7 @@ pub fn batch_delete_worktrees() -> Result<()> {
 }
 
 fn batch_delete_worktrees_internal(manager: &GitWorktreeManager) -> Result<()> {
-    let worktrees = manager.list_worktrees()?;
+    let worktrees = manager.list_worktrees_basic()?;
 
     if worktrees.is_empty() {
         println!();
@@ -249,8 +263,7 @@ fn batch_delete_worktrees_internal(manager: &GitWorktreeManager) -> Result<()> {
         return Ok(());
     }
 
-    let deletable_worktrees: Vec<&WorktreeInfo> =
-        worktrees.iter().filter(|w| !w.is_current).collect();
+    let deletable_worktrees = get_deletable_worktrees_basic(&worktrees);
 
     if deletable_worktrees.is_empty() {
         println!();
@@ -270,7 +283,7 @@ fn batch_delete_worktrees_internal(manager: &GitWorktreeManager) -> Result<()> {
     println!("{header}");
     println!();
 
-    let items = prepare_batch_delete_items(&worktrees);
+    let items = prepare_batch_delete_items_basic(&worktrees);
 
     let selections = MultiSelect::with_theme(&get_theme())
         .with_prompt(
@@ -284,7 +297,7 @@ fn batch_delete_worktrees_internal(manager: &GitWorktreeManager) -> Result<()> {
         _ => return Ok(()),
     };
 
-    let selected_worktrees: Vec<&WorktreeInfo> =
+    let selected_worktrees: Vec<&BasicWorktreeInfo> =
         selections.iter().map(|&i| deletable_worktrees[i]).collect();
 
     let mut branches_to_delete = Vec::new();
@@ -573,4 +586,66 @@ mod tests {
         assert!(items[0].contains("feature/test"));
         assert!(!items[0].contains("main"));
     }
+
+    #[test]
+    fn test_prepare_batch_delete_items_basic_preserves_order_and_filters_current() {
+        let worktrees = vec![
+            BasicWorktreeInfo {
+                name: "z-current".to_string(),
+                git_name: "z-current".to_string(),
+                path: std::path::PathBuf::from("/test/z-current"),
+                branch: "main".to_string(),
+                is_current: true,
+                is_locked: false,
+            },
+            BasicWorktreeInfo {
+                name: "alpha".to_string(),
+                git_name: "alpha".to_string(),
+                path: std::path::PathBuf::from("/test/alpha"),
+                branch: "alpha".to_string(),
+                is_current: false,
+                is_locked: false,
+            },
+            BasicWorktreeInfo {
+                name: "beta-renamed".to_string(),
+                git_name: "beta-original".to_string(),
+                path: std::path::PathBuf::from("/test/beta-renamed"),
+                branch: "beta-branch".to_string(),
+                is_current: false,
+                is_locked: false,
+            },
+        ];
+
+        let items = prepare_batch_delete_items_basic(&worktrees);
+
+        assert_eq!(items, vec!["alpha (alpha)", "beta-renamed (beta-branch)"]);
+    }
+
+    #[test]
+    fn test_get_deletable_worktrees_basic_preserves_identity_mapping() {
+        let worktrees = vec![
+            BasicWorktreeInfo {
+                name: "main".to_string(),
+                git_name: "main".to_string(),
+                path: std::path::PathBuf::from("/test/main"),
+                branch: "main".to_string(),
+                is_current: true,
+                is_locked: false,
+            },
+            BasicWorktreeInfo {
+                name: "renamed-feature".to_string(),
+                git_name: "feature-original".to_string(),
+                path: std::path::PathBuf::from("/test/renamed-feature"),
+                branch: "feature-branch".to_string(),
+                is_current: false,
+                is_locked: false,
+            },
+        ];
+
+        let deletable = get_deletable_worktrees_basic(&worktrees);
+
+        assert_eq!(deletable.len(), 1);
+        assert_eq!(deletable[0].name, "renamed-feature");
+        assert_eq!(deletable[0].git_name, "feature-original");
+    }
 }

src/usecases/rename_worktree.rs

@@ -6,7 +6,7 @@ use crate::constants::{
     section_header, DEFAULT_BRANCH_DETACHED, DEFAULT_BRANCH_UNKNOWN, DEFAULT_MENU_SELECTION,
 };
 use crate::domain::validation::validate_worktree_name;
-use crate::domain::worktree::WorktreeInfo;
+use crate::domain::worktree::{BasicWorktreeInfo, WorktreeInfo};
 use crate::ui::{DialoguerUI, UserInterface};
 use crate::utils::{self, press_any_key_to_continue};
 
@@ -52,6 +52,23 @@ pub struct RenameAnalysis {
     pub is_feature_branch: bool,
 }
 
+fn lightweight_worktrees_to_display(worktrees: Vec<BasicWorktreeInfo>) -> Vec<WorktreeInfo> {
+    worktrees
+        .into_iter()
+        .map(|worktree| WorktreeInfo {
+            name: worktree.name,
+            git_name: worktree.git_name,
+            path: worktree.path,
+            branch: worktree.branch,
+            is_locked: worktree.is_locked,
+            is_current: worktree.is_current,
+            has_changes: false,
+            last_commit: None,
+            ahead_behind: None,
+        })
+        .collect()
+}
+
 /// Pure business logic for filtering renameable worktrees
 pub fn get_renameable_worktrees(worktrees: &[WorktreeInfo]) -> Vec<&WorktreeInfo> {
     worktrees.iter().filter(|w| !w.is_current).collect()
@@ -151,7 +168,7 @@ pub fn rename_worktree() -> Result<()> {
 
 /// Internal implementation of rename_worktree with dependency injection
 pub fn rename_worktree_with_ui(manager: &GitWorktreeManager, ui: &dyn UserInterface) -> Result<()> {
-    let worktrees = manager.list_worktrees()?;
+    let worktrees = lightweight_worktrees_to_display(manager.list_worktrees_basic()?);
 
     if worktrees.is_empty() {
         println!();

src/usecases/search_worktrees.rs

@@ -9,7 +9,7 @@ use crate::constants::{
     MSG_NO_WORKTREES_TO_SEARCH, MSG_SEARCH_FUZZY_ENABLED, PROMPT_SELECT_WORKTREE_SWITCH,
     SEARCH_CURRENT_INDICATOR,
 };
-use crate::domain::worktree::WorktreeInfo;
+use crate::domain::worktree::{BasicWorktreeInfo, WorktreeInfo};
 use crate::utils::{self, get_theme, press_any_key_to_continue};
 
 #[derive(Debug, Clone)]
@@ -25,6 +25,23 @@ pub struct SearchAnalysis {
     pub has_current: bool,
 }
 
+fn lightweight_worktrees_to_display(worktrees: Vec<BasicWorktreeInfo>) -> Vec<WorktreeInfo> {
+    worktrees
+        .into_iter()
+        .map(|worktree| WorktreeInfo {
+            name: worktree.name,
+            git_name: worktree.git_name,
+            path: worktree.path,
+            branch: worktree.branch,
+            is_locked: worktree.is_locked,
+            is_current: worktree.is_current,
+            has_changes: false,
+            last_commit: None,
+            ahead_behind: None,
+        })
+        .collect()
+}
+
 pub fn create_search_items(worktrees: &[WorktreeInfo]) -> SearchAnalysis {
     let items: Vec<String> = worktrees
         .iter()
@@ -63,7 +80,7 @@ pub fn search_worktrees() -> Result<bool> {
 }
 
 fn search_worktrees_internal(manager: &GitWorktreeManager) -> Result<bool> {
-    let worktrees = manager.list_worktrees()?;
+    let worktrees = lightweight_worktrees_to_display(manager.list_worktrees_basic()?);
 
     if worktrees.is_empty() {
         println!();

src/usecases/switch_worktree.rs

@@ -7,7 +7,7 @@ use crate::adapters::shell::switch_file::write_switch_path;
 use crate::constants::{
     section_header, DEFAULT_MENU_SELECTION, HOOK_POST_SWITCH, MSG_ALREADY_IN_WORKTREE,
 };
-use crate::domain::worktree::WorktreeInfo;
+use crate::domain::worktree::{BasicWorktreeInfo, WorktreeInfo};
 use crate::ui::{DialoguerUI, UserInterface};
 use crate::utils::{self, press_any_key_to_continue};
 
@@ -60,6 +60,23 @@ pub struct SwitchAnalysis {
     pub is_already_current: bool,
 }
 
+fn lightweight_worktrees_to_display(worktrees: Vec<BasicWorktreeInfo>) -> Vec<WorktreeInfo> {
+    worktrees
+        .into_iter()
+        .map(|worktree| WorktreeInfo {
+            name: worktree.name,
+            git_name: worktree.git_name,
+            path: worktree.path,
+            branch: worktree.branch,
+            is_locked: worktree.is_locked,
+            is_current: worktree.is_current,
+            has_changes: false,
+            last_commit: None,
+            ahead_behind: None,
+        })
+        .collect()
+}
+
 /// Pure business logic for sorting worktrees for display
 pub fn sort_worktrees_for_display(mut worktrees: Vec<WorktreeInfo>) -> Vec<WorktreeInfo> {
     worktrees.sort_by(|a, b| {
@@ -122,7 +139,7 @@ pub fn switch_worktree_with_ui(
     manager: &GitWorktreeManager,
     ui: &dyn UserInterface,
 ) -> Result<bool> {
-    let worktrees = manager.list_worktrees()?;
+    let worktrees = lightweight_worktrees_to_display(manager.list_worktrees_basic()?);
 
     if worktrees.is_empty() {
         println!();