fix: show only group-relevant hunks when selecting file in sidebar (v0.5.1)

Previously, clicking a file in the sidebar showed all hunks from the
entire group (or the wrong group when a file appeared in multiple groups).
Now the diff pane shows only the specific hunks assigned to that file
within its group.

Key changes:
- TreeNodeId::File includes group index to disambiguate same file across groups
- Sidebar navigation (j/k) syncs diff view immediately, not just on Enter
- hunk_filter_for_file builds per-file filter scoped to the selected group

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Alan Shum

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "semantic-diff"
-version = "0.5.0"
+version = "0.5.1"
 edition = "2021"
 description = "A terminal diff viewer with AI-powered semantic grouping (Claude CLI / Copilot)"
 license = "MIT"

Cargo.toml

@@ -526,44 +526,45 @@ impl App {
         match key.code {
             KeyCode::Char('j') | KeyCode::Down => {
                 ts.key_down();
-                None
             }
             KeyCode::Char('k') | KeyCode::Up => {
                 ts.key_up();
-                None
             }
             KeyCode::Left => {
                 ts.key_left();
-                None
             }
             KeyCode::Right => {
                 ts.key_right();
-                None
             }
             KeyCode::Enter => {
-                let selected = ts.selected().to_vec();
-                drop(ts); // release borrow before mutating self
-                if let Some(last) = selected.last() {
-                    match last {
-                        TreeNodeId::File(path) => {
-                            self.select_tree_file(path);
-                        }
-                        TreeNodeId::Group(gi) => {
-                            self.select_tree_group(*gi);
-                        }
-                    }
-                }
-                None
+                ts.toggle_selected();
             }
             KeyCode::Char('g') => {
                 ts.select_first();
-                None
             }
             KeyCode::Char('G') => {
                 ts.select_last();
-                None
             }
-            _ => None,
+            _ => return None,
+        }
+
+        // After any navigation, sync the diff view to the selected tree node
+        let selected = ts.selected().to_vec();
+        drop(ts); // release borrow before mutating self
+        self.apply_tree_selection(&selected);
+        None
+    }
+
+    /// Update the diff view filter based on the currently selected tree node.
+    fn apply_tree_selection(&mut self, selected: &[TreeNodeId]) {
+        match selected.last() {
+            Some(TreeNodeId::File(group_idx, path)) => {
+                self.select_tree_file(path, *group_idx);
+            }
+            Some(TreeNodeId::Group(gi)) => {
+                self.select_tree_group(*gi);
+            }
+            None => {}
         }
     }
 
@@ -625,11 +626,11 @@ impl App {
         }
     }
 
