id: cleanup parse_str branch handling

In `parse_str`, despite the comment near `self.find_branches_by_name`,
`self.find_branches_by_name` actually handles partial branch name lookup
already, which means that the other branch searches are redundant.
Remove them, which also allows a lot of other code cleanup.

In particular, `Context` is no longer needed when parsing strings - only
when generating the `IdMap`. This makes it clear that the only inputs
are the `RefInfo` and the hunk assignments.

Author: jonathantanmy2

crates/but/src/command/legacy/branch/mod.rs

@@ -88,10 +88,9 @@ pub async fn handle(
 
             let anchor = if let Some(anchor_str) = anchor {
                 // Use the new create_reference API when anchor is provided
-                let mut ctx = ctx; // Make mutable for CliId resolution
 
                 // Resolve the anchor string to a CliId
-                let anchor_ids = id_map.parse_str(&mut ctx, &anchor_str)?;
+                let anchor_ids = id_map.parse_str(&anchor_str)?;
                 if anchor_ids.is_empty() {
                     return Err(anyhow::anyhow!("Could not find anchor: {}", anchor_str));
                 }

crates/but/src/command/legacy/commit.rs

@@ -27,7 +27,7 @@ pub(crate) fn insert_blank_commit(
     let id_map = IdMap::new(&mut ctx)?;
 
     // Resolve the target ID
-    let cli_ids = id_map.parse_str(&mut ctx, target)?;
+    let cli_ids = id_map.parse_str(target)?;
 
     if cli_ids.is_empty() {
         bail!("Target '{}' not found", target);
@@ -173,15 +173,8 @@ pub(crate) fn commit(
         })
         .collect();
 
-    let (target_stack_id, target_stack) = select_stack(
-        &mut ctx,
-        &id_map,
-        project,
-        &stacks,
-        branch_hint,
-        create_branch,
-        out,
-    )?;
+    let (target_stack_id, target_stack) =
+        select_stack(&id_map, project, &stacks, branch_hint, create_branch, out)?;
 
     // Get changes and assignments using but-api
     let worktree_changes = diff::changes_in_worktree(project_id)?;
@@ -248,7 +241,7 @@ pub(crate) fn commit(
             .find(|branch| branch.name == hint)
             .or_else(|| {
                 // If no exact match, try to parse as CLI ID and match
-                if let Ok(cli_ids) = id_map.parse_str(&mut ctx, hint) {
+                if let Ok(cli_ids) = id_map.parse_str(hint) {
                     for cli_id in cli_ids {
                         if let crate::legacy::id::CliId::Branch { name, .. } = cli_id
                             && let Some(branch) =
@@ -347,7 +340,6 @@ fn create_independent_branch(
 }
 
 fn select_stack(
-    ctx: &mut Context,
     id_map: &IdMap,
     project: &Project,
     stacks: &[(
@@ -377,7 +369,7 @@ fn select_stack(
     match branch_hint {
         Some(hint) => {
             // Try to find stack by branch hint
-            if let Some(stack) = find_stack_by_hint(ctx, id_map, stacks, hint) {
+            if let Some(stack) = find_stack_by_hint(id_map, stacks, hint) {
                 return Ok(stack);
             }
 
@@ -409,7 +401,6 @@ fn select_stack(
 }
 
 fn find_stack_by_hint(
-    ctx: &mut Context,
     id_map: &IdMap,
     stacks: &[(
         but_core::ref_metadata::StackId,
@@ -428,7 +419,7 @@ fn find_stack_by_hint(
     }
 
     // Try CLI ID parsing
-    let cli_ids = id_map.parse_str(ctx, hint).ok()?;
+    let cli_ids = id_map.parse_str(hint).ok()?;
     for cli_id in cli_ids {
         if let CliId::Branch { name, .. } = cli_id {
             for (stack_id, stack_details) in stacks {

crates/but/src/command/legacy/describe.rs

@@ -21,7 +21,7 @@ pub(crate) fn describe_target(
     let id_map = IdMap::new(&mut ctx)?;
 
     // Resolve the commit ID
-    let cli_ids = id_map.parse_str(&mut ctx, target)?;
+    let cli_ids = id_map.parse_str(target)?;
 
     if cli_ids.is_empty() {
         bail!("ID '{}' not found", target);

crates/but/src/command/legacy/forge/review.rs

@@ -100,7 +100,7 @@ fn get_branch_names(project: &Project, branch_id: &str) -> anyhow::Result<Vec<St
     let mut ctx = Context::new_from_legacy_project(project.clone())?;
     let id_map = IdMap::new(&mut ctx)?;
     let branch_ids = id_map
-        .parse_str(&mut ctx, branch_id)?
+        .parse_str(branch_id)?
         .iter()
         .filter_map(|clid| match clid {
             CliId::Branch { name, .. } => Some(name.clone()),

crates/but/src/command/legacy/mark.rs

@@ -19,7 +19,7 @@ pub(crate) fn handle(
 ) -> anyhow::Result<()> {
     let ctx = &mut Context::new_from_legacy_project(project.clone())?;
     let id_map = IdMap::new(ctx)?;
-    let target_result = id_map.parse_str(ctx, target_str)?;
+    let target_result = id_map.parse_str(target_str)?;
     if target_result.len() != 1 {
         return Err(anyhow::anyhow!(
             "Target {} is ambiguous: {:?}",

crates/but/src/command/legacy/push.rs

@@ -118,7 +118,7 @@ fn resolve_branch_name(
     branch_id: &str,
 ) -> anyhow::Result<String> {
     // Try to resolve as CliId first
-    let cli_ids = id_map.parse_str(ctx, branch_id)?;
+    let cli_ids = id_map.parse_str(branch_id)?;
 
     if cli_ids.is_empty() {
         // If no CliId matches, treat as literal branch name but validate it exists

crates/but/src/command/legacy/rub/mod.rs

@@ -168,7 +168,7 @@ fn ids(
     target: &str,
 ) -> anyhow::Result<(Vec<CliId>, CliId)> {
     let sources = parse_sources(ctx, id_map, source)?;
-    let target_result = id_map.parse_str(ctx, target)?;
+    let target_result = id_map.parse_str(target)?;
     if target_result.len() != 1 {
         if target_result.is_empty() {
             return Err(anyhow::anyhow!(
@@ -207,11 +207,11 @@ pub(crate) fn parse_sources(
     }
     // Check if it's a list (contains ',')
     else if source.contains(',') {
-        parse_list(ctx, id_map, source)
+        parse_list(id_map, source)
     }
     // Single source
     else {
-        let source_result = id_map.parse_str(ctx, source)?;
+        let source_result = id_map.parse_str(source)?;
         if source_result.len() != 1 {
             if source_result.is_empty() {
                 return Err(anyhow::anyhow!(
@@ -253,8 +253,8 @@ fn parse_range(ctx: &mut Context, id_map: &IdMap, source: &str) -> anyhow::Resul
     let end_str = parts[1];
 
     // Get the start and end IDs
-    let start_matches = id_map.parse_str(ctx, start_str)?;
-    let end_matches = id_map.parse_str(ctx, end_str)?;
+    let start_matches = id_map.parse_str(start_str)?;
+    let end_matches = id_map.parse_str(end_str)?;
 
     if start_matches.len() != 1 {
         return Err(anyhow::anyhow!(
@@ -360,13 +360,13 @@ fn get_all_files_in_display_order(ctx: &mut Context, id_map: &IdMap) -> anyhow::
     Ok(all_files)
 }
 
-fn parse_list(ctx: &mut Context, id_map: &IdMap, source: &str) -> anyhow::Result<Vec<CliId>> {
+fn parse_list(id_map: &IdMap, source: &str) -> anyhow::Result<Vec<CliId>> {
     let parts: Vec<&str> = source.split(',').collect();
     let mut result = Vec::new();
 
     for part in parts {
         let part = part.trim();
-        let matches = id_map.parse_str(ctx, part)?;
+        let matches = id_map.parse_str(part)?;
         if matches.len() != 1 {
             if matches.is_empty() {
                 return Err(anyhow::anyhow!(

crates/but/src/command/legacy/status/assignment.rs

@@ -30,7 +30,11 @@ pub(crate) struct FileAssignment {
 }
 
 impl FileAssignment {
-    pub fn from_assignments(id_map: &IdMap, path: &BString, assignments: &[HunkAssignment]) -> Self {
+    pub fn from_assignments(
+        id_map: &IdMap,
+        path: &BString,
+        assignments: &[HunkAssignment],
+    ) -> Self {
         let mut filtered_assignments = Vec::new();
         for assignment in assignments {
             if assignment.path_bytes == *path {

crates/but/src/command/legacy/status/mod.rs

@@ -18,10 +18,7 @@ const DATE_ONLY: CustomFormat = CustomFormat::new("%Y-%m-%d");
 pub(crate) mod assignment;
 pub(crate) mod json;
 
-use crate::{
-    legacy::id::{CliId, IdMap},
-    utils::OutputChannel,
-};
+use crate::{legacy::id::IdMap, utils::OutputChannel};
 
 type StackDetail = (Option<StackDetails>, Vec<FileAssignment>);
 type StackEntry = (Option<gitbutler_stack::StackId>, StackDetail);
@@ -560,18 +557,6 @@ fn path_with_color(status: &TreeStatus, path: String) -> ColoredString {
     }
 }
 
-pub(crate) fn all_branches(ctx: &mut Context) -> anyhow::Result<Vec<CliId>> {
-    let mut id_map = IdMap::new(ctx)?;
-    let stacks = crate::legacy::commits::stacks(ctx)?;
-    let mut branches = Vec::new();
-    for stack in stacks {
-        for head in stack.heads {
-            branches.push(id_map.branch(head.name.as_ref()).clone());
-        }
-    }
-    Ok(branches)
-}
-
 fn status_from_changes(changes: &[ui::TreeChange], path: BString) -> Option<ui::TreeStatus> {
     changes.iter().find_map(|change| {
         if change.path_bytes == path {

crates/but/src/legacy/id/mod.rs

@@ -224,7 +224,7 @@ impl IdMap {
 
 /// Cli ID generation
 impl IdMap {
-    pub fn parse_str(&self, ctx: &mut Context, s: &str) -> anyhow::Result<Vec<CliId>> {
+    pub fn parse_str(&self, s: &str) -> anyhow::Result<Vec<CliId>> {
         if s.len() < 2 {
             return Err(anyhow::anyhow!(
                 "Id needs to be at least 2 characters long: {}",
@@ -234,7 +234,7 @@ impl IdMap {
 
         let mut matches = Vec::new();
 
-        // First, try exact branch name match
+        // First, try partial branch name match
         if let Ok(branch_matches) = self.find_branches_by_name(s.into()) {
             matches.extend(branch_matches);
         }
@@ -250,17 +250,8 @@ impl IdMap {
             }
         }
 
-        // Then try CliId matching (both prefix and exact)
-        if s.len() > 2 {
-            // For longer strings, try prefix matching on CliIds
-            let mut cli_matches = Vec::new();
-            crate::command::legacy::status::all_branches(ctx)?
-                .into_iter()
-                .filter(|id| id.matches_prefix(s))
-                .for_each(|id| cli_matches.push(id));
-            matches.extend(cli_matches);
-        } else {
-            // For 2-character strings, try exact CliId matching
+        // Then try CliId matching
+        if s.len() == 2 {
             let mut cli_matches = Vec::new();
             if let Some(UncommittedFile {
                 assignment_path: (assignment, path),
@@ -284,13 +275,9 @@ impl IdMap {
                     id: s.to_string(),
                 });
             }
-            crate::command::legacy::status::all_branches(ctx)?
-                .into_iter()
-                .filter(|id| id.matches(s))
-                .for_each(|id| cli_matches.push(id));
             matches.extend(cli_matches);
         }
-        if self.unassigned().matches(s) {
+        if s.find(|c: char| c != '0').is_none() {
             matches.push(self.unassigned().clone());
         }
 
@@ -410,24 +397,6 @@ impl CliId {
     pub fn commit(oid: gix::ObjectId) -> Self {
         CliId::Commit { oid }
     }
-
-    pub fn matches(&self, s: &str) -> bool {
-        match self {
-            CliId::Unassigned { .. } => s.find(|c: char| c != '0').is_none(),
-            _ => s == self.to_string(),
-        }
-    }
-
-    pub fn matches_prefix(&self, s: &str) -> bool {
-        match self {
-            CliId::Commit { oid } => {
-                let oid_hash = hash(&oid.to_string());
-                oid_hash.starts_with(s)
-            }
-            CliId::Unassigned { .. } => s.find(|c: char| c != '0').is_none(),
-            _ => self.to_string().starts_with(s),
-        }
-    }
 }
 
 impl Display for CliId {