[mini.files] Git status and symlinks

[drowning-cat]

Related

• https://gist.github.com/bassamsdata/eec0a3065152226581f8d4244cce9051
• [mini.files] Async Gitignore with Caching & Prefetching for Large Repos #2265

Description

The idea is to add yet another status display for mini.files.

It supports multiple git repositories and lazy fetching. It does not include a git watcher, but it can be refreshed via MiniFiles.synchronize, which is mapped to = by default.

Recipes

Integrate keymaps

---@class MiniFilesItem
---@field fs_type "file"|"directory"
---@field name string
---@field path string
---@field lnum integer
---@field line string

---@return MiniFilesItem[], MiniFilesItem?
local get_selected = function()
  local mode = vim.api.nvim_get_mode().mode
  local row = vim.api.nvim_win_get_cursor(0)[1]
  local min_row, max_row = row, row
  if mode:match("[vV\22]") then
    local visual_row = vim.fn.line("v")
    min_row, max_row = math.min(row, visual_row), math.max(row, visual_row)
  end
  local selected, current = {}, nil
  for lnum = min_row, max_row do
    local fs_entry = MiniFiles.get_fs_entry(0, lnum)
    if fs_entry then
      local item = vim.tbl_extend("keep", fs_entry, {
        lnum = lnum,
        line = vim.api.nvim_buf_get_lines(0, lnum - 1, lnum, true)[1],
      })
      table.insert(selected, item)
      if lnum == row then
        current = item
      end
    end
  end
  return selected, current
end

local get_selected_paths = function()
  local selected = get_selected()
  local selected_paths = vim.tbl_map(function(sel)
    return sel.path
  end, selected)
  return selected_paths, selected
end

local get_branch = function(buf)
  buf = buf or 0
  local buf_name = vim.api.nvim_buf_get_name(buf)
  return string.match(buf_name, "^minifiles://%d+/(.*)")
end

local try_synchronize = function()
  local confirm = vim.fn.confirm
  vim.fn.confirm = function() ---@diagnostic disable-line: duplicate-set-field
    return 3
  end
  local ok = MiniFiles.synchronize()
  vim.fn.confirm = confirm
  return ok
end

local git_run = function(buf, cmd)
  if not try_synchronize() then
    vim.notify("(mini.files) Git command skipped. Synchronize first", vim.log.levels.WARN)
    return
  end
  vim.system(cmd, { cwd = get_branch(buf) }, function(out)
    vim.schedule(function()
      if string.match(vim.api.nvim_get_mode().mode, "[vV\22]") then
        vim.api.nvim_input("<Esc>")
      end
      if out.code == 0 then
        try_synchronize()
      end
    end)
  end)
end

local get_entry_status = function(buf, lnum)
  assert(MiniFilesStatus and MiniFilesStatus.get_status, "`MiniFilesStatus.get_status` is not available")
  local fs_entry = MiniFiles.get_fs_entry(buf, lnum)
  if not fs_entry then
    return nil
  end
  return MiniFilesStatus.get_status(fs_entry.path), fs_entry
end

local get_status_codes = function(status)
  if not status then
    return {}
  end
  local status_codes = {}
  vim.list_extend(status_codes, { status.status })
  vim.list_extend(status_codes, vim.tbl_values(status.children or {}))
  return status_codes
end

-- API

local git_toggle_stage = function()
  local selected_paths, selected = get_selected_paths()
  local all_staged = vim.iter(selected):all(function(sel)
    local status = get_entry_status(0, sel.lnum)
    if not status then
      return true
    end
    local status_codes = get_status_codes(status)
    return vim.iter(status_codes):all(function(xy)
      return xy and string.sub(xy, 1, 1) ~= " " and xy ~= "??"
    end)
  end)
  if all_staged then
    git_run(0, { "git", "restore", "--staged", unpack(selected_paths) })
  else
    git_run(0, { "git", "add", unpack(selected_paths) })
  end
end

local git_restore = function()
  local selected_paths = get_selected_paths()
  git_run(0, { "git", "restore", unpack(selected_paths) })
end

