opencode-nvim-diff-review 0.3.0 → 0.4.1

package/lua/diff-review/init.lua

@@ -23,6 +23,13 @@ local M = {}
 --- Used by the cleanup hooks to avoid removing buffers the user had open.
 local pre_diffview_bufs = {}
 
+--- Pending cursor position to set after diffview finishes opening a file.
+--- DiffviewGoTo stores the target here, and the autocmd on DiffviewDiffBufWinEnter
+--- applies it. This avoids a race with diffview's async file loading which resets
+--- the cursor to line 1 after opening.
+--- @type { file: string, line: number }?
+local pending_goto = nil
+
 --- Query the current diffview state.
 --- Returns a JSON string with:
 ---   open: boolean          - whether diffview is active
@@ -131,13 +138,34 @@ function DiffviewHunks(ref)
   end
   local diff_lines = vim.fn.systemlist(diff_cmd)
   if vim.v.shell_error ~= 0 then
-    return vim.json.encode({ error = "git diff failed" })
+    local err_msg = table.concat(diff_lines, "\n")
+    return vim.json.encode({
+      error = "git diff failed: " .. (err_msg ~= "" and err_msg or "unknown error"),
+    })
   end
 
   if #diff_lines == 0 then
     return vim.json.encode({})
   end
 
+  -- Normalize hunk headers for -U0 output.
+  -- With -U0, git omits the count when it's 1 (e.g., "@@ -134 +134,4 @@"
+  -- instead of "@@ -134,1 +134,4 @@"). diffview's parser expects the
+  -- comma-separated form, so we normalize before parsing.
+  for i, line in ipairs(diff_lines) do
+    local old_spec, new_spec = line:match("^@@ %-(%S+) %+(%S+) @@")
+    if old_spec then
+      -- Ensure both sides have the ",count" format
+      if not old_spec:match(",") then
+        old_spec = old_spec .. ",1"
+      end
+      if not new_spec:match(",") then
+        new_spec = new_spec .. ",1"
+      end
+      diff_lines[i] = "@@ -" .. old_spec .. " +" .. new_spec .. " @@"
+    end
+  end
+
   -- Parse the diff using diffview's parser
   local file_diffs = vcs_utils.parse_diff(diff_lines)
 
@@ -167,15 +195,17 @@ function DiffviewHunks(ref)
   return vim.json.encode(hunks)
 end
 
---- Navigate diffview to a specific file and line number.
+--- Navigate diffview to a specific file and hunk.
 ---
 --- Finds the file in diffview's file list, switches to it if needed,
---- then moves the cursor to the specified line in the right-hand (new) buffer.
+--- positions the cursor at the hunk, and folds all other regions so only
+--- the target hunk (with a few context lines) is visible.
 ---
 --- @param file string Repo-relative file path
---- @param line number Line number to jump to (in the new version of the file)
+--- @param line_or_hunk number|table Either a line number or a hunk spec table:
+---                                   { new_start, new_count, old_start, old_count }
 --- @return string JSON-encoded result: { ok: true } or { error: string }
-function DiffviewGoTo(file, line)
+function DiffviewGoTo(file, line_or_hunk)
   local ok, lib = pcall(require, "diffview.lib")
   if not ok then
     return vim.json.encode({ error = "diffview.nvim not loaded" })
@@ -203,34 +233,28 @@ function DiffviewGoTo(file, line)
     return vim.json.encode({ error = "File not found in diffview: " .. file })
   end
 
+  -- Store the target so the autocmd can position the cursor and set up folds
+  -- after diffview finishes its async file loading.
+  local hunk_spec = type(line_or_hunk) == "table" and line_or_hunk or nil
+  local target_line = hunk_spec
+    and (hunk_spec.new_start > 0 and hunk_spec.new_start or 1)
+    or (type(line_or_hunk) == "number" and line_or_hunk or 1)
+
+  pending_goto = {
+    file = file,
+    line = target_line,
+    hunk = hunk_spec,
+  }
+
   -- Switch to the target file if it's not already the current one
   local cur_file = panel.cur_file
   if not cur_file or cur_file.path ~= file then
     view:set_file(target)
