fix(core): improve tui minimal view display and prevent flashing scrollbar (#32045)

## Current Behavior

- When the minimal view in the TUI is shown, some borders are initially
shown for a fraction of a second.
- When rendering terminal panes, the scrollbar can be wrongly shown for
a fraction of a second when the PTY dimensions are stale. This looks
like the scrollbar flashes.

## Expected Behavior

- When the minimal view in the TUI is shown, no borders should ever be
shown.
- The scrollbar should only be shown when rendering terminal panes when
needed.

Author: leosvelperez

packages/nx/src/native/tui/app.rs

@@ -1030,6 +1030,10 @@ impl App {
                         })
                         .collect();
 
+                    // Calculate minimal view context once for all panes
+                    let is_minimal =
+                        self.is_task_list_hidden() && get_task_count(&self.task_graph) == 1;
+
                     for (pane_idx, pane_area, relevant_pane_task) in terminal_panes_data {
                         if let Some(task_name) = relevant_pane_task {
                             let task_status = self
@@ -1039,11 +1043,11 @@ impl App {
                             // If task is pending, show dependency view instead of terminal pane
                             if task_status == TaskStatus::NotStarted {
                                 self.render_dependency_view_internal(
-                                    f, pane_idx, pane_area, task_name,
+                                    f, pane_idx, pane_area, task_name, is_minimal,
                                 );
                             } else {
                                 self.render_terminal_pane_internal(
-                                    f, pane_idx, pane_area, task_name,
+                                    f, pane_idx, pane_area, task_name, is_minimal,
                                 );
                             }
                         } else {
@@ -1660,6 +1664,7 @@ impl App {
         pane_idx: usize,
         pane_area: Rect,
         task_name: String,
+        is_minimal: bool,
     ) {
         // Calculate values that were previously passed in
         let task_status = self
@@ -1704,7 +1709,8 @@ impl App {
 
         // No need to update status in DependencyViewState - we pass the full map to the widget
         if let Some(dep_state) = &mut self.dependency_view_states[pane_idx] {
-            let dependency_view = DependencyView::new(&self.task_status_map, &self.task_graph);
+            let dependency_view =
+                DependencyView::new(&self.task_status_map, &self.task_graph, is_minimal);
             f.render_stateful_widget(dependency_view, pane_area, dep_state);
         }
     }
@@ -1716,13 +1722,13 @@ impl App {
         pane_idx: usize,
         pane_area: Rect,
         task_name: String,
+        is_minimal: bool,
     ) {
         // Calculate values that were previously passed in
         let task_status = self
             .get_task_status(&task_name)
             .unwrap_or(TaskStatus::NotStarted);
         let task_continuous = self.is_task_continuous(&task_name);
-        let tasks_list_hidden = self.is_task_list_hidden();
         let has_pty = self.pty_instances.contains_key(&task_name);
 
         let is_focused = match self.focus {
@@ -1769,7 +1775,7 @@ impl App {
         );
 
         let terminal_pane = TerminalPane::new()
-            .minimal(tasks_list_hidden && get_task_count(&self.task_graph) == 1)
+            .minimal(is_minimal)
             .pty_data(terminal_pane_data)
             .continuous(task_continuous);
 

packages/nx/src/native/tui/components/dependency_view.rs

@@ -168,13 +168,19 @@ impl DependencyViewState {
 pub struct DependencyView<'a> {
     status_map: &'a HashMap<String, TaskStatus>,
     task_graph: &'a TaskGraph,
+    is_minimal: bool,
 }
 
 impl<'a> DependencyView<'a> {
-    pub fn new(status_map: &'a HashMap<String, TaskStatus>, task_graph: &'a TaskGraph) -> Self {
+    pub fn new(
+        status_map: &'a HashMap<String, TaskStatus>,
+        task_graph: &'a TaskGraph,
+        is_minimal: bool,
+    ) -> Self {
         Self {
             status_map,
             task_graph,
+            is_minimal,
         }
     }
 
@@ -375,17 +381,23 @@ impl<'a> StatefulWidget for DependencyView<'a> {
             ),
         ];
 
-        let block = Block::default()
-            .title(title)
-            .title_alignment(Alignment::Left)
-            .borders(Borders::ALL)
-            .border_type(if state.is_focused {
-                BorderType::Thick
-            } else {
-                BorderType::Plain
-            })
-            .border_style(border_style)
-            .padding(Padding::new(2, 2, 1, 1));
+        let block = if self.is_minimal {
+            Block::default()
+                .borders(Borders::NONE)
+                .padding(Padding::new(2, 2, 1, 1))
+        } else {
+            Block::default()
+                .title(title)
+                .title_alignment(Alignment::Left)
+                .borders(Borders::ALL)
+                .border_type(if state.is_focused {
+                    BorderType::Thick
+                } else {
+                    BorderType::Plain
+                })
+                .border_style(border_style)
+                .padding(Padding::new(2, 2, 1, 1))
+        };
 
         let inner_area = block.inner(area);
         block.render(area, buf);

packages/nx/src/native/tui/components/terminal_pane.rs

@@ -185,6 +185,8 @@ pub struct TerminalPaneState {
     pub has_pty: bool,
     pub is_next_tab_target: bool,
     pub console_available: bool,
+    // Cache expected viewport dimensions for consistent scrollbar calculations
+    pub expected_viewport_height: Option<u16>,
 }
 
 impl TerminalPaneState {
@@ -207,6 +209,7 @@ impl TerminalPaneState {
             has_pty,
             is_next_tab_target,
             console_available,
+            expected_viewport_height: None,
         }
     }
 }
@@ -323,6 +326,39 @@ impl<'a> TerminalPane<'a> {
             .map(|data| data.is_interactive)
             .unwrap_or(false)
     }
+
+    /// Calculate content rows based on expected viewport height, not current PTY dimensions.
+    /// This provides consistent scrollbar calculations even when PTY hasn't been resized yet.
+    fn calculate_content_rows_for_viewport(
+        &self,
+        pty: &crate::native::tui::pty::PtyInstance,
+        expected_viewport_height: u16,
+    ) -> usize {
+        // Try to get current content rows from PTY
+        let current_content_rows = pty.get_total_content_rows();
+
+        // If we have a cached viewport height and it differs from expected,
+        // we need to estimate content based on the expected dimensions
+        if let Some(screen) = pty.get_screen() {
+            let (current_rows, _current_cols) = screen.size();
+
+            // If current PTY dimensions match expected viewport, use current calculation
+            if current_rows == expected_viewport_height {
+                return current_content_rows;
+            }
+
+            // Otherwise, estimate content rows based on expected viewport height
+            // This is a simple heuristic: assume content scales linearly with viewport height
+            if current_rows > 0 {
+                let scale_factor = expected_viewport_height as f64 / current_rows as f64;
+                let estimated_content = (current_content_rows as f64 * scale_factor) as usize;
+                return estimated_content.max(expected_viewport_height as usize);
+            }
+        }
+
+        // Fallback to current calculation
+        current_content_rows
+    }
 }
 
 // This lifetime is needed for our terminal pane data, it breaks without it
@@ -543,11 +579,21 @@ impl<'a> StatefulWidget for TerminalPane<'a> {
             if let Some(pty) = &pty_data.pty {
                 if let Some(screen) = pty.get_screen() {
                     let viewport_height = inner_area.height;
+
+                    // Cache expected viewport height for consistent calculations
+                    state.expected_viewport_height = Some(viewport_height);
+
                     let current_scroll = pty.get_scroll_offset();
 
-                    let total_content_rows = pty.get_total_content_rows();
+                    // Calculate content based on expected dimensions, not current PTY dimensions
+                    // This prevents scrollbar flash when PTY hasn't been resized yet
+                    let total_content_rows =
+                        self.calculate_content_rows_for_viewport(pty, viewport_height);
                     let scrollable_rows =
                         total_content_rows.saturating_sub(viewport_height as usize);
+
+                    // Determine if scrollbar is needed based on content vs viewport size
+                    // This is deterministic and doesn't depend on actual PTY dimensions
                     let needs_scrollbar = scrollable_rows > 0;
 
                     // Reset scrollbar state if no scrolling needed