local git_goto = function(dir)
  local lnum_count = vim.api.nvim_buf_line_count(0)
  local row, col = unpack(vim.api.nvim_win_get_cursor(0))
  local where = {
    next = { row + 1, lnum_count, 1 },
    prev = { row - 1, 1, -1 },
    first = { 1, lnum_count, 1 },
    last = { lnum_count, 1, -1 },
  }
  local conf = assert(where[dir], "Unknown `dir`: " .. tostring(dir))
  for i = conf[1], conf[2], conf[3] do
    local fs_entry = MiniFiles.get_fs_entry(0, i)
    if fs_entry then
      local status = get_entry_status(0, i)
      if status then
        vim.api.nvim_win_set_cursor(0, { i, col })
        return
      end
    end
  end
end

vim.api.nvim_create_autocmd("User", {
  pattern = "MiniFilesBufferCreate",
  desc = "Define `mini.files` buffer keymaps",
  group = au,
  callback = function(e)
    local buf_map = function(modes, lhs, rhs, opts) ---@param opts? vim.keymap.set.Opts
      opts = opts or {}
      opts.buf = e.data.buf_id
      vim.keymap.set(modes, lhs, rhs, opts)
    end
    -- stylua: ignore start
    buf_map({ "n", "x" }, "gh", function() git_toggle_stage() end, { desc = "Git stage/unstage" })
    buf_map({ "n", "x" }, "gH", function() git_restore() end, { desc = "Git restore" })
    buf_map({ "n", "x" }, "[h", function() git_goto("prev") end, { desc = "Git goto previous" })
    buf_map({ "n", "x" }, "]h", function() git_goto("next") end, { desc = "Git goto next" })
    buf_map({ "n", "x" }, "[H", function() git_goto("first") end, { desc = "Git goto first" })
    buf_map({ "n", "x" }, "]H", function() git_goto("last") end, { desc = "Git goto last" })
  end,
})

Code

Put the code in <config>/plugin/minifiles_status.lua.

Code (version 8)

-- See https://github.com/nvim-mini/mini.nvim/discussions/2391
local MiniFiles = require("mini.files")

local au_status = vim.api.nvim_create_augroup("minifiles_status", { clear = true })
local ns_git = vim.api.nvim_create_namespace("minifiles_status_git")
local ns_sym = vim.api.nvim_create_namespace("minifiles_status_sym")

local get_fs_items = function(buf)
  local buf_lines = vim.api.nvim_buf_get_lines(buf, 0, -1, true)
  local fs_items = {}
  for lnum, line in ipairs(buf_lines) do
    local fs_entry = MiniFiles.get_fs_entry(buf, lnum)
    if fs_entry then
      table.insert(fs_items, { lnum = lnum, line = line, fs_entry = fs_entry })
    end
  end
  return fs_items
end

---@param opts vim.api.keyset.set_extmark
local set_extmark = function(buf, ns, start_row, start_col, opts)
  opts = vim.tbl_extend("keep", opts, {
    invalidate = true, -- NOTE: hide if its range is deleted
    end_row = start_row,
    end_col = start_col,
    strict = false,
    hl_mode = "combine",
  })
  vim.api.nvim_buf_set_extmark(buf, ns, start_row, start_col, opts)
end

-- Symlinks

local render_sym = function(buf)
  vim.api.nvim_buf_clear_namespace(buf, ns_sym, 0, -1)
  local fs_items = get_fs_items(buf)
  for _, item in ipairs(fs_items) do
    local lnum, fs_entry = item.lnum, item.fs_entry
    local fs_link = vim.uv.fs_readlink(fs_entry.path)
    if fs_link then
      local fs_stat = vim.uv.fs_stat(fs_entry.path)
      set_extmark(buf, ns_sym, lnum - 1, -1, {
        end_row = lnum, -- NOTE: Set to the next line to preserve it during inline edits
        end_col = 0,
        virt_text_pos = "overlay",
        virt_text = {
          { " → ", "NonText" },
          { vim.fn.pathshorten(fs_link), fs_stat and "NonText" or "ErrorMsg" },
        },
      })
    end
  end
