better resolution of remote branch lkg_parents

Author: wbbradley

src/git2_ops.rs

@@ -73,6 +73,26 @@ impl GitRepo {
                 .unwrap_or(false))
     }
 
+    /// Find the merge-base (common ancestor) of two refs.
+    /// Equivalent to `git merge-base <ref1> <ref2>`
+    pub fn merge_base(&self, ref1: &str, ref2: &str) -> Result<String> {
+        let _bench = GitBenchmark::start("git2:merge-base");
+        let obj1 = self
+            .repo
+            .revparse_single(ref1)
+            .with_context(|| format!("Failed to resolve ref: {}", ref1))?;
+        let obj2 = self
+            .repo
+            .revparse_single(ref2)
+            .with_context(|| format!("Failed to resolve ref: {}", ref2))?;
+
+        let oid = self
+            .repo
+            .merge_base(obj1.id(), obj2.id())
+            .with_context(|| format!("Failed to find merge-base between {} and {}", ref1, ref2))?;
+        Ok(oid.to_string())
+    }
+
     /// Check if a local branch exists.
     /// Only checks for local branches, not remote refs.
     pub fn branch_exists(&self, branch: &str) -> bool {
@@ -87,6 +107,22 @@ impl GitRepo {
         self.repo.revparse_single(ref_name).is_ok()
     }
 
+    /// Resolve a branch name to a ref that exists.
+    /// Tries the branch name first, then falls back to origin/{branch}.
+    /// Returns None if neither exists.
+    pub fn resolve_branch_ref(&self, branch: &str) -> Option<String> {
+        if self.branch_exists(branch) {
+            Some(branch.to_string())
+        } else {
+            let remote_ref = format!("origin/{}", branch);
+            if self.ref_exists(&remote_ref) {
+                Some(remote_ref)
+            } else {
+                None
+            }
+        }
+    }
+
     pub fn branch_status(
         &self,
         parent_branch: Option<&str>,

src/main.rs

@@ -627,25 +627,35 @@ fn recur_tree(
             .truecolor(branch_color.0, branch_color.1, branch_color.2)
     };
 
-    // Get diff stats from LKG ancestor (or parent branch) to current branch
+    // Get diff stats from LKG ancestor (or merge-base) to current branch
     let diff_stats = {
-        // Try lkg_parent first, fall back to resolved parent branch
-        let base_ref = branch
-            .lkg_parent
-            .as_deref()
-            .unwrap_or(&branch_status.parent_branch);
-
-        match git_repo.diff_stats(base_ref, &branch_status.sha) {
-            Ok((adds, dels)) => {
-                let green = dim.apply(colors::GREEN);
-                let red = dim.apply(colors::RED);
-                format!(
-                    " [{} {}]",
-                    format!("+{}", adds).truecolor(green.0, green.1, green.2),
-                    format!("-{}", dels).truecolor(red.0, red.1, red.2)
-                )
-            }
-            Err(_) => String::new(),
+        // Determine base ref and whether it's reliable
+        let (base_ref, is_reliable) = if let Some(lkg) = branch.lkg_parent.as_deref() {
+            (Some(lkg.to_string()), true)
+        } else if let Ok(merge_base) =
+            git_repo.merge_base(&branch_status.parent_branch, &branch_status.sha)
+        {
+            (Some(merge_base), false) // merge-base is less reliable
+        } else {
+            (None, false)
+        };
+
+        match base_ref {
+            Some(base) => match git_repo.diff_stats(&base, &branch_status.sha) {
+                Ok((adds, dels)) => {
+                    let green = dim.apply(colors::GREEN);
+                    let red = dim.apply(colors::RED);
+                    let prefix = if is_reliable { "" } else { "~ " };
+                    format!(
+                        " [{}{}{}]",
+                        prefix,
+                        format!("+{}", adds).truecolor(green.0, green.1, green.2),
+                        format!(" -{}", dels).truecolor(red.0, red.1, red.2)
+                    )
+                }
+                Err(_) => String::new(),
+            },
+            None => String::new(),
         }
     };
 

src/state.rs

@@ -663,23 +663,30 @@ impl State {
         let mut queue: VecDeque<(Option<String>, String)> = VecDeque::new();
         queue.push_back((None, trunk.main_branch.clone()));
         while let Some((parent, branch)) = queue.pop_front() {
-            // Skip branches that don't exist locally
-            if !git_branch_exists(git_repo, &branch) {
+            // Resolve branch to local or remote ref
+            let Some(branch_ref) = git_repo.resolve_branch_ref(&branch) else {
                 tracing::debug!("Skipping non-existent branch {} in refresh_lkgs", branch);
                 continue;
-            }
+            };
 
             if let Some(parent) = parent {
+                // Resolve parent to local or remote ref
+                let parent_ref = git_repo
+                    .resolve_branch_ref(&parent)
+                    .unwrap_or_else(|| parent.clone());
+
                 let tree_branch = self.get_tree_branch(repo, &branch).unwrap();
                 if let Some(lkg_parent) = tree_branch.lkg_parent.as_deref() {
-                    if git_repo.is_ancestor(lkg_parent, &branch)? {
+                    if git_repo.is_ancestor(lkg_parent, &branch_ref)? {
                         parent_lkgs.insert(tree_branch.name.clone(), Some(lkg_parent.to_string()));
                     } else {
                         parent_lkgs.insert(tree_branch.name.clone(), None);
                     }
                 }
-                if git_repo.is_ancestor(&parent, &branch).unwrap_or(false)
-                    && let Ok(new_lkg_parent) = git_repo.sha(&parent)
+                if git_repo
+                    .is_ancestor(&parent_ref, &branch_ref)
+                    .unwrap_or(false)
+                    && let Ok(new_lkg_parent) = git_repo.sha(&parent_ref)
                 {
                     tracing::debug!(
                         lkg_parent = ?new_lkg_parent,