fix(output_window): improve bottom-tracking with wrap-aware scroll and trailing blank line handling

This should smooth out the scroll jumps when streaming tokens near a fold

Author: sudo-tee

lua/opencode/ui/output_window.lua

@@ -141,13 +141,37 @@ function M.is_at_bottom(win)
     return true
   end
 
+  local effective_bottom = M.get_effective_bottom_line(state.windows.output_buf, line_count)
+
   local ok2, cursor = pcall(vim.api.nvim_win_get_cursor, win)
   if not ok2 then
     return true
   end
 
   local prev_line_count = M._prev_line_count_by_win[win] or line_count
-  return cursor[1] >= prev_line_count or cursor[1] >= line_count
+  local prev_effective_bottom = M.get_effective_bottom_line(state.windows.output_buf, prev_line_count)
+  return cursor[1] >= prev_effective_bottom or cursor[1] >= effective_bottom
+end
+
+---@param buf integer
+---@param line_count? integer
+---@return integer
+function M.get_effective_bottom_line(buf, line_count)
+  if not buf or not vim.api.nvim_buf_is_valid(buf) then
+    return 0
+  end
+
+  line_count = line_count or vim.api.nvim_buf_line_count(buf)
+  if not line_count or line_count <= 0 then
+    return 0
+  end
+
+  local last_line = vim.api.nvim_buf_get_lines(buf, line_count - 1, line_count, false)[1]
+  if line_count > 1 and last_line == '' then
+    return line_count - 1
+  end
+
+  return line_count
 end
 
 ---@param win? integer
@@ -219,6 +243,7 @@ function M.setup(windows)
   )
   window_options.set_window_option('wrap', true, windows.output_win, { save_original = true })
   window_options.set_window_option('linebreak', true, windows.output_win, { save_original = true })
+  pcall(window_options.set_window_option, 'smoothscroll', true, windows.output_win, { save_original = true })
   window_options.set_window_option('cursorline', false, windows.output_win, { save_original = true })
   window_options.set_window_option('number', false, windows.output_win, { save_original = true })
   window_options.set_window_option('relativenumber', false, windows.output_win, { save_original = true })
@@ -363,10 +388,11 @@ function M.set_folds(fold_ranges)
   end
 
   local was_open = M.get_open_fold_starts(win, buf)
+  local preserve_view = not M.is_at_bottom(win)
   vim.api.nvim_buf_set_var(buf, 'opencode_folds', folds)
 
   vim.api.nvim_win_call(win, function()
-    local view = vim.fn.winsaveview()
+    local view = preserve_view and vim.fn.winsaveview() or nil
 
     local line_count = vim.api.nvim_buf_line_count(buf)
     for _, range in ipairs(folds.ranges) do
@@ -381,7 +407,9 @@ function M.set_folds(fold_ranges)
       end
     end
 
-    vim.fn.winrestview(view)
+    if view then
+      vim.fn.winrestview(view)
+    end
   end)
 end
 

lua/opencode/ui/renderer/scroll.lua

@@ -3,6 +3,67 @@ local output_window = require('opencode.ui.output_window')
 
 local M = {}
 
+---@param win integer
+---@return boolean
+local function window_wraps(win)
+  local ok, wrap = pcall(vim.api.nvim_get_option_value, 'wrap', { win = win })
+  return ok and wrap == true or false
+end
+
+---@param win integer
+---@return integer
+local function get_text_width(win)
+  local width = vim.api.nvim_win_get_width(win)
+  local ok, wininfo = pcall(vim.fn.getwininfo, win)
+  local textoff = ok and wininfo and wininfo[1] and wininfo[1].textoff or 0
+  return math.max(1, width - textoff)
+end
+
+---@param buf integer
+---@param win integer
+---@param target_line integer
+---@return boolean
+local function end_of_target_line_fits_view(buf, win, target_line)
+  if not window_wraps(win) then
+    return true
+  end
+
+  local visible_top = output_window.get_visible_top_line(win)
+  local visible_bottom = output_window.get_visible_bottom_line(win)
+  if not visible_top or not visible_bottom or target_line < visible_top or target_line > visible_bottom then
+    return false
+  end
+
+  local height = vim.api.nvim_win_get_height(win)
+  local text_width = get_text_width(win)
+  local rows = 0
+  local line = visible_top
+
+  while line <= target_line do
+    local fold_start = vim.api.nvim_win_call(win, function()
+      return vim.fn.foldclosed(line)
+    end)
+
+    if fold_start ~= -1 then
+      rows = rows + 1
+      line = vim.api.nvim_win_call(win, function()
+        return vim.fn.foldclosedend(line) + 1
+      end)
+    else
+      local text = vim.api.nvim_buf_get_lines(buf, line - 1, line, false)[1] or ''
+      local display_width = math.max(1, vim.fn.strdisplaywidth(text))
+      rows = rows + math.max(1, math.ceil(display_width / text_width))
+      line = line + 1
+    end
+
+    if rows > height then
+      return false
+    end
+  end
+
+  return true
+end
+
 ---@return integer|nil
 function M.get_output_win()
   local windows = state.windows
