feat: add streaming 'typing' reveal for the unified inline diff

Animate the unified inline diff with a natural character-by-character
'typing' reveal, opt-in via diff_opts.stream_reveal.

- Incremental reveal: each tick appends only the new tail to the buffer
  and adds extmarks only for lines just fully revealed, so the work is
  O(n) in lines instead of O(n^2); earlier lines and their marks are
  never rewritten, keeping highlights correctly positioned.
- Cancellable: a module-level reveal_gen generation counter aborts any
  in-flight animation (e.g. when a new diff replaces this buffer or the
  diff is torn down), preventing the stale-typing bug and diff
  accumulation (see #205).
- Configurable: stream_reveal, stream_reveal_delay_ms (floor), and
  stream_reveal_chars_per_tick under diff_opts; per-tick cadence uses a
  randomized 400-1000 WPM feel.

Stacks on #300 (the unified inline diff layout).

Author: spoloxs

lua/claudecode/diff_inline.lua

@@ -12,6 +12,12 @@ local ns = vim.api.nvim_create_namespace("claudecode_inline_diff")
 --- so it always stays open showing the file whose changes were reviewed.
 local CLAUDE_BUFFER_NAME = "ClaudeCodeBuffer"
 
+--- Bumped whenever a reveal starts or the diff is torn down, so any in-flight
+--- streaming animation stops and does not mutate the buffer. Each call to
+--- `render_diff_buffer_streamed` captures the current value and bails out once it
+--- no longer matches, making the animation safely cancellable.
+local reveal_gen = 0
+
 ---Get the persistent ClaudeCodeBuffer, creating it on first use or resetting it for reuse.
 ---The buffer is kept alive (`bufhidden = "hide"`) so it survives window/tab closes.
 ---@return number buf The buffer handle
@@ -187,6 +193,113 @@ function M.render_diff_buffer(buf, lines, line_types)
   end
 end
 
+---@param wpm number Words per minute
+---@return number milliseconds per character
+local function wpm_to_ms_per_char(wpm)
+  return (60.0 / wpm / 5.0) * 1000.0
+end
+
+--- Progressively reveal `lines` in `buf` with a natural "typing" cadence.
+---
+--- The reveal is *incremental*: each tick advances by `chars_per_tick` characters,
+--- appends only the new tail to the buffer (never rewriting earlier lines), and
+--- adds extmarks only for lines that just became fully revealed. This keeps the
+--- work O(n) in the number of lines instead of O(n²), and because earlier lines
+--- and their marks are never touched, they stay correctly positioned.
+---@param buf number Buffer handle
+---@param lines string[] Full diff lines (source of truth)
+---@param line_types string[] Parallel type array
+---@param opts table|nil { delay_ms:number, chars_per_tick:number }
+local function render_diff_buffer_streamed(buf, lines, line_types, opts)
+  opts = opts or {}
+  local chars_per_tick = math.max(1, opts.chars_per_tick or 1)
+  local delay_floor_ms = math.max(0, opts.delay_ms or 0)
+
+  local full = table.concat(lines, "\n")
+  local len = #full
+  if len == 0 then
+    vim.api.nvim_buf_set_option(buf, "modifiable", false)
+    return
+  end
+
+  reveal_gen = reveal_gen + 1
+  local my_gen = reveal_gen
+
+  -- Mirror of the buffer content (1-based), mutated incrementally so we only ever
+  -- rewrite the changed tail. Earlier lines and their extmarks are never touched.
+  local buf_lines = { "" }
+  vim.api.nvim_buf_set_lines(buf, 0, -1, false, buf_lines)
+
+  local committed = 0
+  local marked_count = 0
+
+  local function reveal_up_to(target_pos)
+    target_pos = math.min(len, target_pos)
+    if target_pos <= committed then
+      return
+    end
+
+    local delta = full:sub(committed + 1, target_pos)
+    committed = target_pos
+
+    -- Append the new characters to the line mirror, opening new lines on newlines.
+    local parts = vim.split(delta, "\n", { plain = true })
+    buf_lines[#buf_lines] = buf_lines[#buf_lines] .. parts[1]
+    for k = 2, #parts do
+      buf_lines[#buf_lines + 1] = parts[k]
+    end
+
+    -- Push only the changed tail to the buffer (the previous last line plus any
+    -- newly opened lines). This preserves extmarks on earlier lines.
+    local tail_from = #buf_lines - #parts + 1
+    vim.api.nvim_buf_set_lines(buf, tail_from - 1, -1, false, vim.list_slice(buf_lines, tail_from))
+
+    -- Mark only lines that are now fully revealed and not yet marked:
+    -- a line is complete once a newline has closed it, or (at the end) the final
+    -- line regardless of termination. Cap at #line_types so a trailing empty
+    -- element (content ending in "\n") is never marked.
+    local complete_count
+    if committed >= len then
+      complete_count = (#buf_lines > 0 and buf_lines[#buf_lines] == "") and (#buf_lines - 1) or #buf_lines
+    else
+      complete_count = math.max(0, #buf_lines - 1)
+    end
+    complete_count = math.min(complete_count, #line_types)
+
+    for i = marked_count + 1, complete_count do
+      apply_line_mark(buf, i, line_types[i])
+    end
+    marked_count = complete_count
+  end
+
+  local function tick()
+    if my_gen ~= reveal_gen then
+      return
+    end
+    if not vim.api.nvim_buf_is_valid(buf) then
+      return
+    end
+    if committed >= len then
+      vim.api.nvim_buf_set_option(buf, "modifiable", false)
+      return
+    end
+
+    reveal_up_to(committed + chars_per_tick)
+
+    if committed >= len then
+      vim.api.nvim_buf_set_option(buf, "modifiable", false)
+      return
+    end
+
+    -- Natural typing cadence: randomized 400-1000 WPM, with delay_ms as a floor.
+    local wpm = math.random(400, 1000)
+    local delay = math.max(delay_floor_ms, math.floor(wpm_to_ms_per_char(wpm)))
+    vim.defer_fn(tick, delay)
+  end
+
+  tick()
+end
+
 --- Create a scratch editor window when the current tab only has terminal/sidebar windows.
 ---@return number win_id Window ID of the created scratch editor window
 local function create_fallback_editor_window()
@@ -370,9 +483,18 @@ function M.setup_inline_diff(params, resolution_callback, config)
     diff._cleanup_diff_state(name, "replaced by new diff")
   end
 
-  -- Render content + highlights (static full render).
-  M.render_diff_buffer(buf, lines, line_types)
-  vim.api.nvim_buf_set_option(buf, "modifiable", false)
+  -- Render content + highlights. Optionally reveal it with a live "typing" effect.
+  local do_stream = config and config.diff_opts and config.diff_opts.stream_reveal
+  if do_stream then
+    vim.api.nvim_buf_set_option(buf, "modifiable", true)
+    render_diff_buffer_streamed(buf, lines, line_types, {
+      delay_ms = config.diff_opts.stream_reveal_delay_ms or 0,
+      chars_per_tick = config.diff_opts.stream_reveal_chars_per_tick or 1,
+    })
+  else
+    M.render_diff_buffer(buf, lines, line_types)
+    vim.api.nvim_buf_set_option(buf, "modifiable", false)
+  end
   partial_setup.new_buffer = buf
 
   -- Buffer metadata
@@ -613,6 +735,9 @@ end
 function M.cleanup_inline_diff(tab_name, diff_data)
   local diff = require("claudecode.diff")
 
+  -- Cancel any in-flight streaming reveal so it stops mutating the buffer.
+  reveal_gen = reveal_gen + 1
+
   -- Clean up autocmds
   for _, autocmd_id in ipairs(diff_data.autocmd_ids or {}) do
     pcall(vim.api.nvim_del_autocmd, autocmd_id)