end

vim.api.nvim_create_autocmd("User", {
  pattern = "MiniFilesBufferUpdate",
  group = au_status,
  desc = "Update `mini.files` symlinks",
  callback = function(e)
    render_sym(e.data.buf_id)
  end,
})

-- Git status

local get_branch = function(buf)
  local buf_name = vim.api.nvim_buf_get_name(buf)
  local branch = string.match(buf_name, "^minifiles://%d+/(.*)")
  if not branch then
    return
  end
  return vim.fs.normalize(branch)
end

local find_branch_root = function(branch_buf)
  local branch = get_branch(branch_buf)
  if not branch then
    return
  end
  local git_root = vim.fs.root(branch, ".git")
  if not git_root then
    return
  end
  return vim.fs.normalize(git_root)
end

local get_status = function(path, status_map)
  local status = status_map[path] or status_map[path .. "/"]
  if status then
    return status
  end
  -- NOTE: Check if inside an untracked folder
  for dir in vim.fs.parents(path) do
    status = status_map[dir .. "/"]
    if status then
      return status, dir
    end
  end
  return nil
end

local get_descendant_statuses = function(path, status_map)
  local child_statuses = {}
  for map_path, map_status in pairs(status_map) do
    local rel = vim.fs.relpath(path, map_path)
    if rel and rel ~= "." then
      child_statuses[map_path] = map_status
    end
  end
  return child_statuses
end

local get_deleted_items = function(buf, fs_items, status_map)
  local fs_entries = vim.tbl_map(function(item)
    return item.fs_entry
  end, fs_items)
  local is_deleted = function(status)
    return string.match(status, "D")
  end
  local branch = assert(get_branch(buf))
  local is_child = function(path)
    return vim.fs.dirname(path) == branch
  end
  for map_path, map_status in pairs(status_map) do
    if is_deleted(map_status) and is_child(map_path) then
      table.insert(fs_entries, {
        fs_type = "file",
        name = vim.fs.basename(map_path),
        path = map_path,
      })
    end
  end
  fs_entries = MiniFiles.config.content.sort(fs_entries)
  local deleted_items = {}
  local filter = MiniFiles.config.content.filter
  for lnum, fs_entry in ipairs(fs_entries) do
    local status = status_map[fs_entry.path]
    if status and is_deleted(status) and filter(fs_entry) then
      table.insert(deleted_items, {
        lnum = lnum - #deleted_items,
        fs_entry = fs_entry,
        status = status,
      })
    end
  end
  return deleted_items
end

-- -- Renderer

local get_status_hl = function(xy)
  local x, y = string.sub(xy, 1, 1), string.sub(xy, 2, 2)
  if xy == "??" or xy == "!!" then -- Untracked, ignored
    return "NonText"
  elseif string.match(xy, "U") or xy == "AA" or xy == "DD" then -- Unmerged (conflict)
    return "DiagnosticError"
  elseif y == "D" then -- Unstaged: deleted
    return "DiagnosticError"
  elseif string.match(y, "[MTRC]") then -- Unstaged: modified/type-changed/renamed/copied
    return "DiagnosticWarn"
  elseif string.match(x, "[RC]") then -- Staged: renamed/copied
    return "DiagnosticHint"
  elseif string.match(x, "[AMTD]") then -- Staged: added/modified/type-changed/deleted
    return "DiagnosticOk"
  end
  return "Normal"
end

local get_entry_style = function(fs_entry, status_map)
  local path, fs_type = fs_entry.path, fs_entry.fs_type
  local own_status, _ = get_status(path, status_map)
  if own_status then
    return nil, get_status_hl(own_status)
  end
  if fs_type == "directory" then
    local child_statuses = get_descendant_statuses(path, status_map)
    if vim.tbl_isempty(child_statuses) then
      return nil, nil
    end
    local statuses = vim.tbl_values(child_statuses)
    -- NOTE: Group by color
    local first_hl = get_status_hl(statuses[1])
    local all_same = vim.iter(statuses):all(function(s)
      return get_status_hl(s) == first_hl
    end)
    local merge_hl = all_same and first_hl or get_status_hl(" M")
    local count = #statuses
    return (count > 99 and "99+" or count), merge_hl
  end
  return nil, nil
