feat(worktrees): remove and lock/unlock from the popup

In the Worktrees popup:
- `Shift+D` removes the selected linked worktree (confirmation
  dialog). The removal is refused — with a clear error — if the
  worktree is the current one, is locked, or has uncommitted/untracked
  changes, mirroring `git worktree remove` without `--force` (libgit2
  does not refuse a dirty remove on its own, so the check is done in
  Rust via `is_workdir_clean`).
- `l` toggles the lock state of the selected linked worktree; the 🔒
  marker updates immediately.
The primary "(main)" tree and the current worktree are gated out of
both actions.

- asyncgit: `remove_worktree` (prune with valid+working_tree, guarded)
  and `toggle_worktree_lock`; `WorktreeInfo` gains `is_main`; 3 tests
- wiring: `Action::DeleteWorktree` -> confirm popup -> confirmed-action
  handler; `lock_worktree` key (`l`); strings + command hints

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BMQxBdr5f3B3jmDtdvGtTu

Author: stevenpollack

CHANGELOG.md

@@ -11,6 +11,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * support x509 commit signing [[@kaden-l-nelson](https://github.com/kaden-l-nelson)] ([#2514](https://github.com/gitui-org/gitui/issues/2514))
 * worktrees popup: list worktrees and switch between them ([Shift+W])
 * worktrees popup: create a new worktree with a new branch ([c] from the worktrees list)
+* worktrees popup: remove a worktree ([Shift+D], refused if it is dirty or locked) and lock/unlock it ([l])
 
 ### Changed
 * use [tombi](https://github.com/tombi-toml/tombi) for all toml file formatting

asyncgit/src/sync/mod.rs

@@ -109,7 +109,10 @@ pub use utils::{
 	get_head, get_head_tuple, repo_dir, repo_open_error,
 	stage_add_all, stage_add_file, stage_addremoved, Head,
 };
-pub use worktree::{create_worktree, get_worktrees, WorktreeInfo};
+pub use worktree::{
+	create_worktree, get_worktrees, remove_worktree,
+	toggle_worktree_lock, WorktreeInfo,
+};
 
 pub use git2::ResetType;
 

asyncgit/src/sync/worktree.rs

@@ -2,17 +2,23 @@
 
 use std::path::{Path, PathBuf};
 
-use git2::{Repository, WorktreeLockStatus};
+use git2::{Repository, WorktreeLockStatus, WorktreePruneOptions};
 use scopetime::scope_time;
 
-use super::{repo, RepoPath};
+use super::{is_workdir_clean, repo, RepoPath};
 use crate::error::{Error, Result};
 
 /// name reported for the primary working tree
 const MAIN_WORKTREE_NAME: &str = "(main)";
 
 /// Information about one git worktree (the primary tree or a linked one).
+///
+/// The four flag fields are independent (e.g. the primary tree can be
+/// current or not, a linked tree can be locked or not, etc.), so they
+/// don't collapse into a smaller enum; see `status_tree.rs` for the
+/// same precedent in this codebase.
 #[derive(Debug, Clone)]
+#[allow(clippy::struct_excessive_bools)]
 pub struct WorktreeInfo {
 	/// Linked-worktree name; "(main)" for the primary working tree.
 	pub name: String,
@@ -27,6 +33,9 @@ pub struct WorktreeInfo {
 	pub is_locked: bool,
 	/// Whether this is the worktree gitui is currently operating in.
 	pub is_current: bool,
+	/// Whether this is the primary ("(main)") working tree, which
+	/// cannot be removed or locked.
+	pub is_main: bool,
 }
 
 /// Lists the worktrees of the repo at `repo_path`, returning the
@@ -93,6 +102,7 @@ fn main_worktree_info(
 		branch,
 		is_valid: true,
 		is_locked: false,
+		is_main: true,
 	})
 }
 
@@ -119,6 +129,7 @@ fn linked_worktree_info(
 		branch,
 		is_valid: wt.validate().is_ok(),
 		is_locked,
+		is_main: false,
 	})
 }
 
