fix(core): make running a single task more transparent (#31163)

<!-- Please make sure you have read the submission guidelines before
posting an PR -->
<!--
https://github.com/nrwl/nx/blob/master/CONTRIBUTING.md#-submitting-a-pr
-->

<!-- Please make sure that your commit message follows our format -->
<!-- Example: `fix(nx): must begin with lowercase` -->

<!-- If this is a particularly complex change or feature addition, you
can request a dedicated Nx release for this pull request branch. Mention
someone from the Nx team or the `@nrwl/nx-pipelines-reviewers` and they
will confirm if the PR warrants its own release for testing purposes,
and generate it for you if appropriate. -->

## Current Behavior
<!-- This is the behavior we have today -->

Running a single task is in this uncanny framed state and doesn't exit
immediately.

<img width="1317" alt="image"
src="https://github.com/user-attachments/assets/13e7463f-9eb0-48db-95f2-c09e203d494f"
/>

## Expected Behavior
<!-- This is the behavior we should expect with the changes in this PR
-->

Running a single task isn't framed and exits immediately.

This also fixes scrolling in interactive mode based on whether or not
the underlying terminal is in application cursor mode or not.


![image](https://github.com/user-attachments/assets/c32c85e7-edd6-4aba-9a15-bc75cc9ee5ba)


## Related Issue(s)
<!-- Please link the issue being fixed so it gets closed when this is
merged. -->

Fixes #

---------

Co-authored-by: JamesHenry <[email protected]>

Author: FrozenPandaz

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

@@ -1,5 +1,5 @@
 use color_eyre::eyre::Result;
-use crossterm::event::{KeyCode, KeyEvent, KeyModifiers, MouseEventKind};
+use crossterm::event::{KeyCode, KeyEvent, KeyModifiers, MouseEvent, MouseEventKind};
 use hashbrown::HashSet;
 use napi::bindgen_prelude::External;
 use napi::threadsafe_function::{ErrorStrategy, ThreadsafeFunction};
@@ -214,14 +214,22 @@ impl App {
             return;
         }
 
-        self.begin_exit_countdown()
+        if self.tasks.len() > 1 {
+            self.begin_exit_countdown()
+        } else {
+            self.quit();
+        }
+    }
+
+    fn quit(&mut self) {
+        self.quit_at = Some(std::time::Instant::now());
     }
 
     fn begin_exit_countdown(&mut self) {
         let countdown_duration = self.tui_config.auto_exit.countdown_seconds();
         // If countdown is disabled, exit immediately
         if countdown_duration.is_none() {
-            self.quit_at = Some(std::time::Instant::now());
+            self.quit();
             return;
         }
 
@@ -708,27 +716,32 @@ impl App {
                     self.user_has_interacted = true;
                 }
 
+                if matches!(self.focus, Focus::MultipleOutput(_)) {
+                    self.handle_mouse_event(mouse).ok();
+                    return Ok(false);
+                }
+
                 match mouse.kind {
                     MouseEventKind::ScrollUp => {
-                        if matches!(self.focus, Focus::MultipleOutput(_)) {
+                        if matches!(self.focus, Focus::TaskList) {
+                            self.dispatch_action(Action::PreviousTask);
+                        } else {
                             self.handle_key_event(KeyEvent::new(
                                 KeyCode::Up,
                                 KeyModifiers::empty(),
                             ))
                             .ok();
-                        } else if matches!(self.focus, Focus::TaskList) {
-                            self.dispatch_action(Action::PreviousTask);
                         }
                     }
                     MouseEventKind::ScrollDown => {
-                        if matches!(self.focus, Focus::MultipleOutput(_)) {
+                        if matches!(self.focus, Focus::TaskList) {
+                            self.dispatch_action(Action::NextTask);
+                        } else {
                             self.handle_key_event(KeyEvent::new(
                                 KeyCode::Down,
                                 KeyModifiers::empty(),
                             ))
                             .ok();
-                        } else if matches!(self.focus, Focus::TaskList) {
-                            self.dispatch_action(Action::NextTask);
                         }
                     }
                     _ => {}
@@ -790,6 +803,7 @@ impl App {
                     }
 
                     let frame_area = self.frame_area.unwrap();
+                    let tasks_list_hidden = self.is_task_list_hidden();
                     let layout_areas = self.layout_areas.as_mut().unwrap();
 
                     if self.debug_mode {
@@ -970,6 +984,7 @@ impl App {
                                 );
 
                                 let terminal_pane = TerminalPane::new()
+                                    .minimal(tasks_list_hidden && self.tasks.len() == 1)
                                     .pty_data(terminal_pane_data)
                                     .continuous(task.continuous);
 
@@ -1330,6 +1345,15 @@ impl App {
         let _ = self.handle_pty_resize();
     }
 
+    fn handle_mouse_event(&mut self, mouse_event: MouseEvent) -> io::Result<()> {
+        if let Focus::MultipleOutput(pane_idx) = self.focus {
+            let terminal_pane_data = &mut self.terminal_pane_data[pane_idx];
+            terminal_pane_data.handle_mouse_event(mouse_event)
+        } else {
+            Ok(())
+        }
+    }
+
     /// Forward key events to the currently focused pane, if any.
     fn handle_key_event(&mut self, key: KeyEvent) -> io::Result<()> {
         if let Focus::MultipleOutput(pane_idx) = self.focus {

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

@@ -138,7 +138,7 @@ impl LayoutManager {
         self.mode = match self.mode {
             LayoutMode::Auto => {
                 // If we are in auto mode, we need to figure out our current orientation and set the mode to the opposite.
-                if self.is_vertical_layout_preferred(area.width, area.height, self.task_count) {
+                if self.is_vertical_layout_preferred(area.width, area.height) {
                     LayoutMode::Horizontal
                 } else {
                     LayoutMode::Vertical
@@ -249,9 +249,7 @@ impl LayoutManager {
     fn calculate_layout_visible_task_list(&self, area: Rect) -> LayoutAreas {
         // Determine whether to use vertical or horizontal layout
         let use_vertical = match self.mode {
-            LayoutMode::Auto => {
-                self.is_vertical_layout_preferred(area.width, area.height, self.task_count)
-            }
+            LayoutMode::Auto => self.is_vertical_layout_preferred(area.width, area.height),
             LayoutMode::Vertical => true,
             LayoutMode::Horizontal => false,
         };
@@ -401,17 +399,7 @@ impl LayoutManager {
     /// - Terminal aspect ratio
     /// - Number of tasks (single task prefers vertical layout)
     /// - Minimum dimensions requirements
-    fn is_vertical_layout_preferred(
-        &self,
-        terminal_width: u16,
-        terminal_height: u16,
-        task_count: usize,
-    ) -> bool {
-        // If there's only a single task, prefer vertical layout
-        if task_count <= 1 {
-            return true;
-        }
-
+    fn is_vertical_layout_preferred(&self, terminal_width: u16, terminal_height: u16) -> bool {
         // Calculate aspect ratio (width/height)
         let aspect_ratio = terminal_width as f32 / terminal_height as f32;
 
@@ -557,27 +545,6 @@ mod tests {
         assert_eq!(task_list.height, 100 / 3);
     }
 
-    #[test]
-    fn test_auto_mode_prefers_vertical_for_single_task() {
-        let mut layout_manager = LayoutManager::new(5);
-        let area = create_test_area(200, 60); // Wide terminal that would normally use horizontal
-
-        layout_manager.set_mode(LayoutMode::Auto);
-        layout_manager.set_task_list_visibility(TaskListVisibility::Visible);
-        layout_manager.set_pane_arrangement(PaneArrangement::Single);
-        layout_manager.set_task_count(1); // Single task
-
-        let layout = layout_manager.calculate_layout(area);
-        assert!(layout.task_list.is_some());
-
-        // Even though terminal is wide, layout should be vertical for a single task
-        let task_list = layout.task_list.unwrap();
-        assert_eq!(task_list.x, 0);
-        assert_eq!(task_list.y, 0);
-        assert_eq!(task_list.width, 200);
-        assert_eq!(task_list.height, 60 / 3);
-    }
-
     #[test]
     fn test_forced_vertical_mode() {
         let mut layout_manager = LayoutManager::new(5);
@@ -840,19 +807,6 @@ mod tests {
             insta::assert_snapshot!(terminal.backend());
         }
 
-        /// Visual test for auto mode with single task (should be vertical regardless of terminal size)
-        #[test]
-        fn test_visualize_auto_mode_single_task() {
-            let mut layout_manager = LayoutManager::new(5);
-            layout_manager.set_mode(LayoutMode::Auto);
-            layout_manager.set_task_list_visibility(TaskListVisibility::Visible);
-            layout_manager.set_pane_arrangement(PaneArrangement::Single);
-            layout_manager.set_task_count(1);
-
-            let terminal = render_layout(120, 30, &layout_manager);
-            insta::assert_snapshot!(terminal.backend());
-        }
-
         /// Visual test for auto mode with tall terminal
         #[test]
         fn test_visualize_auto_mode_tall_terminal() {