end

local refresh_deleted = function(branch_win, fs_items)
  fs_items = fs_items or {}
  local buf = vim.api.nvim_win_get_buf(branch_win)
  local lnum_count = vim.api.nvim_buf_line_count(buf)
  vim.api.nvim_win_set_height(branch_win, lnum_count + #fs_items)
  local topfill = vim.iter(fs_items):fold(0, function(acc, del)
    return del.lnum == 1 and acc + 1 or acc
  end)
  vim.api.nvim_win_call(branch_win, function()
    vim.fn.winrestview({ topfill = topfill })
  end)
end

---@param buf integer
---@param status_map table<string, string>
local render_git = function(buf, status_map)
  if not vim.api.nvim_buf_is_valid(buf) then
    return
  end
  vim.api.nvim_buf_clear_namespace(buf, ns_git, 0, -1)
  local fs_items = get_fs_items(buf)
  -- NOTE: 1. Display deleted entries as virtual lines
  local git_deleted = get_deleted_items(buf, fs_items, status_map)
  local prefix = MiniFiles.config.content.prefix
  for _, del_item in ipairs(git_deleted) do
    local lnum, status, fs_entry = del_item.lnum, del_item.status, del_item.fs_entry
    local status_hl = get_status_hl(status)
    local name_hl = fs_entry.fs_type == "file" and { status_hl, "@markup.strikethrough" } or status_hl
    set_extmark(buf, ns_git, lnum - 1, 0, {
      invalidate = false,
      virt_lines_above = true,
      virt_lines_overflow = "scroll",
      virt_lines = {
        { { prefix(fs_entry) }, { fs_entry.name, name_hl } },
      },
    })
  end
  -- HACK: Used to adjust the window height. See `MiniFilesWindowUpdate` below
  vim.b[buf].git_deleted = git_deleted
  for _, win in ipairs(vim.fn.win_findbuf(buf)) do
    refresh_deleted(win, git_deleted)
  end
  -- NOTE: 2. Display git status for visible entries
  for _, item in ipairs(fs_items) do
    local icon, hl_group = get_entry_style(item.fs_entry, status_map)
    local lnum, line = item.lnum, item.line
    if icon then
      local icon_text = string.gsub(icon, " ", "·")
      set_extmark(buf, ns_git, lnum - 1, 0, {
        virt_text = { { icon_text, hl_group } },
        virt_text_pos = "eol_right_align",
      })
    end
    if hl_group then
      -- NOTE: Start highlighting after the icon.
      --       Include `/` to keep the extmark when the first character is deleted
      local name_pos = string.match(line, "/.-/.-()/") -- /01/󰈔 /<name>
      if name_pos then
        set_extmark(buf, ns_git, lnum - 1, name_pos - 1, {
          end_row = lnum,
          end_col = 0,
          hl_group = hl_group,
        })
      end
    end
  end
end

-- -- GitStatus

local GitStatus = {}

---@class RootState
---@field map table<string, string>
---@field subs fun(state: self, out: vim.SystemCompleted)[]
---@field updated_at integer
---@field expires_at integer
---@field error? vim.SystemCompleted

---@type table<string, RootState>
GitStatus.store = {}

GitStatus.ttl = math.huge -- disabled; seconds
GitStatus.cleanup_keep = 3

GitStatus._parse_porcelain = function(git_root, stdout)
  local status_map = {}
  local chunk_list = vim.split(stdout, "%z")
  local i = 1
  while i <= #chunk_list do
    local chunk = chunk_list[i]
    -- NOTE: Path is relative to the git repository
    local status, rel_path = string.match(chunk, "^(..) (.*)")
    if status and rel_path then
      -- NOTE: Windows: "a\foo\", "\bar" => "a/foo/bar"
      local abs_path = vim.fs.joinpath(git_root, rel_path)
      status_map[abs_path] = status
      -- NOTE: Rename/copy entries are followed by an additional original path
      if string.match(status, "[RC]") then
        i = i + 1
      end
    end
    i = i + 1
  end
  return status_map
end

GitStatus.query = function(git_root, on_done)
  git_root = vim.fs.normalize(git_root)
  local state = GitStatus.store[git_root]
  if not state then
    state = { map = {}, subs = {}, updated_at = -1, expires_at = -1 }
    GitStatus.store[git_root] = state
  end
  local is_fetching = not vim.tbl_isempty(state.subs)
  if is_fetching then
    -- NOTE: Coalesce identical requests into a single `vim.system` call
    table.insert(state.subs, on_done)
    return
  end
  state.subs = { on_done }
  -- WARN: Untracked directories end with `/`; files inside are not reported
  local sys = vim.system({ "git", "status", "--ignored", "--porcelain", "--null" }, { cwd = git_root }, function(out)
    vim.schedule(function()
      local subs = state.subs
      state.subs = {}
      if out.code == 0 and out.stdout then
        local status_map = GitStatus._parse_porcelain(git_root, out.stdout)
        -- NOTE: Manually include the `.git` directory in case it's used
        status_map[vim.fs.joinpath(git_root, ".git/")] = "!!"
        state.map = status_map
        state.updated_at = os.time()
        state.expires_at = state.updated_at + GitStatus.ttl
        state.error = nil
      else
        state.error = out
        vim.notify("Git status failed: " .. (out.stderr or ""), vim.log.levels.WARN)
      end
      for _, cb in ipairs(subs) do
        cb(state, out)
      end
    end)
  end)
  return sys
end

-- NOTE: Call `GitStatus.query` separately to refresh the data
GitStatus.get_cached = function(git_root)
  git_root = vim.fs.normalize(git_root)
  local state = vim.deepcopy(GitStatus.store[git_root])
  if not state then
    return nil, false
  end
  local is_fresh = os.time() < state.expires_at
  return state, is_fresh
end

GitStatus.expire = function()
  for _, state in pairs(GitStatus.store) do
    state.expires_at = -1
  end
end

GitStatus.prune = function(keep_count)
  keep_count = keep_count or GitStatus.cleanup_keep or 0
  local roots = vim.tbl_keys(GitStatus.store)
  if #roots <= keep_count then
    return
  end
  -- NOTE: Keep the latest N entries
  table.sort(roots, function(a, b)
    return GitStatus.store[a].updated_at > GitStatus.store[b].updated_at
  end)
  for i = keep_count + 1, #roots do
    GitStatus.store[roots[i]] = nil
  end
end

-- -- MiniFilesStatus

_G.MiniFilesStatus = {} -- NOTE: Public API

MiniFilesStatus.get_status = function(path)
  path = vim.fs.normalize(path)
  local status, source, children
  local outer_root = vim.iter(vim.fs.parents(path)):find(function(dir)
    return GitStatus.store[dir] ~= nil
  end)
  local outer_state = outer_root and GitStatus.get_cached(outer_root)
  if outer_state then
    status, source = get_status(path, outer_state.map)
  end
  local inner_state = GitStatus.store[path] and GitStatus.get_cached(path) or outer_state
  children = inner_state and get_descendant_statuses(path, inner_state.map) or {}
  if not status and vim.tbl_isempty(children) then
    return nil
  end
  return {
    status = status,
    source = source,
    children = children,
  }
end

local get_rooted_branches = function(filter_root)
  local rooted_branches = {}
  for _, buf in ipairs(vim.api.nvim_list_bufs()) do
    local buf_root = find_branch_root(buf)
    if buf_root and (filter_root == nil or filter_root == buf_root) then
      rooted_branches[buf] = buf_root
    end
  end
  return rooted_branches
end

MiniFilesStatus.update = function(git_root) ---@param git_root? string
  for buf, buf_root in pairs(get_rooted_branches(git_root)) do
    GitStatus.query(buf_root, function(state)
      render_git(buf, state.map)
    end)
  end
end

-- -- Setup

vim.api.nvim_create_autocmd("User", {
  pattern = "MiniFilesWindowUpdate",
  group = au_status,
  desc = "Adjust `mini.files` window to fit git deleted entries",
  callback = function(e)
    local win, buf = e.data.win_id, e.data.buf_id
    local git_deleted = vim.b[buf].git_deleted or {}
    refresh_deleted(win, git_deleted)
  end,
})

local update_buf_status = function(buf, force)
  local git_root = find_branch_root(buf)
  if not git_root then
    return
  end
  local is_new = vim.b[buf].git_root == nil
  vim.b[buf].git_root = git_root
  -- NOTE: Stale-while-revalidate: render now, refresh later
  local cached, is_fresh = GitStatus.get_cached(git_root)
  if cached then
    render_git(buf, cached.map)
  end
  -- NOTE: Avoid a redundant query after `go_in`
  if not force and is_new and is_fresh then
    return
  end
  GitStatus.query(git_root, function(state)
    render_git(buf, state.map)
  end)
end

vim.api.nvim_create_autocmd("User", {
  pattern = "MiniFilesBufferUpdate",
  group = au_status,
  desc = "Update/render `mini.files` git status",
  callback = function(e)
    update_buf_status(e.data.buf_id)
  end,
})

vim.api.nvim_create_autocmd("User", {
  pattern = "MiniGitUpdated",
  group = au_status,
  desc = "Synchronize `mini.files` git status after `mini.git` updates",
  callback = function(e)
    local MiniGit = require("mini.git")
    local git_root = (MiniGit.get_buf_data(e.buf) or {}).root
    if not git_root then
      return
    end
    MiniFilesStatus.update(git_root)
  end,
})

vim.api.nvim_create_autocmd("FocusGained", {
  group = au_status,
  desc = "Synchronize `mini.files` git status after gaining focus",
  callback = function()
    MiniFilesStatus.update()
  end,
})

vim.api.nvim_create_autocmd("User", {
  pattern = "MiniFilesExplorerClose",
  group = au_status,
  desc = "Clean up `mini.files` git status",
  callback = function()
    GitStatus.prune()
    -- NOTE: Force statuses to refresh when reopening
    GitStatus.expire()
  end,
})

[echasnovski]

Thanks for sharing!

I've looked quickly through the code. There are some areas that I either don't fully understand or can be improved, like the intention of local after_icon = string.match(line, "/.-/.-()/") or updating only if number of lines has changed in autocommand for TextChanged.

But the main concern is that this monkey patches MiniFiles.synchronize which I'd not recommend. The comment says synchronize clears all extmarks and triggers MiniFilesBufferUpdate. But 1) it doesn't clear all extmarks, it calls nvim_buf_set_lines() which "squashes" all extmarks as they react to text change; 2) if there is a relevant event trigger, why there is a need to monkey-patch?

