Smoother Diff Resolution: Auto-jump to diffs & Auto-save after co/ct

[ChuBL]

I’ve been using Avante heavily, but I kept running into a few specific friction points that broke my flow during the "Edit -> Review -> Apply" loop:

1. Sidebar Scrolling: The sidebar always opens focused on the top line, forcing me to scroll down every time to see the latest response.
2. Lost Focus: After the AI generates a change, the cursor doesn't automatically focus on the new diff, so I have to navigate there manually.
3. Manual Save Fatigue: If I want to chain AI modifications, I have to manually accept the diff (co/ct) and then hit :w before the AI can see the new context.

After several hours of battling with Copilot, we finally managed to hack together a solution that automates this logic. It makes the review process feel much snappier.

What this script does:

• Auto-scroll: Forces the cursor to the bottom (G) whenever entering the Avante sidebar.
• Auto-jump: Automatically switches focus to the target window and triggers ]x (next conflict) immediately after generation finishes.
• Auto-save: Wraps the co (Choose Ours) and ct (Choose Theirs) keymaps to automatically trigger :w (silent write) immediately after accepting a change.

The Code:
Note: This monkey-patches avante.llm_tools.replace_in_file, so be aware that internal API changes in future Avante updates might affect it.

My behaviour config:

behaviour = {
    auto_suggestions = false,
    auto_approve_tool_permissions = {
        -- 1. Read-only / Navigation (High frequency, safe)
        "ls",
        "view",
        "glob",
        "grep",
        "read_file_toplevel_symbols",
        "read_definitions",
        "read_todos",

        -- 2. Information Retrieval (Web context)
        "web_search",
        "fetch",

        -- 3. Context & Planning (Safe internal logic)
        "add_file_to_context",
        "remove_file_from_context",
        "write_todos",

        -- 4. Computation (If restricted to pure python)
        "run_python",
    },
    -- auto_approve_tool_permissions = false,
    auto_apply_diff_after_generation = false,
    enable_cursor_planning_mode = true,
    -- minimize_diff = true,
    -- confirmation_ui_style = "popup",
    enable_fastapply = false,
    auto_focus_on_diff_view = false, -- Focus stays on code!
    auto_set_highlight_group = true,
    auto_set_keymaps = true,
    support_paste_from_clipboard = true,
},

My solution (add this to the end of avante.lua):

-----------------------------------------------------------------------
-- FIX: Force cursor to bottom when entering Avante Sidebar
-----------------------------------------------------------------------
vim.api.nvim_create_autocmd("FileType", {
    pattern = "Avante",
    callback = function()
        vim.defer_fn(function()
            pcall(vim.cmd, "normal! G")
        end, 100)
    end,
})

-----------------------------------------------------------------------
-- FEATURE 1: Auto-jump to next diff when AI generates new changes
-----------------------------------------------------------------------
local replace_in_file = require("avante.llm_tools.replace_in_file")
local original_func = replace_in_file.func

replace_in_file.func = function(input, opts)
    local is_streaming = opts.streaming == true
    local target_path = input and input.path

    local result, err = original_func(input, opts)

    -- FEATURE 1: Auto-jump when diff is complete
    if not is_streaming and target_path and result ~= false and not err then
        vim.defer_fn(function()
            local Utils = require("avante.utils")
            local target_bufnr = vim.fn.bufnr(target_path)

            if target_bufnr > 0 and vim.api.nvim_buf_is_valid(target_bufnr) then
                local target_winid = Utils.get_winid(target_bufnr)
                local filetype = vim.bo[target_bufnr].filetype

                if target_winid and vim.api.nvim_win_is_valid(target_winid) and filetype ~= "Avante" then
                    vim.api.nvim_set_current_win(target_winid)

                    local keymaps = vim.api.nvim_buf_get_keymap(target_bufnr, 'n')
                    for _, map in ipairs(keymaps) do
                        if map.lhs == ']x' and map.callback then
                            pcall(map.callback)
                            vim.defer_fn(function()
                                pcall(vim.cmd, "normal! zz")
                            end, 50)
                            break
                        end
                    end
                end
            end
        end, 300)

        -- FEATURE 2: Wrap co/ct with auto-save
        vim.defer_fn(function()
            local target_bufnr = vim.fn.bufnr(target_path)

            if target_bufnr > 0 and vim.api.nvim_buf_is_valid(target_bufnr) then
                local keymaps = vim.api.nvim_buf_get_keymap(target_bufnr, 'n')
                local co_callback, ct_callback = nil, nil

                for _, map in ipairs(keymaps) do
                    if map.lhs == 'co' and map.callback then
                        co_callback = map.callback
                    elseif map.lhs == 'ct' and map.callback then
                        ct_callback = map.callback
                    end
                end

                if co_callback then
                    vim.keymap.set('n', 'co', function()
                        co_callback()
                        vim.defer_fn(function()
                            if vim.api.nvim_buf_is_valid(target_bufnr) then
                                vim.api.nvim_buf_call(target_bufnr, function()
                                    vim.cmd("silent! write")
                                end)
                            end
                        end, 100)
                    end, { buffer = target_bufnr, silent = true, desc = "Choose ours + auto-save" })
                end

                if ct_callback then
                    vim.keymap.set('n', 'ct', function()
                        ct_callback()
                        vim.defer_fn(function()
                            if vim.api.nvim_buf_is_valid(target_bufnr) then
                                vim.api.nvim_buf_call(target_bufnr, function()
                                    vim.cmd("silent! write")
                                end)
                            end
                        end, 100)
                    end, { buffer = target_bufnr, silent = true, desc = "Choose theirs + auto-save" })
                end
            end
        end, 400)
    end

    return result, err
end