ReviewSync for diffs

Author: dglsparsons

AGENTS.md

@@ -31,6 +31,10 @@
 
 - `fetch` builds PR change blocks from local git (`git diff -w <base_sha>...<head_sha>`) instead of GitHub file patches; when commits are missing locally it attempts a targeted `git fetch` of base/head refs before failing.
 
+## Learned while implementing ReviewSync for local diffs
+
+- Store `ReviewDiff` selector options (`target`, `--cached-only`, `--uncached-only`, `--merge-base`, `--tracked-only`) on the active local review so `ReviewSync` can re-run the same diff mode instead of silently falling back to default `diff`.
+
 ## Project Overview
 
 `neo-reviewer` is a Neovim plugin for reviewing GitHub PRs. Hybrid architecture: Rust CLI for GitHub API/diff parsing, Lua plugin for UI.

doc/neo_reviewer.txt

@@ -260,11 +260,13 @@ These user commands are created when you call `setup()`.
     and pops any stashed changes.
 
 :ReviewSync                                                        *:ReviewSync*
-    Sync the current PR review with GitHub. Fetches the latest comments and
-    rebuilds diff changes from local git (same base/head commit range and
-    whitespace filtering as |:ReviewPR|). Preserves cursor position and
-    expanded change block state.
-    Only works during an active PR review (not local diff reviews).
+    Sync the current active review.
+    - During PR review: fetches latest comments/metadata from GitHub and
+      rebuilds diff changes from local git (same base/head commit range and
+      whitespace filtering as |:ReviewPR|).
+    - During local diff review: re-runs local `git diff` sourcing with the
+      same target/selector options used by |:ReviewDiff| and reapplies markers.
+    Preserves cursor position and expanded change block state when possible.
 
 ==============================================================================
 6. FUNCTIONS                                            *neo_reviewer-functions*
@@ -402,10 +404,12 @@ require("neo_reviewer").done()                                   *neo_reviewer.d
     the previous branch and pops any stashed changes.
 
 require("neo_reviewer").sync()                                   *neo_reviewer.sync()*
-    Sync the current PR review with GitHub. Re-fetches PR metadata/comments and
-    rebuilds diff changes from local git (`base...head`, `-w`). Preserves
-    cursor position, expanded change block state, and checkout state. Only
-    works during an active PR review.
+    Sync the current active review.
+    - During PR review: re-fetches PR metadata/comments and rebuilds diff
+      changes from local git (`base...head`, `-w`).
+    - During local diff review: re-runs local diff sourcing with the same
+      selection options used by |neo_reviewer.review_diff()|.
+    Preserves cursor position and expanded change block state when possible.
     See |:ReviewSync|.
 
 require("neo_reviewer").toggle_ai_feedback()     *neo_reviewer.toggle_ai_feedback()*

lua/neo_reviewer/init.lua

@@ -129,6 +129,18 @@ local function parse_review_diff_args(args)
     return opts, nil
 end
 
+---@param opts NRReviewDiffOpts
+---@return NRLocalDiffOpts
+local function to_local_diff_opts(opts)
+    return {
+        target = opts.target,
+        cached_only = opts.cached_only,
+        uncached_only = opts.uncached_only,
+        merge_base = opts.merge_base,
+        tracked_only = opts.tracked_only,
+    }
+end
+
 ---@param review NRReview
 ---@return boolean
 local function restore_previous_branch(review)
@@ -208,7 +220,7 @@ function M.setup(opts)
 
     vim.api.nvim_create_user_command("ReviewSync", function()
         M.sync()
-    end, { desc = "Sync PR review with GitHub" })
+    end, { desc = "Sync active review" })
 end
 
 ---@param url_or_number? string|integer
@@ -414,14 +426,7 @@ function M.review_diff(opts)
         return
     end
 