[antoniorodr]

Is this then still not recommended?

For now I am using this "dummy solution" to grey out the files which are not tracked by git.

local function getVisibleSet(path)
	local gitRoot = vim.fs.root(path, { ".git" })
	if not gitRoot then
		return true
	end
	if visibleCache[gitRoot] then
		return visibleCache[gitRoot]
	end
	local tracked = vim.fn.system({ "git", "-C", gitRoot, "ls-files" })
	local untracked = vim.fn.system({ "git", "-C", gitRoot, "ls-files", "--others", "--exclude-standard" })
	if vim.v.shell_error ~= 0 then
		return nil
	end
	local set = {}
	local function add(line)
		local p = vim.fs.normalize(gitRoot .. "/" .. line)
		set[p] = true
		while p ~= gitRoot do
			p = vim.fs.dirname(p)
			set[p] = true
		end
	end
	for line in vim.gsplit(tracked, "\n", { plain = true, trimempty = true }) do
		add(line)
	end
	for line in vim.gsplit(untracked, "\n", { plain = true, trimempty = true }) do
		add(line)
	end
	visibleCache[gitRoot] = set
	return set
end

local function isIgnored(path, visibleSet)
	if visibleSet == true then
		return false
	end
	return not (visibleSet and visibleSet[vim.fs.normalize(path)])
