feat(ui/renderer): flash-highlight updated lines in output window

Author: sudo-tee

lua/opencode/config.lua

@@ -260,6 +260,7 @@ M.defaults = {
     enabled = false,
     capture_streamed_events = false,
     show_ids = true,
+    highlight_updated_lines = false,
     quick_chat = {
       keep_session = false,
       set_active_session = false,

lua/opencode/types.lua

@@ -208,6 +208,7 @@
 ---@field enabled boolean
 ---@field capture_streamed_events boolean
 ---@field show_ids boolean
+---@field highlight_updated_lines boolean
 ---@field quick_chat {keep_session: boolean, set_active_session: boolean}
 
 ---@class OpencodeHooks

lua/opencode/ui/highlight.lua

@@ -47,6 +47,7 @@ function M.setup()
     vim.api.nvim_set_hl(0, 'OpencodeQuestionOption', { link = 'Normal', default = true })
     vim.api.nvim_set_hl(0, 'OpencodeQuestionBorder', { fg = '#E3F2FD', default = true })
     vim.api.nvim_set_hl(0, 'OpencodeQuestionTitle', { link = '@label', bold = true, default = true })
+    vim.api.nvim_set_hl(0, 'OpencodeDebugUpdatedLine', { bg = '#FFF3BF', default = true })
   else
     vim.api.nvim_set_hl(0, 'OpencodeBorder', { fg = '#616161', default = true })
     vim.api.nvim_set_hl(0, 'OpencodeBackground', { link = 'Normal', default = true })
@@ -90,6 +91,7 @@ function M.setup()
     vim.api.nvim_set_hl(0, 'OpencodeQuestionOption', { link = 'Normal', default = true })
     vim.api.nvim_set_hl(0, 'OpencodeQuestionBorder', { fg = '#2B3A5A', default = true })
     vim.api.nvim_set_hl(0, 'OpencodeQuestionTitle', { link = '@label', bold = true, default = true })
+    vim.api.nvim_set_hl(0, 'OpencodeDebugUpdatedLine', { bg = '#4A3F17', default = true })
   end
 end
 

lua/opencode/ui/output_window.lua

@@ -4,10 +4,12 @@ local window_options = require('opencode.ui.window_options')
 
 local M = {}
 M.namespace = vim.api.nvim_create_namespace('opencode_output')
+M.debug_namespace = vim.api.nvim_create_namespace('opencode_output_debug')
 
 local _update_depth = 0
 local _update_buf = nil
 local _scroll_tracking_suppressed = 0
+local _debug_flash_tick = 0
 
 function M.with_suppressed_scroll_tracking(fn)
   if type(fn) ~= 'function' then
@@ -221,7 +223,7 @@ end
 ---Clear output buf extmarks
 ---@param start_line? integer Line to start clearing, defaults 0
 ---@param end_line? integer Line to clear until, defaults to -1
----@param clear_all? boolean If true, clears all extmarks in the buffer
+---@param clear_all? boolean If true, clears all namespaces in the range
 function M.clear_extmarks(start_line, end_line, clear_all)
   local windows = state.windows
   if not windows or not windows.output_buf or not vim.api.nvim_buf_is_valid(windows.output_buf) then
@@ -267,6 +269,46 @@ function M.set_extmarks(extmarks, line_offset)
   end
 end
 
+---@param ranges { start_line: integer, end_line_exclusive: integer }[]
+function M.flash_updated_line_ranges(ranges)
+  local windows = state.windows
+  if not windows or not windows.output_buf or not vim.api.nvim_buf_is_valid(windows.output_buf) then
+    return
+  end
+
+  if type(ranges) ~= 'table' or vim.tbl_isempty(ranges) then
+    return
+  end
+
+  local output_buf = windows.output_buf
+  _debug_flash_tick = _debug_flash_tick + 1
+  local flash_tick = _debug_flash_tick
+
+  pcall(vim.api.nvim_buf_clear_namespace, output_buf, M.debug_namespace, 0, -1)
+
+  for _, range in ipairs(ranges) do
+    local start_line = math.max(range.start_line or 0, 0)
+    local end_line_exclusive = math.max(range.end_line_exclusive or start_line, start_line)
+    for line = start_line, end_line_exclusive - 1 do
+      pcall(vim.api.nvim_buf_set_extmark, output_buf, M.debug_namespace, line, 0, {
+        line_hl_group = 'OpencodeDebugUpdatedLine',
+        hl_eol = true,
+        priority = 6000,
+      })
+    end
+  end
+
+  vim.defer_fn(function()
+    if flash_tick ~= _debug_flash_tick then
+      return
+    end
+
+    if state.windows and state.windows.output_buf and vim.api.nvim_buf_is_valid(state.windows.output_buf) then
+      pcall(vim.api.nvim_buf_clear_namespace, state.windows.output_buf, M.debug_namespace, 0, -1)
+    end
+  end, 120)
+end
+
 function M.focus_output(should_stop_insert)
   if not M.mounted() then
     return

lua/opencode/ui/renderer/buffer_ops.lua

@@ -5,6 +5,11 @@ local output_window = require('opencode.ui.output_window')
 
 local M = {}
 
+local function resolve_extmark(extmark)
+  local actual_extmark = type(extmark) == 'function' and extmark() or extmark
+  return vim.deepcopy(actual_extmark)
+end
+
 local function merge_output(target, source)
   if not source then
     return
@@ -60,6 +65,181 @@ local function add_trailing_padding(output)
   return output
 end
 
+local function build_output_with_padding(visible_render)
+  return add_trailing_padding(M.flatten_visible_render(visible_render))
+end
+
+local function resolve_line_extmarks(output, line_index)
+  local resolved_extmarks = {}
+
+  for _, extmark in ipairs((output.extmarks or {})[line_index] or {}) do
+    resolved_extmarks[#resolved_extmarks + 1] = resolve_extmark(extmark)
+  end
+
+  return resolved_extmarks
+end
+
+local function line_matches(previous_output, previous_line_index, next_output, next_line_index)
+  return (previous_output.lines or {})[previous_line_index + 1] == (next_output.lines or {})[next_line_index + 1]
+    and vim.deep_equal(
+      resolve_line_extmarks(previous_output, previous_line_index),
+      resolve_line_extmarks(next_output, next_line_index)
+    )
+end
+
+local function build_line_patches(previous_output, next_output)
+  local previous_line_count = #(previous_output.lines or {})
+  local next_line_count = #(next_output.lines or {})
+  local shared_prefix = 0
+
+  while shared_prefix < previous_line_count and shared_prefix < next_line_count do
+    if not line_matches(previous_output, shared_prefix, next_output, shared_prefix) then
+      break
+    end
+    shared_prefix = shared_prefix + 1
+  end
+
+  if shared_prefix == previous_line_count and shared_prefix == next_line_count then
+    return {}
+  end
+
+  local shared_suffix = 0
+  while shared_suffix < (previous_line_count - shared_prefix) and shared_suffix < (next_line_count - shared_prefix) do
+    if not line_matches(
+      previous_output,
+      previous_line_count - shared_suffix - 1,
+      next_output,
+      next_line_count - shared_suffix - 1
+    ) then
+      break
+    end
+    shared_suffix = shared_suffix + 1
+  end
+
+  return {
+    {
+      old_start_line = shared_prefix,
+      old_end_line_exclusive = previous_line_count - shared_suffix,
+      new_start_line = shared_prefix,
+      new_end_line_exclusive = next_line_count - shared_suffix,
+    },
+  }
+end
+
+local function slice_output(output, start_line, end_line_exclusive)
+  local lines = {}
+  for line_index = start_line + 1, end_line_exclusive do
+    lines[#lines + 1] = (output.lines or {})[line_index] or ''
+  end
+
+  local extmarks = {}
+  for line_index, marks in pairs(output.extmarks or {}) do
+    if line_index >= start_line and line_index < end_line_exclusive then
+      local target_index = line_index - start_line
+      extmarks[target_index] = {}
+      for _, extmark in ipairs(marks) do
+        local next_extmark = resolve_extmark(extmark)
+        if next_extmark.end_row then
+          next_extmark.end_row = next_extmark.end_row - start_line
+        end
+        extmarks[target_index][#extmarks[target_index] + 1] = next_extmark
+      end
+    end
+  end
+
+  return {
+    lines = lines,
+    extmarks = extmarks,
+  }
+end
+
+local function apply_full_output(output)
+  local updated_ranges = {
+    {
+      start_line = 0,
+      end_line_exclusive = #(output.lines or {}),
+    },
+  }
+
+  if output_window.buffer_valid() then
+    output_window.begin_update()
+    output_window.clear_extmarks(0, -1, true)
+    output_window.set_lines(output.lines or {})
+    output_window.set_extmarks(output.extmarks)
+    output_window.end_update()
+  end
+
+  return updated_ranges
+end
+
+local function apply_changed_line_patches(previous_output, next_output)
+  local updated_ranges = {}
+  local patches = build_line_patches(previous_output, next_output)
+  local line_delta = 0
+
+  if output_window.buffer_valid() then
+    output_window.begin_update()
+    output_window.clear_extmarks(0, -1, true)
+    for _, patch in ipairs(patches) do
+      local start_line = patch.old_start_line + line_delta
+      local old_end_line_exclusive = patch.old_end_line_exclusive + line_delta
+      local replacement = slice_output(next_output, patch.new_start_line, patch.new_end_line_exclusive)
+
+      output_window.set_lines(replacement.lines or {}, start_line, old_end_line_exclusive)
+
+      updated_ranges[#updated_ranges + 1] = {
+        start_line = start_line,
+        end_line_exclusive = start_line + #(replacement.lines or {}),
+      }
+
+      line_delta = line_delta + (#(replacement.lines or {}) - (patch.old_end_line_exclusive - patch.old_start_line))
+    end
+    output_window.set_extmarks(next_output.extmarks)
+    output_window.end_update()
+  end
+
+  return updated_ranges
+end
+
+local function apply_block_patch(visible_render, patch)
+  local replacement = flatten_block_range(visible_render.blocks or {}, patch.new_start_index, patch.new_end_index)
+  if patch.include_trailing_padding then
+    replacement = add_trailing_padding(replacement)
+  end
+
+  local updated_ranges = {
+    {
+      start_line = patch.start_line,
+      end_line_exclusive = patch.start_line + #(replacement.lines or {}),
+    },
+  }
+
+  if output_window.buffer_valid() then
+    output_window.begin_update()
+    output_window.clear_extmarks(patch.start_line, patch.old_end_line_exclusive, true)
+    output_window.set_lines(replacement.lines or {}, patch.start_line, patch.old_end_line_exclusive)
+    output_window.set_extmarks(replacement.extmarks, patch.start_line)
+    output_window.end_update()
+  end
+
+  return updated_ranges
+end
+
+local function maybe_flash_updated_ranges(ranges)
+  if not require('opencode.config').debug.highlight_updated_lines then
+    return
+  end
+
+  local flashable_ranges = {}
+  for _, range in ipairs(ranges or {}) do
+    if (range.end_line_exclusive or 0) > (range.start_line or 0) then
+      flashable_ranges[#flashable_ranges + 1] = range
+    end
+  end
+
+  output_window.flash_updated_line_ranges(flashable_ranges)
+end
+
 local function get_message_by_id(message_id)
   for _, message in ipairs(state.messages or {}) do
     if message and message.info and message.info.id == message_id then
@@ -113,48 +293,52 @@ end
 ---@param visible_render { blocks?: RenderBlock[] }
 ---@return Output
 function M.apply(visible_render)
-  local output = add_trailing_padding(M.flatten_visible_render(visible_render))
-
-  if output_window.buffer_valid() then
-    output_window.begin_update()
-    output_window.set_lines(output.lines or {})
-    output_window.clear_extmarks(0, -1, true)
-    output_window.set_extmarks(output.extmarks)
-    output_window.end_update()
-  end
+  local output = build_output_with_padding(visible_render)
+  local updated_ranges = apply_full_output(output)
 
   rebuild_render_state_from_blocks(visible_render and visible_render.blocks or {})
+  maybe_flash_updated_ranges(updated_ranges)
   return output
 end
 
 ---@param plan { strategy: 'noop'|'full'|'patch', visible_render: table, patch?: table }
 ---@return Output
 function M.apply_plan(plan)
   if plan and plan.strategy == 'noop' then
-    return add_trailing_padding(M.flatten_visible_render(plan.visible_render))
+    return build_output_with_padding(plan.visible_render)
   end
 
   if not plan or plan.strategy ~= 'patch' or not plan.patch then
-    return M.apply(plan and plan.visible_render or nil)
+    local visible_render = plan and plan.visible_render or nil
+    local next_output = build_output_with_padding(visible_render)
+    local previous_visible_render = ctx.prev_visible_render
+    local updated_ranges
+
+    if previous_visible_render then
+      updated_ranges = apply_changed_line_patches(build_output_with_padding(previous_visible_render), next_output)
+    else
+      updated_ranges = apply_full_output(next_output)
+    end
+
+    rebuild_render_state_from_blocks(visible_render and visible_render.blocks or {})
+    maybe_flash_updated_ranges(updated_ranges)
+    return next_output
   end
 
   local visible_render = plan.visible_render or {}
-  local patch = plan.patch
-  local replacement = flatten_block_range(visible_render.blocks or {}, patch.new_start_index, patch.new_end_index)
-  if patch.include_trailing_padding then
-    replacement = add_trailing_padding(replacement)
-  end
+  local next_output = build_output_with_padding(visible_render)
+  local previous_visible_render = ctx.prev_visible_render
+  local updated_ranges
 
-  if output_window.buffer_valid() then
-    output_window.begin_update()
-    output_window.set_lines(replacement.lines or {}, patch.start_line, patch.old_end_line_exclusive)
-    output_window.clear_extmarks(patch.start_line, patch.old_end_line_exclusive, false)
-    output_window.set_extmarks(replacement.extmarks, patch.start_line)
-    output_window.end_update()
+  if previous_visible_render then
+    updated_ranges = apply_changed_line_patches(build_output_with_padding(previous_visible_render), next_output)
+  else
+    updated_ranges = apply_block_patch(visible_render, plan.patch)
   end
 
   rebuild_render_state_from_blocks(visible_render.blocks or {})
-  return add_trailing_padding(M.flatten_visible_render(visible_render))
+  maybe_flash_updated_ranges(updated_ranges)
+  return next_output
 end
 
 ---@param prev_visible_render { blocks?: RenderBlock[] }?