Branch name slash trimming (#65)

* fix: trim trailing slashes for branch parameters

Co-authored-by: Safia Abdalla <safia@safia.rocks>

* test: remove low-value utils slash tests

Co-authored-by: Safia Abdalla <safia@safia.rocks>

---------

Co-authored-by: Cursor Agent <cursoragent@cursor.com>

Author: captainsafia

src/commands/go.rs

@@ -6,11 +6,13 @@ use crate::commands::shell_init::{
 };
 use crate::git::{discover_repo, find_worktree_by_name, list_worktrees, RepoContext};
 use crate::models::Worktree;
-use crate::utils::get_shell_for_platform;
+use crate::utils::{get_shell_for_platform, trim_trailing_branch_slashes};
 
 pub fn run(name: Option<&str>, path_only: bool) {
     if path_only
-        && name.map(|n| n.trim().is_empty()).unwrap_or(true)
+        && name
+            .map(|n| trim_trailing_branch_slashes(n).is_empty())
+            .unwrap_or(true)
         && !atty::is(atty::Stream::Stdin)
     {
         eprintln!(
@@ -30,10 +32,11 @@ pub fn run(name: Option<&str>, path_only: bool) {
     };
 
     let worktree = if let Some(name) = name {
-        if name.trim().is_empty() {
+        let normalized_name = trim_trailing_branch_slashes(name);
+        if normalized_name.is_empty() {
             pick_or_error(&repo)
         } else {
-            match find_worktree_by_name(&repo, name) {
+            match find_worktree_by_name(&repo, normalized_name) {
                 Ok(Some(wt)) => wt,
                 Ok(None) => {
                     eprintln!(

src/commands/prune.rs

@@ -6,7 +6,7 @@ use crate::git::{
     DETACHED_HEAD,
 };
 use crate::models::Worktree;
-use crate::utils::parse_duration;
+use crate::utils::{parse_duration, trim_trailing_branch_slashes};
 
 pub fn run(dry_run: bool, force: bool, base: Option<&str>, older_than: Option<&str>) {
     if older_than.is_some() && base.is_some() {
@@ -32,7 +32,12 @@ pub fn run(dry_run: bool, force: bool, base: Option<&str>, older_than: Option<&s
     // Get the base branch
     let base_branch = if older_than.is_none() {
         if let Some(b) = base {
-            b.to_string()
+            let normalized = trim_trailing_branch_slashes(b);
+            if normalized.is_empty() {
+                eprintln!("{} Branch name is required", "Error:".red());
+                std::process::exit(1);
+            }
+            normalized.to_string()
         } else {
             match get_default_branch(&repo) {
                 Ok(b) => b,

src/commands/remove.rs

@@ -2,6 +2,7 @@ use colored::Colorize;
 
 use crate::git::{discover_repo, list_worktrees, remove_worktree};
 use crate::models::Worktree;
+use crate::utils::trim_trailing_branch_slashes;
 
 pub fn run(name: Option<&str>, force: bool, yes: bool) {
     let repo = match discover_repo() {
@@ -24,9 +25,7 @@ pub fn run(name: Option<&str>, force: bool, yes: bool) {
         if name.trim().is_empty() {
             pick_worktree_to_remove(&worktrees)
         } else {
-            match worktrees.iter().find(|wt| {
-                wt.branch == name || wt.path == name || wt.path.ends_with(&format!("/{}", name))
-            }) {
+            match find_worktree_by_identifier(&worktrees, name) {
                 Some(wt) => wt.clone(),
                 None => {
                     eprintln!(
@@ -110,6 +109,23 @@ pub fn run(name: Option<&str>, force: bool, yes: bool) {
     );
 }
 
+fn find_worktree_by_identifier<'a>(
+    worktrees: &'a [Worktree],
+    identifier: &str,
+) -> Option<&'a Worktree> {
+    let trimmed_identifier = identifier.trim();
+    let normalized_branch = trim_trailing_branch_slashes(trimmed_identifier);
+    let normalized_path = trimmed_identifier.trim_end_matches('/');
+
+    worktrees.iter().find(|wt| {
+        wt.path == trimmed_identifier
+            || wt.path.trim_end_matches('/') == normalized_path
+            || (!normalized_branch.is_empty()
+                && (wt.branch == normalized_branch
+                    || wt.path.ends_with(&format!("/{}", normalized_branch))))
+    })
+}
+
 fn pick_worktree_to_remove(worktrees: &[Worktree]) -> Worktree {
     let removable: Vec<&Worktree> = worktrees
         .iter()
@@ -148,3 +164,51 @@ fn pick_worktree_to_remove(worktrees: &[Worktree]) -> Worktree {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::find_worktree_by_identifier;
+    use crate::models::Worktree;
+    use chrono::DateTime;
+
+    fn make_worktree(path: &str, branch: &str) -> Worktree {
+        Worktree {
+            path: path.to_string(),
+            branch: branch.to_string(),
+            head: "abc123".to_string(),
+            created_at: DateTime::from_timestamp(0, 0).unwrap(),
+            is_dirty: false,
+            is_locked: false,
+            is_prunable: false,
+            is_main: false,
+        }
+    }
+
+    #[test]
+    fn find_worktree_by_identifier_matches_branch_with_trailing_slash() {
+        let worktrees = vec![make_worktree(
+            "/repo/feature/my-branch",
+            "feature/my-branch",
+        )];
+
+        let found = find_worktree_by_identifier(&worktrees, "feature/my-branch/");
+        assert_eq!(
+            found.map(|wt| wt.branch.as_str()),
+            Some("feature/my-branch")
+        );
+    }
+
+    #[test]
+    fn find_worktree_by_identifier_matches_path_with_trailing_slash() {
+        let worktrees = vec![make_worktree(
+            "/repo/feature/my-branch",
+            "feature/my-branch",
+        )];
+
+        let found = find_worktree_by_identifier(&worktrees, "/repo/feature/my-branch/");
+        assert_eq!(
+            found.map(|wt| wt.branch.as_str()),
+            Some("feature/my-branch")
+        );
+    }
+}

src/commands/sync.rs

@@ -1,6 +1,7 @@
 use colored::Colorize;
 
 use crate::git::{discover_repo, get_default_branch, list_worktrees, sync_branch};
+use crate::utils::trim_trailing_branch_slashes;
 
 pub fn run(branch: Option<&str>) {
     let repo = match discover_repo() {
@@ -12,7 +13,12 @@ pub fn run(branch: Option<&str>) {
     };
 
     let target_branch = if let Some(b) = branch {
-        b.to_string()
+        let normalized = trim_trailing_branch_slashes(b);
+        if normalized.is_empty() {
+            eprintln!("{} Branch name is required", "Error:".red());
+            std::process::exit(1);
+        }
+        normalized.to_string()
     } else {
         match get_default_branch(&repo) {
             Ok(b) => b,

src/git/worktree_manager.rs

@@ -5,7 +5,7 @@ use std::path::{Path, PathBuf};
 use std::process::Command;
 
 use crate::models::Worktree;
-use crate::utils::{discover_bare_clone, get_project_root};
+use crate::utils::{discover_bare_clone, get_project_root, trim_trailing_branch_slashes};
 
 pub const MAIN_BRANCHES: &[&str] = &["main", "master"];
 pub const DETACHED_HEAD: &str = "detached HEAD";
@@ -247,32 +247,36 @@ pub fn find_worktree_by_name(
     name: &str,
 ) -> Result<Option<Worktree>, String> {
     let worktrees = list_worktrees(context)?;
+    Ok(match_worktree_by_name(&worktrees, name).cloned())
+}
+
+fn match_worktree_by_name<'a>(worktrees: &'a [Worktree], name: &str) -> Option<&'a Worktree> {
+    let normalized_name = trim_trailing_branch_slashes(name);
+
+    if normalized_name.is_empty() {
+        return None;
+    }
 
-    // First, try exact branch name match
-    if let Some(wt) = worktrees.iter().find(|wt| wt.branch == name) {
-        return Ok(Some(wt.clone()));
+    // First, try exact branch name match.
+    if let Some(wt) = worktrees.iter().find(|wt| wt.branch == normalized_name) {
+        return Some(wt);
     }
 
-    // Try matching by directory name
+    // Try matching by directory name.
     if let Some(wt) = worktrees.iter().find(|wt| {
         Path::new(&wt.path)
             .file_name()
             .and_then(|n| n.to_str())
-            .map(|n| n == name)
+            .map(|n| n == normalized_name)
             .unwrap_or(false)
     }) {
-        return Ok(Some(wt.clone()));
+        return Some(wt);
     }
 
-    // Try partial branch name match (suffix matching)
-    if let Some(wt) = worktrees
+    // Try partial branch name match (suffix matching).
+    worktrees
         .iter()
-        .find(|wt| wt.branch.ends_with(&format!("/{}", name)))
-    {
-        return Ok(Some(wt.clone()));
-    }
-
-    Ok(None)
+        .find(|wt| wt.branch.ends_with(&format!("/{}", normalized_name)))
 }
 
 struct PartialWorktree {
@@ -399,6 +403,20 @@ fn metadata_created_at(meta: &fs::Metadata) -> Option<DateTime<Utc>> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use chrono::DateTime;
+
+    fn make_worktree(path: &str, branch: &str) -> Worktree {
+        Worktree {
+            path: path.to_string(),
+            branch: branch.to_string(),
+            head: "abc123".to_string(),
+            created_at: DateTime::from_timestamp(0, 0).unwrap(),
+            is_dirty: false,
+            is_locked: false,
+            is_prunable: false,
+            is_main: false,
+        }
+    }
 
     // --- parseWorktreeLines tests ---
 
@@ -460,4 +478,32 @@ mod tests {
         assert!(worktrees[1].is_locked);
         assert!(worktrees[2].is_prunable);
     }
+
+    #[test]
+    fn match_worktree_by_name_trims_trailing_slashes() {
+        let worktrees = vec![
+            make_worktree("/repo/main", "main"),
+            make_worktree("/repo/feature/my-branch", "feature/my-branch"),
+        ];
+
+        let found = match_worktree_by_name(&worktrees, "feature/my-branch/");
+        assert_eq!(
+            found.map(|wt| wt.branch.as_str()),
+            Some("feature/my-branch")
+        );
+    }
+
+    #[test]
+    fn match_worktree_by_name_suffix_match_with_trailing_slash() {
+        let worktrees = vec![make_worktree(
+            "/repo/feature/my-branch",
+            "feature/my-branch",
+        )];
+
+        let found = match_worktree_by_name(&worktrees, "my-branch/");
+        assert_eq!(
+            found.map(|wt| wt.branch.as_str()),
+            Some("feature/my-branch")
+        );
+    }
 }

src/main.rs

@@ -8,12 +8,12 @@ mod git;
 mod models;
 mod utils;
 
-use crate::utils::{is_valid_git_url, parse_duration};
+use crate::utils::{is_valid_git_url, parse_duration, trim_trailing_branch_slashes};
 
 const VERSION: &str = env!("CARGO_PKG_VERSION");
 
 fn validate_branch_name(value: &str) -> Result<String, String> {
-    let trimmed = value.trim();
+    let trimmed = trim_trailing_branch_slashes(value);
     if trimmed.is_empty() {
         return Err("Branch name is required".to_string());
     }
@@ -240,3 +240,21 @@ fn main() {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::validate_branch_name;
+
+    #[test]
+    fn validate_branch_name_trims_trailing_slashes() {
+        assert_eq!(
+            validate_branch_name("feature/my-branch///").unwrap(),
+            "feature/my-branch"
+        );
+    }
+
+    #[test]
+    fn validate_branch_name_rejects_empty_after_trimming() {
+        assert!(validate_branch_name("///").is_err());
+    }
+}

src/utils.rs

@@ -191,6 +191,12 @@ pub fn extract_repo_name(git_url: &str) -> Result<String, String> {
     Ok(repo_name.to_string())
 }
 
+/// Normalize branch-like user input by trimming whitespace and trailing slashes.
+/// Preserves internal slashes (e.g. "feature/my-branch") for nested branch names.
+pub fn trim_trailing_branch_slashes(value: &str) -> &str {
+    value.trim().trim_end_matches('/')
+}
+
 /// Normalize human-friendly duration strings to ISO 8601 format.
 /// Accepts formats like: 30d, 2w, 6M, 1y, 12h, 30m
 /// Returns ISO 8601 format: P30D, P2W, P6M, P1Y, PT12H, PT30M