end

I do not think this is the ideal way to do it tho, but it works.

And to show git status like the @drowning-cat solution would be great to have as well.

[echasnovski]

Is this then still not recommended?

The reasoning in the comment did not change. If the code changed (it was edited couple of days ago), then maybe they are no longer valid.

[drowning-cat]

Is this then still not recommended?

I don't think it's "not recommended" in the sense that it shouldn't be used. It's more about the quality of the implementation. The earlier versions were indeed very poorly written, especially the TextChanged part and the overall workflow, which is quite unintuitive. Even now, there are still a few crucial bugs I hope to fix soon.

If I remember correctly, I originally used monkey patching because the cursor was getting reset for some reason (probably my fault), and MiniFilesBufferUpdate was fired when a folder was opened for the first time, which also helped avoid a few unnecessary requests for git roots that had already been fetched.

Maybe I'll ask for another review once I reach Version 6. By then, the code should at least be working properly.

[drowning-cat]

@echasnovski,

Maybe I'll ask for another review once again. By then, the code should at least be working properly.

Sorry to bother you again. If you have some free time, could you please take a quick look at Version 6?

The main reason I'm monkey-patching MiniFiles.synchronize() is to detect when synchronization is requested and force a git status refresh. Right now it looks like this:

Click me

local synchronize = MiniFiles.synchronize
MiniFiles.synchronize = function(...)
  -- NOTE: Force `is_fresh=false` before `MiniFilesBufferUpdate`
  GitStatus.expire()
  return synchronize(...)