+  else
+    -- Already on the right file — apply directly
+    M._apply_pending_goto()
   end
 
-  -- Move cursor to the target line in the right-hand (new version) buffer.
-  -- The layout has windows a (left/old) and b (right/new).
-  -- We need to wait briefly for the file switch to complete, then find
-  -- the right window and set the cursor.
-  vim.schedule(function()
-    -- Find the window showing the "b" (new) side of the diff
-    local layout = target.layout
-    if layout and layout.b and layout.b.file then
-      local b_win = layout.b.win
-      if b_win and vim.api.nvim_win_is_valid(b_win.id) then
-        -- Clamp line to buffer length
-        local bufnr = layout.b.file.bufnr
-        local max_line = vim.api.nvim_buf_line_count(bufnr)
-        local target_line = math.min(math.max(line or 1, 1), max_line)
-        vim.api.nvim_win_set_cursor(b_win.id, { target_line, 0 })
-        -- Center the view on the target line
-        vim.api.nvim_set_current_win(b_win.id)
-        vim.cmd("normal! zz")
-      end
-    end
-  end)
-
   return vim.json.encode({ ok = true })
 end
 
@@ -245,6 +269,146 @@ function M.on_view_opened(view)
   end
 end
 
+--- Number of context lines to show above and below a focused hunk.
+--- This provides enough surrounding code to understand the change without
+--- overwhelming the view with unrelated code.
+local HUNK_CONTEXT = 5
+
+--- Apply a pending cursor position and hunk focus after diffview has finished
+--- loading a file. Called from the DiffviewDiffBufWinEnter autocmd and from
+--- DiffviewGoTo when the file is already displayed.
+function M._apply_pending_goto()
+  if not pending_goto then return end
+
+  local target_line = pending_goto.line
+  local hunk = pending_goto.hunk
+  pending_goto = nil
+
+  -- Small delay to ensure diffview's own cursor positioning (which resets to
+  -- line 1 on file_open_new) has completed before we override it.
+  vim.defer_fn(function()
+    local ok, lib = pcall(require, "diffview.lib")
+    if not ok then return end
+
+    local view = lib.get_current_view()
+    if not view then return end
+
+    local layout = view.cur_layout
+    if not layout then return end
+
+    -- Get the main window (right-hand / "b" side in a 2-way diff)
+    local main_win = layout:get_main_win()
+    if not main_win or not main_win.id or not vim.api.nvim_win_is_valid(main_win.id) then
+      return
+    end
+
+    local main_file = main_win.file
+    if not main_file or not main_file.bufnr or not vim.api.nvim_buf_is_loaded(main_file.bufnr) then
+      return
+    end
+
+    -- Position cursor at the hunk
+    local max_line = vim.api.nvim_buf_line_count(main_file.bufnr)
+    local line = math.min(math.max(target_line or 1, 1), max_line)
+    vim.api.nvim_win_set_cursor(main_win.id, { line, 0 })
+    vim.api.nvim_set_current_win(main_win.id)
+
+    -- Set up hunk-focus folds if we have hunk boundaries
+    if hunk then
+      M._apply_hunk_focus(view, hunk)
+    end
+
+    vim.cmd("normal! zz")
+  end, 50)
+end
+
+--- Create folds that hide everything except the target hunk and a few
+--- context lines around it. Switches both diff windows to foldmethod=manual.
+---
+--- @param view table The current DiffView
+--- @param hunk table Hunk spec: { new_start, new_count, old_start, old_count }
+function M._apply_hunk_focus(view, hunk)
+  local layout = view.cur_layout
+  if not layout then return end
+
+  -- Compute the visible range for each side (old = "a", new = "b").
+  -- layout.a and layout.b are Window objects with .id and .file properties.
+  -- A hunk with count=0 means pure insertion/deletion — show context around
+  -- the start line instead.
+  local sides = {}
+
+  -- "b" side (new/right) — uses new_start/new_count
+  if layout.b and layout.b.file and layout.b.file.bufnr
+    and vim.api.nvim_buf_is_loaded(layout.b.file.bufnr)
+  then
+    local lcount = vim.api.nvim_buf_line_count(layout.b.file.bufnr)
+    local hunk_first = hunk.new_start > 0 and hunk.new_start or 1
+    local hunk_last = hunk.new_count > 0 and (hunk.new_start + hunk.new_count - 1) or hunk_first
+    table.insert(sides, {
+      win_id = layout.b.id,
+      lcount = lcount,
+      hunk_first = hunk_first,
+      hunk_last = hunk_last,
+    })
+  end
+
+  -- "a" side (old/left) — uses old_start/old_count
+  if layout.a and layout.a.file and layout.a.file.bufnr
+    and vim.api.nvim_buf_is_loaded(layout.a.file.bufnr)
+  then
+    local lcount = vim.api.nvim_buf_line_count(layout.a.file.bufnr)
+    local hunk_first = hunk.old_start > 0 and hunk.old_start or 1
+    local hunk_last = hunk.old_count > 0 and (hunk.old_start + hunk.old_count - 1) or hunk_first
+    table.insert(sides, {
+      win_id = layout.a.id,
+      lcount = lcount,
+      hunk_first = hunk_first,
+      hunk_last = hunk_last,
+    })
+  end
+
+  for _, side in ipairs(sides) do
+    if vim.api.nvim_win_is_valid(side.win_id) then
+      vim.api.nvim_win_call(side.win_id, function()
+        -- Switch to manual folds so we have full control
+        vim.wo.foldmethod = "manual"
+        vim.wo.foldenable = true
+
+        -- Show absolute line numbers so the user can correlate with the
+        -- hunk header line ranges (e.g. @@ -273,1 +273,3 @@)
+        vim.wo.number = true
+        vim.wo.relativenumber = false
+
+        -- Override the Folded highlight in this window so fold lines don't
+        -- look like diff modifications. Uses winhl to scope it to this window.
+        local existing_winhl = vim.wo.winhl or ""
+        if not existing_winhl:match("Folded:") then
+          vim.wo.winhl = existing_winhl
+            .. (existing_winhl ~= "" and "," or "")
+            .. "Folded:DiffviewDiffFoldedReview"
+        end
+
+        -- Remove all existing folds
+        pcall(vim.cmd, "normal! zE")
+
+        -- Visible range: hunk lines + context
+        local vis_first = math.max(1, side.hunk_first - HUNK_CONTEXT)
+        local vis_last = math.min(side.lcount, side.hunk_last + HUNK_CONTEXT)
+
+        -- Create fold above the visible range
+        if vis_first > 1 then
+          vim.cmd(string.format("1,%dfold", vis_first - 1))
+        end
+
+        -- Create fold below the visible range
+        if vis_last < side.lcount then
+          vim.cmd(string.format("%d,%dfold", vis_last + 1, side.lcount))
+        end
+      end)
+    end
+  end
+end
+
 --- Diffview hook: called when a diff view is closed.
 --- Cleans up buffers that diffview created but the user didn't have open before.
 --- - diffview:// internal buffers are always removed