-    /// Filter the diff view to the group containing the selected file, and scroll to it.
-    /// If the group is already active, just scroll to the file without toggling off.
-    fn select_tree_file(&mut self, path: &str) {
-        let filter = self.hunk_filter_for_file(path);
-        // Always apply the group filter (don't toggle — that's what group headers are for)
+    /// Filter the diff view to show only the hunks for the selected file within its group.
+    /// `group_idx` identifies which group the file was selected from (None = flat/ungrouped).
+    fn select_tree_file(&mut self, path: &str, group_idx: Option<usize>) {
+        let filter = self.hunk_filter_for_file(path, group_idx);
+        // Always apply the filter (don't toggle — that's what group headers are for)
         self.tree_filter = Some(filter);
         // Rebuild visible items and scroll to the selected file's header
         let items = self.visible_items();
@@ -652,40 +653,74 @@ impl App {
     fn select_tree_group(&mut self, group_idx: usize) {
         let filter = self.hunk_filter_for_group(group_idx);
         if filter.is_empty() {
-            self.tree_state.borrow_mut().toggle_selected();
             return;
         }
-        // Toggle: if already filtering to this group, clear it
-        if self.tree_filter.as_ref() == Some(&filter) {
-            self.tree_filter = None;
-        } else {
-            self.tree_filter = Some(filter);
-        }
+        self.tree_filter = Some(filter);
         self.ui_state.selected_index = 0;
         self.ui_state.scroll_offset = 0;
     }
 
-    /// Build a HunkFilter for the group containing `path`.
-    /// Falls back to showing just that file (all hunks) if no groups exist.
-    fn hunk_filter_for_file(&self, path: &str) -> HunkFilter {
+    /// Build a HunkFilter for a single file's hunks within a specific group.
+    /// Only shows the hunks relevant to that group, not the entire group's files.
+    fn hunk_filter_for_file(&self, path: &str, group_idx: Option<usize>) -> HunkFilter {
         if let Some(groups) = &self.semantic_groups {
-            for (gi, group) in groups.iter().enumerate() {
-                let has_file = group.changes().iter().any(|c| {
-                    c.file == path || path.ends_with(c.file.as_str()) || c.file.ends_with(path)
-                });
-                if has_file {
-                    return self.hunk_filter_for_group(gi);
+            if let Some(gi) = group_idx {
+                if gi >= groups.len() {
+                    // "Other" group — extract only this file's ungrouped hunks
+                    return self.hunk_filter_for_file_in_other(path);
+                }
+                if let Some(group) = groups.get(gi) {
+                    if let Some(filter) = self.hunk_filter_for_file_in_group(path, group) {
+                        return filter;
+                    }
                 }
             }
-            // File is in the "Other" group — collect ungrouped file/hunks
-            return self.hunk_filter_for_other();
+            // Fallback (no group_idx or file not found in specified group):
+            // search all groups for the first match
+            for group in groups.iter() {
+                if let Some(filter) = self.hunk_filter_for_file_in_group(path, group) {
+                    return filter;
+                }
+            }
+            return self.hunk_filter_for_file_in_other(path);
         }
-        // No semantic groups — filter to just this file (all hunks)
+        // No semantic groups — show all hunks for this file
         let mut filter = HunkFilter::new();
         filter.insert(path.to_string(), HashSet::new());
         filter
     }
 
+    /// Build a single-file HunkFilter from a specific group's changes.
+    fn hunk_filter_for_file_in_group(
+        &self,
+        path: &str,
+        group: &crate::grouper::SemanticGroup,
+    ) -> Option<HunkFilter> {
+        for change in &group.changes() {
+            if let Some(diff_path) = self.resolve_diff_path(&change.file) {
+                if diff_path == path {
+                    let mut filter = HunkFilter::new();
+                    let hunk_set: HashSet<usize> = change.hunks.iter().copied().collect();
+                    filter.insert(diff_path, hunk_set);
+                    return Some(filter);
+                }
+            }
+        }
+        None
+    }
+
+    /// Build a single-file HunkFilter from the "Other" (ungrouped) hunks.
+    fn hunk_filter_for_file_in_other(&self, path: &str) -> HunkFilter {
+        let other = self.hunk_filter_for_other();
+        let mut filter = HunkFilter::new();
+        if let Some(hunk_set) = other.get(path) {
+            filter.insert(path.to_string(), hunk_set.clone());
+        } else {
+            filter.insert(path.to_string(), HashSet::new());
+        }
+        filter
+    }
+
     /// Build a HunkFilter for group at `group_idx`.
     fn hunk_filter_for_group(&self, group_idx: usize) -> HunkFilter {
         if let Some(groups) = &self.semantic_groups {

src/app.rs

@@ -8,17 +8,19 @@ use ratatui::Frame;
 use tui_tree_widget::{Tree, TreeItem};
 
 /// Identifier for tree nodes.
+/// Files include an optional group index to disambiguate the same file in multiple groups.
 #[derive(Debug, Clone, Hash, Eq, PartialEq)]
 pub enum TreeNodeId {
     Group(usize),
-    File(String),
+    File(Option<usize>, String), // (group_index, path)
 }
 
 impl std::fmt::Display for TreeNodeId {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             TreeNodeId::Group(i) => write!(f, "group-{i}"),
-            TreeNodeId::File(path) => write!(f, "file-{path}"),
+            TreeNodeId::File(Some(gi), path) => write!(f, "file-{gi}-{path}"),
+            TreeNodeId::File(None, path) => write!(f, "file-{path}"),
         }
     }
 }
@@ -50,7 +52,7 @@ fn build_flat_tree<'a>(app: &App) -> Vec<TreeItem<'a, TreeNodeId>> {
                     Style::default().fg(Color::Red),
                 ),
             ]);
-            TreeItem::new_leaf(TreeNodeId::File(path), line)
+            TreeItem::new_leaf(TreeNodeId::File(None, path), line)
         })
         .collect()
 }
@@ -130,7 +132,7 @@ fn build_grouped_tree<'a>(
                         Style::default().fg(Color::Red),
                     ),
                 ]);
-                children.push(TreeItem::new_leaf(TreeNodeId::File(path), line));
+                children.push(TreeItem::new_leaf(TreeNodeId::File(Some(gi), path), line));
             }
         }
 
@@ -194,7 +196,7 @@ fn build_grouped_tree<'a>(
                     Style::default().fg(Color::Red),
                 ),
             ]);
-            other_children.push(TreeItem::new_leaf(TreeNodeId::File(path), line));
+            other_children.push(TreeItem::new_leaf(TreeNodeId::File(Some(groups.len()), path), line));
         }
     }