end

vim.api.nvim_create_autocmd("User", {
  pattern = "MiniFilesBufferUpdate",
  callback = function(e)
    local buf = e.data.buf_id
    local git_root = find_root(buf)
    if not git_root then
      return
    end
    local cached, is_fresh = GitStatus.get(git_root)
    if cached then
      render_git(buf, cached.map)
    end
    if not is_fresh then
      GitStatus.query(git_root, function(state)
        render_git(buf, state.map)
      end)
    end
  end,
})

vim.api.nvim_create_autocmd("User", {
  pattern = "MiniFilesExplorerClose",
  callback = function()
    GitStatus.expire()
  end,
})

MiniFilesBufferUpdate can also be used to implement a stale-while-revalidate approach by rendering the cached status first and then refreshing it in the background. The downside is that this also triggers an unnecessary git status query every time a directory is opened for the first time (MiniFilesBufferCreate):

Click me

vim.api.nvim_create_autocmd("User", {
  pattern = "MiniFilesBufferUpdate",
  callback = function(e)
    local buf = e.data.buf_id
    local git_root = find_root(buf)
    if not git_root then
      return
    end
    -- NOTE: stale-while-revalidate
    local cached = GitStatus.get(git_root)
    if cached then
      render_git(buf, cached.map)
    end
    -- WARN: Also runs when a directory is opened for the first time
    GitStatus.query(git_root, function(state)
      render_git(buf, state.map)
    end)
  end,
})

The only alternative I could come up with is to infer whether the buffer was just created by keeping some buffer-local state, for example, initializing vim.b.minifiles_status_tick on MiniFilesBufferCreate and incrementing it on MiniFilesBufferUpdate. Then tick == 1 would mean "buffer creation", and anything after that would effectively mean "synchronization". But that feels even hackier than monkey-patching MiniFiles.synchronize().

I hope I'm not missing the elephant in the room.

[echasnovski]

I've taken a (very) quick look at Version 6. It's still quite large, so couldn't really fit quickly in my context window :)

MiniFilesBufferUpdate can also be used to implement a stale-while-revalidate approach by rendering the cached status first and then refreshing it in the background. The downside is that this also triggers an unnecessary git status query every time a directory is opened for the first time (MiniFilesBufferCreate):

If this is a problem, then my guess would be to indeed create some kind of per-buffer flag (or tick) on MiniFilesBufferCreate that would be used in MiniFilesBufferUpdate to decide if it needs to do an expensive operation. If this approach is possible, then this is probably the way I'd suggest to approach this.