@@ -289,6 +453,20 @@ function M.setup(opts)
   _G.DiffviewHunks = DiffviewHunks
   _G.DiffviewGoTo = DiffviewGoTo
 
+  -- Define a neutral highlight for fold lines in hunk-focus mode.
+  -- Links to Comment by default so folds look like muted separators
+  -- rather than diff modifications. Users can override this.
+  vim.api.nvim_set_hl(0, "DiffviewDiffFoldedReview", { link = "Comment", default = true })
+
+  -- Listen for diffview's DiffviewDiffBufWinEnter autocmd to apply pending
+  -- cursor positions after async file loading completes.
+  vim.api.nvim_create_autocmd("User", {
+    pattern = "DiffviewDiffBufWinEnter",
+    callback = function()
+      M._apply_pending_goto()
+    end,
+  })
+
   -- Configure diffview hooks
   local dv_ok, diffview = pcall(require, "diffview")
   if not dv_ok then

package/opencode-plugin/index.ts

@@ -105,22 +105,28 @@ const discoverNvimSocket = async (): Promise<string | null> => {
 
 // --- Helpers ---
 
+const STATUS_LABELS: Record<string, string> = {
+  M: "modified",
+  A: "added",
+  D: "deleted",
+  R: "renamed",
+  C: "copied",
+  T: "type-changed",
+}
+
 const statusLabel = (status: string | undefined): string =>
-  status === "M" ? "modified" :
-  status === "A" ? "added" :
-  status === "D" ? "deleted" :
-  status === "R" ? "renamed" :
-  status ?? "changed"
+  (status && STATUS_LABELS[status]) ?? "changed"
 
 const formatHunkPosition = (): string => {
   if (reviewQueue.length === 0) return "No review in progress."
   const item = reviewQueue[reviewPosition]
-  return `Reviewing: ${item.file} (${statusLabel(item.status)}) ${item.header} — item ${reviewPosition + 1} of ${reviewQueue.length}.`
+  const fileCount = new Set(reviewQueue.map(h => h.file)).size
+  return `Reviewing: ${item.file} (${statusLabel(item.status)}) ${item.header} — item ${reviewPosition + 1} of ${reviewQueue.length} across ${fileCount} file${fileCount === 1 ? "" : "s"}.`
 }
 
 /**
  * Match an order item from the agent to a hunk in the available hunks list.
- * Identity is {file, old_start, new_start}.
+ * A hunk is uniquely identified by {file, old_start, old_count, new_start, new_count}.
  */
 const findHunk = (
   hunks: HunkItem[],
@@ -135,6 +141,26 @@ const findHunk = (
       h.new_count === orderItem.new_count
   )
 
+/**
+ * Format a summary of the files covered in the review queue.
+ */
+const formatQueueSummary = (queue: HunkItem[]): string => {
+  const fileGroups = new Map<string, { status: string; count: number }>()
+  for (const item of queue) {
+    const existing = fileGroups.get(item.file)
+    if (existing) {
+      existing.count++
+    } else {
+      fileGroups.set(item.file, { status: item.status, count: 1 })
+    }
+  }
+  const lines = Array.from(fileGroups.entries()).map(
+    ([file, { status, count }]) =>
+      `  ${file} (${statusLabel(status)}) — ${count} hunk${count === 1 ? "" : "s"}`
+  )
+  return `\nFiles in review:\n${lines.join("\n")}`
+}
+
 // --- Plugin ---
 
 export const DiffReviewPlugin: Plugin = async (ctx) => {
@@ -258,15 +284,16 @@ export const DiffReviewPlugin: Plugin = async (ctx) => {
 
           const goToHunk = async (item: HunkItem): Promise<void> => {
             const file = item.file.replace(/"/g, '\\"')
-            // Navigate to the new_start line (the line in the new version)
-            const line = item.new_start > 0 ? item.new_start : 1
+            // Pass hunk boundaries so Lua can set up folds to focus on this hunk
+            const hunkSpec = `{new_start=${item.new_start},new_count=${item.new_count},old_start=${item.old_start},old_count=${item.old_count}}`
             const raw = await nvimExpr(
-              `luaeval("DiffviewGoTo('${file}', ${line})")`
+              `luaeval("DiffviewGoTo('${file}', ${hunkSpec})")`
             )
             const result = JSON.parse(raw.trim())
             if (result.error) throw new Error(result.error)
-            // Give diffview time to switch files and position the cursor
-            await Bun.sleep(300)
+            // Give diffview time to switch files and the Lua side to
+            // position cursor and set up folds
+            await Bun.sleep(500)
           }
 
           try {
@@ -353,7 +380,8 @@ export const DiffReviewPlugin: Plugin = async (ctx) => {
 
                 return `Started review with ${reviewQueue.length} item${reviewQueue.length === 1 ? "" : "s"}` +
                   (ref ? ` (comparing against ${ref})` : " (uncommitted changes vs HEAD)") +
-                  `. ${formatHunkPosition()}`
+                  `. ${formatHunkPosition()}` +
+                  formatQueueSummary(reviewQueue)
               }
 
               case "next": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-nvim-diff-review",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "Agent-driven guided code review for Neovim + OpenCode",
   "main": "opencode-plugin/index.ts",
   "keywords": [