@@ -167,6 +178,83 @@ pub fn create_worktree(
 	Ok(worktree.path().to_path_buf())
 }
 
+/// Removes the linked worktree named `name`: deletes its working
+/// directory and prunes its administrative files.
+///
+/// Refuses (returns an error, mirroring `git worktree remove` without
+/// `--force`) when the worktree is the current one, is locked, or has
+/// uncommitted/untracked changes — since removal deletes the working
+/// directory irrecoverably.
+pub fn remove_worktree(
+	repo_path: &RepoPath,
+	name: &str,
+) -> Result<()> {
+	scope_time!("remove_worktree");
+
+	let repo = repo(repo_path)?;
+	let worktree = repo.find_worktree(name)?;
+
+	// never remove the worktree gitui is operating in.
+	if same_workdir(worktree.path(), repo.workdir()) {
+		return Err(Error::Generic(
+			"cannot remove the current worktree".to_string(),
+		));
+	}
+
+	// a locked worktree is deliberately protected; require unlock.
+	if matches!(worktree.is_locked()?, WorktreeLockStatus::Locked(_))
+	{
+		return Err(Error::Generic(
+			"worktree is locked; unlock it before removing"
+				.to_string(),
+		));
+	}
+
+	// refuse to delete a worktree with uncommitted or untracked
+	// changes (libgit2 does not refuse this itself). Only checkable
+	// when the working dir still exists.
+	if worktree.validate().is_ok() {
+		if let Some(path) = worktree.path().to_str() {
+			let wt_path: RepoPath = path.into();
+			if !is_workdir_clean(&wt_path, None)? {
+				return Err(Error::Generic(
+					"worktree has uncommitted changes; commit or discard them first"
+						.to_string(),
+				));
+			}
+		}
+	}
+
+	// valid(true): also prune worktrees whose dir still exists;
+	// working_tree(true): delete the working directory too.
+	let mut opts = WorktreePruneOptions::new();
+	opts.valid(true).working_tree(true);
+	worktree.prune(Some(&mut opts))?;
+
+	Ok(())
+}
+
+/// Toggles the lock state of the linked worktree named `name`: locks
+/// it (with no reason) when unlocked, unlocks it when locked.
+pub fn toggle_worktree_lock(
+	repo_path: &RepoPath,
+	name: &str,
+) -> Result<()> {
+	scope_time!("toggle_worktree_lock");
+
+	let repo = repo(repo_path)?;
+	let worktree = repo.find_worktree(name)?;
+
+	if matches!(worktree.is_locked()?, WorktreeLockStatus::Locked(_))
+	{
+		worktree.unlock()?;
+	} else {
+		worktree.lock(None)?;
+	}
+
+	Ok(())
+}
+
 /// short name of the branch a repo's HEAD points at, or `None` when
 /// HEAD is unborn or detached.
 fn head_branch(repo: &Repository) -> Option<String> {
@@ -197,7 +285,10 @@ fn same_workdir(path: &Path, current: Option<&Path>) -> bool {
 
 #[cfg(test)]
 mod tests {
-	use super::{create_worktree, get_worktrees, WorktreeInfo};
+	use super::{
+		create_worktree, get_worktrees, remove_worktree,
+		toggle_worktree_lock, WorktreeInfo,
+	};
 	use crate::sync::{tests::repo_init, RepoPath};
 	use pretty_assertions::assert_eq;
 
@@ -325,4 +416,70 @@ mod tests {
 		let res = create_worktree(&repo_path, "..");
 		assert!(res.is_err());
 	}
+
+	#[test]
+	fn test_remove_worktree() {
+		let (_td, repo) = repo_init().unwrap();
+		let root = repo.path().parent().unwrap();
+		let repo_path: RepoPath = root.to_str().unwrap().into();
+
+		let wt_dir = tempfile::TempDir::new().unwrap();
+		let wt_path = wt_dir.path().join("gone");
+		create_worktree(&repo_path, wt_path.to_str().unwrap())
+			.unwrap();
+		assert_eq!(get_worktrees(&repo_path).unwrap().len(), 2);
+
+		remove_worktree(&repo_path, "gone").unwrap();
+
+		let list = get_worktrees(&repo_path).unwrap();
+		assert_eq!(list.len(), 1);
+		assert_eq!(list[0].name, "(main)");
+		assert!(!wt_path.exists());
+	}
+
+	#[test]
+	fn test_remove_worktree_refuses_dirty() {
+		let (_td, repo) = repo_init().unwrap();
+		let root = repo.path().parent().unwrap();
+		let repo_path: RepoPath = root.to_str().unwrap().into();
+
+		let wt_dir = tempfile::TempDir::new().unwrap();
+		let wt_path = wt_dir.path().join("dirty");
+		create_worktree(&repo_path, wt_path.to_str().unwrap())
+			.unwrap();
+
+		// introduce an untracked file inside the worktree
+		std::fs::write(wt_path.join("scratch.txt"), b"wip").unwrap();
+
+		assert!(remove_worktree(&repo_path, "dirty").is_err());
+		// still present because removal was refused
+		assert_eq!(get_worktrees(&repo_path).unwrap().len(), 2);
+	}
+
+	#[test]
+	fn test_toggle_worktree_lock() {
+		let (_td, repo) = repo_init().unwrap();
+		let root = repo.path().parent().unwrap();
+		let repo_path: RepoPath = root.to_str().unwrap().into();
+
+		let wt_dir = tempfile::TempDir::new().unwrap();
+		let wt_path = wt_dir.path().join("lockme");
+		create_worktree(&repo_path, wt_path.to_str().unwrap())
+			.unwrap();
+
+		let locked = |p: &RepoPath| {
+			get_worktrees(p)
+				.unwrap()
+				.into_iter()
+				.find(|w| w.name == "lockme")
+				.unwrap()
+				.is_locked
+		};
+
+		assert!(!locked(&repo_path));
+		toggle_worktree_lock(&repo_path, "lockme").unwrap();
+		assert!(locked(&repo_path));
+		toggle_worktree_lock(&repo_path, "lockme").unwrap();
+		assert!(!locked(&repo_path));
+	}
 }

src/app.rs

@@ -1009,6 +1009,17 @@ impl App {
 
 				self.select_branch_popup.update_branches()?;
 			}
+			Action::DeleteWorktree(name) => {
+				if let Err(e) =
+					sync::remove_worktree(&self.repo.borrow(), &name)
+				{
+					self.queue.push(InternalEvent::ShowErrorMsg(
+						e.to_string(),
+					));
+				}
+				self.worktree_popup.update_worktrees()?;
+				flags.insert(NeedsUpdate::ALL);
+			}
 			Action::DeleteRemoteBranch(branch_ref) => {
 				self.delete_remote_branch(&branch_ref)?;
 			}

src/keys/key_list.rs

@@ -119,6 +119,7 @@ pub struct KeysList {
 	pub tag_annotate: GituiKeyEvent,
 	pub view_submodules: GituiKeyEvent,
 	pub view_worktrees: GituiKeyEvent,
+	pub lock_worktree: GituiKeyEvent,
 	pub view_remotes: GituiKeyEvent,
 	pub update_remote_name: GituiKeyEvent,
 	pub update_remote_url: GituiKeyEvent,
@@ -218,6 +219,7 @@ impl Default for KeysList {
 			tag_annotate: GituiKeyEvent::new(KeyCode::Char('a'),  KeyModifiers::CONTROL),
 			view_submodules: GituiKeyEvent::new(KeyCode::Char('S'),  KeyModifiers::SHIFT),
 			view_worktrees: GituiKeyEvent::new(KeyCode::Char('W'),  KeyModifiers::SHIFT),
+			lock_worktree: GituiKeyEvent::new(KeyCode::Char('l'),  KeyModifiers::empty()),
 			view_remotes: GituiKeyEvent::new(KeyCode::Char('r'), KeyModifiers::CONTROL),
 			update_remote_name: GituiKeyEvent::new(KeyCode::Char('n'),KeyModifiers::NONE),
 			update_remote_url: GituiKeyEvent::new(KeyCode::Char('u'),KeyModifiers::NONE),

src/popups/confirm.rs

@@ -172,6 +172,10 @@ impl ConfirmPopup {
 			strings::confirm_title_delete_remote(&self.key_config),
 			strings::confirm_msg_delete_remote(&self.key_config,remote_name),
 		),
+                Action::DeleteWorktree(name) => (
+                    strings::confirm_title_delete_worktree(&self.key_config),
+                    strings::confirm_msg_delete_worktree(&self.key_config, name),
+                ),
                 Action::DeleteTag(tag_name) => (
                     strings::confirm_title_delete_tag(
                         &self.key_config,

src/popups/worktrees.rs

@@ -5,12 +5,14 @@ use crate::{
 		DrawableComponent, EventState, ScrollType, VerticalScroll,
 	},
 	keys::{key_match, SharedKeyConfig},
-	queue::{InternalEvent, Queue},
+	queue::{Action, InternalEvent, Queue},
 	strings,
 	ui::{self, Size},
 };
 use anyhow::Result;
-use asyncgit::sync::{get_worktrees, RepoPathRef, WorktreeInfo};
+use asyncgit::sync::{
+	get_worktrees, toggle_worktree_lock, RepoPathRef, WorktreeInfo,
+};
 use crossterm::event::Event;
 use ratatui::{
 	layout::{Alignment, Margin, Rect},
@@ -108,6 +110,18 @@ impl Component for WorktreesPopup {
 				true,
 				true,
 			));
+
+			out.push(CommandInfo::new(
+				strings::commands::remove_worktree(&self.key_config),
+				self.can_remove_worktree(),
+				true,
+			));
+
+			out.push(CommandInfo::new(
+				strings::commands::lock_worktree(&self.key_config),
+				self.can_lock_worktree(),
+				true,
+			));
 		}
 		visibility_blocking(self)
 	}
@@ -157,6 +171,37 @@ impl Component for WorktreesPopup {
 			{
 				self.queue.push(InternalEvent::CreateWorktree);
 				self.hide();
+			} else if key_match(e, self.key_config.keys.delete_branch)
+			{
+				if let Some(worktree) = self.selected_entry() {
+					if !worktree.is_main && !worktree.is_current {
+						self.queue.push(
+							InternalEvent::ConfirmAction(
+								Action::DeleteWorktree(
+									worktree.name.clone(),
+								),
+							),
+						);
+					}
+				}
+			} else if key_match(e, self.key_config.keys.lock_worktree)
+			{
+				let name = self
+					.selected_entry()
+					.filter(|w| !w.is_main)
+					.map(|w| w.name.clone());
+
+				if let Some(name) = name {
+					if let Err(err) = toggle_worktree_lock(
+						&self.repo.borrow(),
+						&name,
+					) {
+						self.queue.push(InternalEvent::ShowErrorMsg(
+							err.to_string(),
+						));
+					}
+					self.update_worktrees()?;
+				}
 			} else if key_match(
 				e,
 				self.key_config.keys.cmd_bar_toggle,
@@ -224,6 +269,15 @@ impl WorktreesPopup {
 		self.selected_entry().is_some_and(|w| !w.is_current)
 	}
 
+	fn can_remove_worktree(&self) -> bool {
+		self.selected_entry()
+			.is_some_and(|w| !w.is_main && !w.is_current)
+	}
+
+	fn can_lock_worktree(&self) -> bool {
+		self.selected_entry().is_some_and(|w| !w.is_main)
+	}
+
 	//TODO: dedup this almost identical with BranchListComponent
 	fn move_selection(&mut self, scroll: ScrollType) -> Result<bool> {
 		let new_selection = match scroll {

src/queue.rs

@@ -52,6 +52,7 @@ pub enum Action {
 	DeleteTag(String),
 	DeleteRemoteTag(String, String),
 	DeleteRemote(String),
+	DeleteWorktree(String),
 	ForcePush(String, bool),
 	PullMerge { incoming: usize, rebase: bool },
 	AbortMerge,