@@ -21,11 +82,27 @@ function M.scroll_win_to_bottom(win, buf)
   if line_count == 0 then
     return
   end
-  local last_line = vim.api.nvim_buf_get_lines(buf, line_count - 1, line_count, false)[1] or ''
-  vim.api.nvim_win_set_cursor(win, { line_count, #last_line })
-  vim.api.nvim_win_call(win, function()
-    vim.cmd('normal! zb')
-  end)
+
+  local target_line = output_window.get_effective_bottom_line(buf, line_count)
+  if target_line <= 0 then
+    return
+  end
+
+  local target_text = vim.api.nvim_buf_get_lines(buf, target_line - 1, target_line, false)[1] or ''
+  local visible_bottom = output_window.get_visible_bottom_line(win)
+  vim.api.nvim_win_set_cursor(win, { target_line, #target_text })
+
+  local needs_bottom_align = not visible_bottom or target_line > visible_bottom
+  if not needs_bottom_align and window_wraps(win) then
+    needs_bottom_align = not end_of_target_line_fits_view(buf, win, target_line)
+  end
+
+  if needs_bottom_align then
+    vim.api.nvim_win_call(win, function()
+      vim.cmd('normal! zb')
+    end)
+  end
+
   output_window._prev_line_count_by_win[win] = line_count
 end
 

tests/unit/cursor_tracking_spec.lua

@@ -220,6 +220,13 @@ describe('output_window.is_at_bottom', function()
     assert.is_true(output_window.is_at_bottom(win))
   end)
 
+  it('treats a trailing blank line as padding, not content bottom', function()
+    vim.api.nvim_buf_set_lines(buf, 0, -1, false, { 'line 1', 'line 2', '' })
+    vim.api.nvim_win_set_cursor(win, { 2, 0 })
+
+    assert.is_true(output_window.is_at_bottom(win))
+  end)
+
   it('returns false when cursor is not on last line', function()
     -- cursor not at last line
     vim.api.nvim_win_set_cursor(win, { 25, 0 })
@@ -364,6 +371,7 @@ describe('renderer.scroll_to_bottom', function()
   local renderer = require('opencode.ui.renderer')
   local ctx = require('opencode.ui.renderer.ctx')
   local output_window = require('opencode.ui.output_window')
+  local stub = require('luassert.stub')
   local buf, win
 
   before_each(function()
@@ -437,6 +445,90 @@ describe('renderer.scroll_to_bottom', function()
     assert.equals(3, cursor[1])
     assert.equals(#longer_line - 1, cursor[2])
   end)
+
+  it('scrolls to the last non-empty line when buffer ends with padding', function()
+    vim.api.nvim_buf_set_lines(buf, 0, -1, false, { 'line 1', 'line 2', '' })
+
+    local scroll = require('opencode.ui.renderer.scroll')
+    scroll.scroll_win_to_bottom(win, buf)
+
+    local cursor = vim.api.nvim_win_get_cursor(win)
+    assert.equals(2, cursor[1])
+  end)
+
+  it('skips zb when the followed bottom line is already visible', function()
+    vim.api.nvim_buf_set_lines(buf, 0, -1, false, { 'line 1', 'line 2', 'line 3' })
+    vim.api.nvim_win_set_height(win, 10)
+    vim.api.nvim_set_option_value('wrap', false, { win = win, scope = 'local' })
+    vim.api.nvim_win_set_cursor(win, { 1, 0 })
+
+    local cmd_stub = stub(vim, 'cmd')
+    local scroll = require('opencode.ui.renderer.scroll')
+    scroll.scroll_win_to_bottom(win, buf)
+
+    local cursor = vim.api.nvim_win_get_cursor(win)
+    assert.equals(3, cursor[1])
+    assert.stub(cmd_stub).was_not_called_with('normal! zb')
+    cmd_stub:revert()
+  end)
+
+  it('uses zb when the followed bottom line is below the viewport', function()
+    local lines = {}
+    for i = 1, 40 do
+      lines[i] = 'line ' .. i
+    end
+    vim.api.nvim_buf_set_lines(buf, 0, -1, false, lines)
+    vim.api.nvim_win_set_height(win, 5)
+    vim.api.nvim_win_set_cursor(win, { 1, 0 })
+
+    local cmd_stub = stub(vim, 'cmd').invokes(function(cmd)
+      if cmd == 'normal! zb' then
+        vim.api.nvim_win_call(win, function()
+          vim.fn.winrestview({ topline = 36 })
+        end)
+        return
+      end
+      return vim.api.nvim_cmd(vim.api.nvim_parse_cmd(cmd, {}), {})
+    end)
+
+    local scroll = require('opencode.ui.renderer.scroll')
+    scroll.scroll_win_to_bottom(win, buf)
+
+    local cursor = vim.api.nvim_win_get_cursor(win)
+    assert.equals(40, cursor[1])
+    assert.stub(cmd_stub).was_called_with('normal! zb')
+    cmd_stub:revert()
+  end)
+
+  it('uses zb when a wrapped bottom line grows past the last screen row', function()
+    local long_line = string.rep('x', 80)
+    local longer_line = string.rep('x', 180)
+
+    vim.api.nvim_win_set_width(win, 20)
+    vim.api.nvim_win_set_height(win, 5)
+    vim.api.nvim_set_option_value('wrap', true, { win = win, scope = 'local' })
+    vim.api.nvim_buf_set_lines(buf, 0, -1, false, { long_line })
+
+    local cmd_stub = stub(vim, 'cmd').invokes(function(cmd)
+      if cmd == 'normal! zb' then
+        return
+      end
+      return vim.api.nvim_cmd(vim.api.nvim_parse_cmd(cmd, {}), {})
+    end)
+
+    local scroll = require('opencode.ui.renderer.scroll')
+    scroll.scroll_win_to_bottom(win, buf)
+    cmd_stub:clear()
+
+    vim.api.nvim_buf_set_lines(buf, 0, 1, false, { longer_line })
+    scroll.scroll_win_to_bottom(win, buf)
+
+    local cursor = vim.api.nvim_win_get_cursor(win)
+    assert.equals(1, cursor[1])
+    assert.equals(#longer_line - 1, cursor[2])
+    assert.stub(cmd_stub).was_called_with('normal! zb')
+    cmd_stub:revert()
+  end)
 end)
 
 describe('ui.focus_input', function()

tests/unit/output_window_spec.lua

@@ -175,6 +175,32 @@ describe('output_window.setup', function()
     assert.equals(1, foldclosed)
   end)
 
+  it('does not restore the view when following the bottom during fold updates', function()
+    output_window.setup({ output_buf = buf, output_win = win })
+    output_window.set_lines({ 'a', 'b', 'c', 'd' })
+    vim.api.nvim_win_set_cursor(win, { 4, 0 })
+
+    local winrestview_stub = stub(vim.fn, 'winrestview')
+
+    output_window.set_folds({ { from = 1, to = 3 } })
+
+    assert.stub(winrestview_stub).was_not_called()
+    winrestview_stub:revert()
+  end)
+
+  it('restores the view when the user is reading away from the bottom', function()
+    output_window.setup({ output_buf = buf, output_win = win })
+    output_window.set_lines({ 'a', 'b', 'c', 'd' })
+    vim.api.nvim_win_set_cursor(win, { 2, 0 })
+
+    local winrestview_stub = stub(vim.fn, 'winrestview')
+
+    output_window.set_folds({ { from = 1, to = 3 } })
+
+    assert.stub(winrestview_stub).was_called()
+    winrestview_stub:revert()
+  end)
+
   it('stores fold metadata in a lookup-friendly structure', function()
     output_window.setup({ output_buf = buf, output_win = win })
     output_window.set_folds({ { from = 3, to = 5 }, { from = 1, to = 2 } })