-    ---@type NRLocalDiffOpts
-    local diff_opts = {
-        target = opts.target,
-        cached_only = opts.cached_only,
-        uncached_only = opts.uncached_only,
-        merge_base = opts.merge_base,
-        tracked_only = opts.tracked_only,
-    }
+    local diff_opts = to_local_diff_opts(opts)
 
     vim.notify("Getting local diff...", vim.log.levels.INFO)
 
@@ -459,7 +464,7 @@ function M.review_diff(opts)
         }
 
         state.clear_review()
-        local review = state.set_local_review(filtered_data)
+        local review = state.set_local_review(filtered_data, diff_opts)
 
         local comments_file = require("neo_reviewer.ui.comments_file")
         comments_file.clear()
@@ -1115,6 +1120,75 @@ function M.sync()
         return
     end
 
+    if review.review_type == "local" then
+        local config = require("neo_reviewer.config")
+        local preserved = {
+            diff_opts = review.local_diff_opts or {},
+            expanded_changes = review.expanded_changes,
+            show_old_code = review.show_old_code,
+        }
+        local cursor_pos = vim.api.nvim_win_get_cursor(0)
+
+        vim.notify("Syncing local diff...", vim.log.levels.INFO)
+
+        cli.get_local_diff(preserved.diff_opts, function(data, err)
+            if err then
+                vim.notify("Failed to sync local diff: " .. err, vim.log.levels.ERROR)
+                return
+            end
+
+            local filtered_files, skipped_count = filter_local_diff_files(data.files, config.values.review_diff)
+
+            state.clear_review()
+
+            if #filtered_files == 0 then
+                if #data.files == 0 then
+                    vim.notify("No changes to review", vim.log.levels.WARN)
+                else
+                    vim.notify(
+                        string.format("No reviewable changes after skipping %d noise files", skipped_count),
+                        vim.log.levels.WARN
+                    )
+                end
+                return
+            end
+
+            if skipped_count > 0 then
+                vim.notify(
+                    string.format("[neo-reviewer] Skipped %d noise file(s) in local diff review", skipped_count),
+                    vim.log.levels.INFO
+                )
+            end
+
+            ---@type NRDiffData
+            local filtered_data = {
+                git_root = data.git_root,
+                files = filtered_files,
+            }
+            local new_review = state.set_local_review(filtered_data, preserved.diff_opts)
+            new_review.expanded_changes = preserved.expanded_changes
+            new_review.show_old_code = preserved.show_old_code
+
+            M.enable_overlay()
+
+            pcall(vim.api.nvim_win_set_cursor, 0, cursor_pos)
+
+            if skipped_count > 0 then
+                vim.notify(
+                    string.format(
+                        "Synced local diff (%d files changed, %d noise files skipped)",
+                        #filtered_files,
+                        skipped_count
+                    ),
+                    vim.log.levels.INFO
+                )
+            else
+                vim.notify(string.format("Synced local diff (%d files changed)", #filtered_files), vim.log.levels.INFO)
+            end
+        end)
+        return
+    end
+
     if review.review_type ~= "pr" or not review.url then
         vim.notify("Sync only works for PR reviews", vim.log.levels.WARN)
         return

lua/neo_reviewer/state.lua

@@ -92,6 +92,7 @@
 ---@field url? string PR URL (for PR reviews)
 ---@field viewer? string Current authenticated user
 ---@field git_root? string Git root directory (for local reviews)
+---@field local_diff_opts? NRLocalDiffOpts Local diff selector options used to fetch current review
 ---@field files NRFile[] Changed files
 ---@field files_by_path table<string, NRFile> Files indexed by path
 ---@field comments NRComment[] Comments on the PR
@@ -163,8 +164,9 @@ function M.set_review(review_data, git_root)
 end
 
 ---@param diff_data NRDiffData
+---@param diff_opts? NRLocalDiffOpts
 ---@return NRReview
-function M.set_local_review(diff_data)
+function M.set_local_review(diff_data, diff_opts)
     local files_by_path = {}
     for _, file in ipairs(diff_data.files) do
         if not file.change_blocks then
@@ -176,6 +178,7 @@ function M.set_local_review(diff_data)
     state.active_review = {
         review_type = "local",
         git_root = diff_data.git_root,
+        local_diff_opts = diff_opts or {},
         files = diff_data.files,
         files_by_path = files_by_path,
         comments = {},

lua/tests/plenary/state_spec.lua

@@ -532,6 +532,22 @@ describe("neo_reviewer.state", function()
             assert.are.equal(2, #review.files)
         end)
 
+        it("stores local diff selector options for sync", function()
+            local data = helpers.deep_copy(fixtures.local_diff)
+            state.set_local_review(data, {
+                target = "main",
+                cached_only = true,
+                merge_base = true,
+            })
+
+            local review = state.get_review()
+            assert.are.same({
+                target = "main",
+                cached_only = true,
+                merge_base = true,
+            }, review.local_diff_opts)
+        end)
+
         it("normalizes missing change_blocks for local review", function()
             local data = {
                 git_root = "/tmp/test-repo",

lua/tests/plenary/sync_spec.lua

@@ -18,6 +18,7 @@ describe("neo_reviewer.sync", function()
         cli = require("neo_reviewer.cli")
 
         stub(cli, "fetch_pr")
+        stub(cli, "get_local_diff")
 
         neo_reviewer = require("neo_reviewer")
 
@@ -26,6 +27,7 @@ describe("neo_reviewer.sync", function()
 
     after_each(function()
         cli.fetch_pr:revert()
+        cli.get_local_diff:revert()
 
         notifications.restore()
         state.clear_review()
@@ -42,15 +44,75 @@ describe("neo_reviewer.sync", function()
             assert.are.equal(vim.log.levels.WARN, notifs[1].level)
         end)
 
-        it("warns when trying to sync local diff review", function()
+        it("syncs local diff review by re-running diff with saved options", function()
+            state.set_local_review(mock_data.local_diff, {
+                target = "main",
+                tracked_only = true,
+            })
+
+            cli.get_local_diff.invokes(function(_, callback)
+                callback({
+                    git_root = "/tmp/test",
+                    files = {
+                        { path = "src/synced.lua", status = "modified", change_blocks = {} },
+                    },
+                }, nil)
+            end)
+
+            neo_reviewer.sync()
+
+            assert.stub(cli.get_local_diff).was_called(1)
+            assert.stub(cli.get_local_diff).was_called_with({
+                target = "main",
+                tracked_only = true,
+            }, match._)
+
+            local review = state.get_review()
+            assert.is_not_nil(review)
+            assert.are.equal("local", review.review_type)
+            assert.are.equal(1, #review.files)
+            assert.are.equal("src/synced.lua", review.files[1].path)
+        end)
+
+        it("notifies user when local diff sync is in progress", function()
             state.set_local_review(mock_data.local_diff)
 
             neo_reviewer.sync()
 
             local notifs = notifications.get()
-            assert.are.equal(1, #notifs)
-            assert.matches("Sync only works for PR reviews", notifs[1].msg)
-            assert.are.equal(vim.log.levels.WARN, notifs[1].level)
+            local found = false
+            for _, n in ipairs(notifs) do
+                if n.msg:match("Syncing local diff") then
+                    found = true
+                    break
+                end
+            end
+            assert.is_true(found, "Expected 'Syncing local diff...' notification")
+        end)
+
+        it("ends local review when sync finds no changes", function()
+            state.set_local_review(mock_data.local_diff)
+
+            cli.get_local_diff.invokes(function(_, callback)
+                callback({
+                    git_root = "/tmp/test",
+                    files = {},
+                }, nil)
+            end)
+
+            neo_reviewer.sync()
+
+            assert.is_nil(state.get_review())
+
+            local notifs = notifications.get()
+            local found = false
+            for _, n in ipairs(notifs) do
+                if n.msg:match("No changes to review") and n.level == vim.log.levels.WARN then
+                    found = true
+                    break
+                end
+            end
+            assert.is_true(found, "Expected 'No changes to review' warning")
         end)
 
         it("warns when PR review has no url", function()