4runr-os 2.1.48 → 2.1.50

package/mk3-tui/src/app.rs

@@ -282,8 +282,9 @@ impl App {
         match key.code {
             // Typing - ALL characters go to command input (with debounce)
             KeyCode::Char(c) => {
-                self.state.command_input.push(c);
+                // CRITICAL: Always set focused when typing to show cursor
                 self.state.command_focused = true;
+                self.state.command_input.push(c);
                 // Debounce: schedule render after delay
                 self.input_debounce = Some(Instant::now());
                 // Don't render immediately - let debounce handle it

package/mk3-tui/src/ui/layout.rs

@@ -40,6 +40,9 @@ fn render_separator(f: &mut Frame, area: Rect) {
 }
 
 pub fn render(f: &mut Frame, state: &AppState) {
+    // CRITICAL: Hide cursor by default at start of each render
+    // Only show it when explicitly set in render_command_box
+    // This prevents cursor from appearing in wrong places (like operations log)
     let full_area = f.size();
     f.render_widget(Clear, full_area);
     
@@ -508,31 +511,53 @@ fn render_center_column(f: &mut Frame, area: Rect, state: &AppState) {
     f.render_widget(Paragraph::new(lines), content_area);
     
     // === RENDER CLEAN SCROLLBAR (only if scrollable) ===
+    // CRITICAL FIX: Only render scrollbar when actually scrollable to prevent flickering
     if total_logs > visible_height && max_scroll > 0 {
         // Scrollbar positioned inside the border, 1 char from right edge
-        let scrollbar_x = panel_area.x + panel_area.width.saturating_sub(3); // Inside border, 1 char from right
+        // Use fixed position to prevent jitter
+        let scrollbar_x = panel_area.x + panel_area.width.saturating_sub(3);
         let scrollbar_y = content_area.y;
         let scrollbar_height = content_area.height;
         
-        // Calculate scrollbar thumb size (proportional to visible/total ratio)
-        let thumb_height = ((visible_height as f32 / total_logs as f32) * scrollbar_height as f32).max(1.0) as u16;
-        let thumb_height = thumb_height.min(scrollbar_height);
+        // CRITICAL: Use integer math to prevent floating point rounding issues
+        // Calculate thumb size (minimum 1 char, proportional to visible/total)
+        let thumb_height = ((visible_height as u32 * scrollbar_height as u32) / total_logs as u32) as u16;
+        let thumb_height = thumb_height.max(1).min(scrollbar_height);
         
-        // Calculate thumb position based on scroll offset
-        let scroll_ratio = if max_scroll > 0 { state.log_scroll as f32 / max_scroll as f32 } else { 0.0 };
-        let thumb_start = (scroll_ratio * (scrollbar_height - thumb_height) as f32) as u16;
+        // Calculate thumb position using integer math for stability
+        let thumb_start = if max_scroll > 0 {
+            // Use integer division to avoid floating point jitter
+            ((state.log_scroll as u32 * (scrollbar_height.saturating_sub(thumb_height) as u32)) / max_scroll as u32) as u16
+        } else {
+            0
+        };
+        
+        // Clamp thumb_start to valid range
+        let thumb_start = thumb_start.min(scrollbar_height.saturating_sub(thumb_height));
+        let thumb_end = (thumb_start + thumb_height).min(scrollbar_height);
+        
+        // Render scrollbar track (entire height) as single operation to prevent flicker
+        // Build scrollbar string first, then render once
+        let mut scrollbar_chars = vec![String::from("│"); scrollbar_height as usize];
         
-        // Draw clean scrollbar with better visibility
-        for i in 0..scrollbar_height {
-            let y = scrollbar_y + i;
+        // Fill thumb portion
+        for i in thumb_start..thumb_end {
+            if i < scrollbar_height {
+                scrollbar_chars[i as usize] = String::from("█");
+            }
+        }
+        
+        // Render entire scrollbar at once (prevents flickering from multiple renders)
+        for (i, c) in scrollbar_chars.iter().enumerate() {
+            let y = scrollbar_y + i as u16;
             if y < scrollbar_y + scrollbar_height {
-                let (c, color) = if i >= thumb_start && i < thumb_start + thumb_height {
-                    ("█", CYBER_CYAN) // Thumb in cyan (matches panel title)
+                let color = if i >= thumb_start as usize && i < thumb_end as usize {
+                    CYBER_CYAN
                 } else {
-                    ("│", TEXT_MUTED) // Track in muted gray
+                    TEXT_MUTED
                 };
                 f.render_widget(
-                    Paragraph::new(c).style(Style::default().fg(color)),
+                    Paragraph::new(c.as_str()).style(Style::default().fg(color)),
                     Rect { x: scrollbar_x, y, width: 1, height: 1 }
                 );
             }
@@ -598,13 +623,14 @@ fn render_command_box(f: &mut Frame, area: Rect, state: &AppState) {
     // Just use spacing for visual separation
     
     // Command prompt - Use ASCII > instead of Unicode ▶
-    let cursor = if state.command_focused || !state.command_input.is_empty() { "_" } else { "_" };
+    // Note: We show a visual cursor character "_" in the text, but the real cursor
+    // position is handled separately below
     let prompt_line = Line::from(vec![
         Span::styled("> ", Style::default().fg(BRAND_PURPLE)), // ASCII > instead of Unicode ▶
         Span::styled("4runr", Style::default().fg(BRAND_VIOLET).add_modifier(Modifier::BOLD)),
         Span::styled(": ", Style::default().fg(TEXT_DIM)), // ASCII : instead of Unicode ›
         Span::styled(&state.command_input, Style::default().fg(TEXT_PRIMARY)),
-        Span::styled(cursor, Style::default().fg(CYBER_CYAN)),
+        Span::styled("_", Style::default().fg(CYBER_CYAN)), // Visual cursor indicator
     ]);
     f.render_widget(Paragraph::new(prompt_line), Rect {
         x: bar_area.x, y: bar_area.y + 1, width: bar_area.width, height: 1
@@ -623,12 +649,26 @@ fn render_command_box(f: &mut Frame, area: Rect, state: &AppState) {
         x: bar_area.x, y: bar_area.y + 2, width: bar_area.width, height: 1
     });
     
-    // Cursor position when focused
-    if state.command_focused {
-        let cursor_x = bar_area.x + 8 + state.command_input.len() as u16; // +8 for "> 4runr: "
+    // CRITICAL FIX: Only set cursor position when user is actively typing
+    // This prevents cursor from appearing in wrong places (operations log, etc.)
+    // IMPORTANT: In Ratatui, set_cursor() shows the cursor, so we only call it here
+    if state.command_focused || !state.command_input.is_empty() {
+        // Calculate correct cursor position: "> 4runr: " = 9 chars
+        let prompt_len = 9u16; // "> 4runr: " = 9 characters ("> " + "4runr" + ": " = 2+5+2 = 9)
+        let input_len = state.command_input.len() as u16;
+        let cursor_x = bar_area.x + prompt_len + input_len;
         let cursor_y = bar_area.y + 1;
-        f.set_cursor(cursor_x.min(bar_area.x + bar_area.width - 1), cursor_y);
+        
+        // Ensure cursor doesn't go beyond the safe area (respects 15% margin)
+        let max_x = (bar_area.x + bar_area.width).saturating_sub(1);
+        let final_x = cursor_x.min(max_x);
+        
+        // Only set cursor if we're actually at the input field
+        // This prevents cursor from appearing elsewhere (operations log, etc.)
+        f.set_cursor(final_x, cursor_y);
     }
+    // IMPORTANT: If not focused and no input, we don't call set_cursor()
+    // This keeps the cursor hidden (hidden at start of main loop)
 }
 
 fn render_too_small(f: &mut Frame, viewport: &SafeViewport) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "4runr-os",
-  "version": "2.1.48",
+  "version": "2.1.50",
   "type": "module",
   "description": "4Runr AI Agent OS - Interactive terminal for managing AI agents",
   "main": "dist/index.js",