[mini.pick] emulating emacs M-x find-file with a custom picker

[edisj]

hello again mini enjoyers,

I've been working on my own little plugin that handles opening persistent and ephemeral windows in the msgarea and one of the main use cases was emulating the emacs "minibuffer" with mini.pick. I wanted to see if I could create an M-x find-file picker and it turned out pretty good :).

The main behavior I wanted to capture:

• item listing comes from directory content of the head of query and is automatically updated during typing
• tab completing when current selection is a directory should send you to that directory's contents
• typing ~ or // sends you to home and root dir, but keeps a history of previously typed queries so that when you clear current query, previous query is restored
• choose when the current query doesn't match anything should :edit that query as a path
• some extmark decorations similar to ls -l columns

mini_pick_findfile_demo.mp4

Here's the code (about ~250 LOC, but a lot is just comments and styling)

local fn, fs, uv, api = vim.fn, vim.fs, vim.uv, vim.api
local pick = require("mini.pick")

---convert fs_stat size to string with units
local size_str = function(size)
  if not size then return "" end
  local KB = 1000
  local MB = KB*KB
  local GB = KB*KB*KB
  local TB = KB*KB*KB*KB
  local out = ""
  if     size < KB then out = ("%s"):format(size)
  elseif size < MB then out = ("%.1fk"):format(size / KB)
  elseif size < GB then out = ("%.1fM"):format(size / MB)
  elseif size < TB then out = ("%.1fG"):format(size / GB)
  else                  out = ("%.1fT"):format(size / TB)
  end
  return out
end

---convert fs_stat octal "mode" number to permissions string, e.g. 604 -> -rw----r--
local permissions_str = function(type, mode)
  if not mode then return string.rep("-", 10) end
  type = ({ directory = "d", link = "l" })[type] or "-"
  local octal_str = ("%03o"):format(mode % (8*8*8)) -- keep bottom 3 octal-digits
  local octal_map = {
    ["0"] = "---", ["1"] = "--x", ["2"] = "-w-", ["3"] = "-wx",
    ["4"] = "r--", ["5"] = "r-x", ["6"] = "rw-", ["7"] = "rwx",
  }
  local user = octal_map[octal_str:sub(1, 1)]
  local group = octal_map[octal_str:sub(2, 2)]
  local other = octal_map[octal_str:sub(3, 3)]
  return type .. user .. group .. other
end

---convert fs_stat mtime to "last modified" string
local modified_str = function(mtime)
  if not mtime then return "" end
  return fn.strftime("%b %d %H:%M", mtime.sec)
end

---create an array of items for picker, will be called
---for each new directory visited during a picker session
---NOTE: actual items are returned as .items field of the returned table
local get_dir_items = function(dirname)
  if not dirname then return { items = {}, widths = {} } end

  -- while we make items, also compute max length of text and size
  -- so we can arrange data into neatly aligned columns in custom show()
  local text_col_width = 0
  local size_col_width = 0
  local items = vim
    .iter(fs.dir(dirname))
    :map(function(name, type)
      local path = fs.joinpath(dirname, name)
      local stat = uv.fs_stat(path) or {}
      local text = type == "directory" and name .. "/" or name
      local size = size_str(stat.size)
      text_col_width = math.max(text_col_width, #text)
      size_col_width = math.max(size_col_width, #size)
      return {
        text = text,
        path = path,
        type = type,
        size = size_str(stat.size),
        permissions = permissions_str(type, stat.mode),
        modified = modified_str(stat.mtime),
      }
    end)
    :totable()

  return { items = items, widths = { text = text_col_width, size = size_col_width } }
end


-- path helpers --------------------------------------------------------------
local normalized = function(path)
  return path and fs.normalize(fs.abspath(path))
end

local query_to_path = function(query)
  local path = table.concat(query)
  if vim.trim(path) == "" then return false end
  return fs.abspath(path)
end

local query_to_dirname = function(query)
  local path = table.concat(query)
  if vim.trim(path) == "" then return false end
  local dirname = path == "~" and fs.dirname(fn.expand(path)) or fs.dirname(path)
  return normalized(dirname)
end

local query_tail = function(query)
  local path = query_to_path(query)
  local tail = path and fs.basename(path) or ""
  return vim.split(tail, "")
end


-- picker implementation -----------------------------------------------------
local CACHE_STUB = { items = {}, widths = {} }

local find_file = function(local_opts, opts)
  local_opts = vim.tbl_extend("force", { dir = fn.getcwd() }, local_opts or {})
  local initial_dir = normalized(local_opts.dir)
  vim.schedule(function()
    pick.set_picker_query(vim.split(fn.fnamemodify(initial_dir, ":~").. "/", ""))
  end)

  -- `items_cache` is a table keyed by normalized directory paths
  -- NOTE: using `[false]` as a special key to stub empty lookups,
  -- which happens when query is empty
  local items_cache = { [false] = CACHE_STUB }
  items_cache[initial_dir] = get_dir_items(initial_dir)
  local items = items_cache[initial_dir].items

  -- stack helpers -----------------------------------------------------------
  -- This is just a tiny "stack" implementation to help with implementing the
  -- "presssing ~ or / resets query to list home or root directory" feature.
  -- The idea is pressing a "~" or "/" trigger with the right conditions will
  -- push the current query to a "history" stack and reset the query, and then
  -- reaching an empty query (by typing backspace or however) will restore
  -- a saved query from the top of the stack if it exists.
  local query_history_stack = {}
  local stack_pop = function()
    return table.remove(query_history_stack)
  end
  local stack_push = function(query)
    local top = query_history_stack[#query_history_stack]
    if top and table.concat(top) == table.concat(query) then return end
    table.insert(query_history_stack, query)
    return query
  end
  local push_to_stack_and_reset_query = function(query)
    local trigger_char = query[#query]
    query[#query] = nil -- don't want to save the trigger char to saved query in history
    stack_push(query)
    pick.set_picker_query({ trigger_char })
  end
  ----------------------------------------------------------------------------

  local last_dir = initial_dir
  local match = function(stritems, inds, query)

    -- restore query on top of stack if we hit empty query
    if #query == 0 then
      local last_query = stack_pop()
      if last_query then
        pick.set_picker_query(last_query)
        return
      end
    end

    -- pressing "~" anywhere during a query should immediatlely bring you home
    -- NOTE: excluding cases with repetition like `query == { "~", "~", "~" }`
    if #query > 1 and query[#query] == "~" and query[#query - 1] ~= "~" then
      push_to_stack_and_reset_query(query)
      return
    end

    -- pressing "/" only when last query char is "/" should bring you to root
    -- meaning the last to chars of the query should be "//"
    if #query > 1 and query[#query] == "/" and query[#query - 1] == "/" then
      if table.concat(query) ~= "//" then
        push_to_stack_and_reset_query(query)
      else
        -- NOTE: I'm excluding the case where you type "/" when `query == { "/" }`
        -- i.e. repeating consecutive "/" chars does not add an empty "/" to the query
        -- stack. This differs from Emacs behavior, but I think it's a lot better.
        pick.set_picker_query({ "/" })
      end
      return
    end

    local current_dir = query_to_dirname(query)
    if current_dir ~= last_dir then
      last_dir = current_dir
      -- if `current_dir == false`, we hit our items_cache[false] stub,
      -- which is {} (truthy), so items will become {}, otherwise compute and cache new items
      if not items_cache[current_dir] then items_cache[current_dir] = get_dir_items(current_dir) end
      pick.set_picker_items(items_cache[current_dir].items, { do_match = true })
      return
    end

    return pick.default_match(stritems, inds, query_tail(query))
  end

  local show = function(buf_id, items_to_show, query)
    pick.default_show(buf_id, items_to_show, query_tail(query), { show_icons = true })

    local ns = api.nvim_create_namespace("find-file-picker")
    api.nvim_buf_clear_namespace(buf_id, ns, 0, -1)
    local extmark = function(i, text, hl, extmark_opts)
      api.nvim_buf_set_extmark(buf_id, ns, i - 1, 0, {
        virt_text = {{ text, hl }},
        virt_text_pos = extmark_opts.virt_text_pos,
        virt_text_win_col = extmark_opts.virt_text_win_col,
        hl_mode = "combine",
      })
    end
    local col_widths = items_cache[query_to_dirname(query)].widths
    -- the numbers are kinda magic here...
    -- 9 because that's the width of "%6s   " format string
    -- 4 beacuse the text is prefixed with icons so 2 for icon and 2 for extra space after text
    -- 40 because it looks alright as default offset
    -- NOTE: an alternative would be to truncate filenames if width too long instead of moving columns
    local permissions_offset = math.max(9 + (col_widths.text or 0) + 4, 40)
    for i, item in ipairs(items_to_show) do
      extmark(i, ("%6s   "):format(item.size), "String", { virt_text_pos = "inline" })
      extmark(i, item.permissions, "Number", { virt_text_win_col = permissions_offset })
      extmark(i, item.modified, "Comment", { virt_text_win_col = permissions_offset + 20 })
    end
  end

  local custom_choose = function()
    local current = pick.get_picker_matches().current
    if current then
      pick.default_choose(current)
      return true
    end
    local query = pick.get_picker_query()
    local path = query_to_path(query)
    -- NOTE: needs to be scheduled so picker returns to target window and THEN calls :edit
    vim.schedule(function() vim.cmd("edit " .. path) end)
    return true
  end

  local custom_tab_complete = function()
    local current = pick.get_picker_matches().current
    if not current then return end

    local path = fn.fnamemodify(current.path, ":p:~")
    local query = vim.split(path, "")
    pick.set_picker_query(query)
  end

  -- default opts
  opts = vim.tbl_deep_extend("keep", opts or {}, {
    window = { prompt_prefix = " Search: " },
    source = { name = "Find File" },
    mappings = {
      choose = "", -- to suppress overwrite <CR> warning
      custom_choose = { char = "<CR>", func = custom_choose },
      custom_tab_complete = { char = "<Tab>", func = custom_tab_complete },
    },
  })
  -- mandatory opts
  opts = vim.tbl_deep_extend("force", opts, {
    options = { use_cache = false },
    source = { items = items, match = match, show = show },
  })
  return pick.start(opts)
end

pick.registry["find_file"] = find_file
vim.keymap.set("n", "<Leader>ff", function() pick.registry.find_file() end)
vim.keymap.set("n", "<Leader>f.", function() pick.registry.find_file({ dir = fn.expand("%:p:h") }) end)

For jumping to a file in cwd I think MiniPick.builtin.files() is still far superior, but I really like this picker as an :edit replacement and when I need to quickly jump to root/home dir or any dir outside of cwd. I know there's also MiniExtra.pickers.explorer(), but there you have to press enter many times to move through directories.

mini.pick is really nice to use, I had fun tinkering :)

---

A few notes / things I couldn't do yet:

Weird options.use_cache = true behavior (bug?)

I'm not sure why this happens, but when options.use_cache is on, a weird bug occurs - typing a full directory name relists all items and current match ends in the wrong position. It happens when backspacing or finishing a directory name in query... see vid:

findfile_usecache_bug.mp4

So I just forced options.use_cache = false for this picker and implemented my own little cache.

Why does extmark with virt_text_pos = "inline" at col 0 not get line hl?

My "size" column in the picker doesn't get highlighted with MiniPickMatchCurrent like the rest of the line, but when I go to preview and back, it's fixed... any idea why?

findfile_extmark_demo.mp4

How to autocomplete truncated paths?

There was one feature from M-x find-file I'm not sure how to implement... When you type truncated paths for example ~/.c/n/l, the items listing will automatically update to match paths that have those first chars. For example in emacs it looks like this:

I have no idea how to implement this. Would I need to use a fuzzy finding algorithm?

Also completely separate question, but do you know if there is any simple way to keep the Statusline highlight on the current window target of the picker? I use laststatus = 2 so I like the StatuslineNC highlight to dim non-current window, but I don't want my current window statusline to switch to non-current highlight while inside a picker.

[simifalaye]

For the statusline, I've fixed this for both my minibuffer.nvim plugin (outdated) and your msgarea.nvim plugin. Take a look at g:statusline_winid. The issue is that technically, you are focused on another window in the msgarea and so your main window (which is drawing the statusline) is now an inactive window. If you have a vim.opt.statusline function, you just need to keep track of the previous win and render the statusline for that buffer instead.

[edisj]

oh hey, I saw you forked my repo but didn't realize you were the minibuffer.nvim author, what's up!

Thanks, this helped me find the answer. For my statusline I do use a custom expr string but it's
vim.go.statusline = "%{%v:lua.Statusline.active()%}", and apparently g:statusline_winid is only set for statusline expressions that begin with %!. After some digging though I found there's another variable, g:actual_curwin that's set for %{% type expressions, so i just had to prefix my statusline function with

Statusline.active = function()
  if _G.MiniPick then
    local state = _G.MiniPick.get_picker_state()
    if state and state.windows.main == tonumber(vim.g.actual_curwin) then
      vim.g.actual_curwin = state.windows.target
    end
  end
  ...
end

and it works :).

There's still an issue though where resetting the highlight with %* still goes back to StatuslineNC even though I changed g:actual_curwin, so I had to reset the statusline hl manually by checking if vim.api.nvim_get_current_win() == tonumber(vim.g.actual_curwin) instead of using %*

[voyeg3r]

I have made a snacks picker version of your picker :)

Code

-- File: ~/.config/nvim/lua/core/utils/pickers.lua
-- Author: Sergio Araujo
-- Purpose: Custom Snacks picker sources like Emacs Find-file

local M = {}
local bit = require('bit')
local has_mini, mini_icons = pcall(require, 'mini.icons')

local dir_cache = {}
local SIZE_COL_WIDTH, GAP, FALLBACK_NAME_WIDTH = 7, '  ', 40
local OCTAL_MAP = { ['0']='---', ['1']='--x', ['2']='-w-', ['3']='-wx', ['4']='r--', ['5']='r-x', ['6']='rw-', ['7']='rwx' }

local function permissions_str(entry_type, mode)
  local t = ({ directory = 'd', link = 'l' })[entry_type] or '-'
  if not mode then return t .. 'rwxrwxrwx' end
  local oct = ('%03o'):format(mode % 0x1FF)
  return t .. OCTAL_MAP[oct:sub(1,1)] .. OCTAL_MAP[oct:sub(2,2)] .. OCTAL_MAP[oct:sub(3,3)]
end

local function format_size(s)
  local u, i = { 'b', 'k', 'm', 'g', 't' }, 1
  while s >= 1024 and i < #u do s, i = s / 1024, i + 1 end
  return i == 1 and ('%d'):format(s) .. u[i] or ('%.1f'):format(s) .. u[i]
end

local function scan_directory(dir)
  local stat = vim.uv.fs_stat(dir)
  if not stat then return {}, 0 end

  local cached = dir_cache[dir]
  if cached and cached.mtime == stat.mtime.sec then return cached.items, cached.name_width_max end

  local items, max_len, scan = {}, 0, vim.uv.fs_scandir(dir)
  if not scan then return {}, 0 end

  while true do
    local name, etype = vim.uv.fs_scandir_next(scan)
    if not name then break end
    max_len = math.max(max_len, #name)
    local fp = vim.fs.joinpath(dir, name)
    local fstat = vim.uv.fs_stat(fp)
    local is_dir = fstat and (etype == 'link' and vim.fn.isdirectory(fp) == 1 or etype == 'directory') or false

    table.insert(items, {
      name = name, full_path = fp, is_dir = is_dir, is_symlink = etype == 'link', is_broken = not fstat,
      is_executable = fstat and (bit.band(fstat.mode, 0x40) ~= 0) or false,
      size = fstat and fstat.size or 0, mtime = fstat and fstat.mtime or { sec = 0 },
      perms = permissions_str(etype, fstat and fstat.mode),
    })
  end

  table.sort(items, function(a, b)
    if a.is_dir ~= b.is_dir then return a.is_dir end
    return a.name:lower() < b.name:lower()
  end)

  dir_cache[dir] = { items = items, mtime = stat.mtime.sec, name_width_max = max_len }
  return items, max_len
end

local function get_entry_icon(item)
  if item.is_broken then return '󱧨 ', 'DiagnosticError' end
  if item.is_symlink then return ' ', 'Identifier' end
  local cat = item.is_dir and 'directory' or 'file'
  local def_i, def_h = item.is_dir and '󰉋 ' or ' ', item.is_dir and 'Directory' or 'Normal'
  if has_mini then
    local i, h = mini_icons.get(cat, item.text or '')
    return (i or def_i) .. ' ', h or def_h
  end
  return def_i .. ' ', def_h
end

local function format_ls_line(item, name_width)
  name_width = name_width or FALLBACK_NAME_WIDTH
  local icon_str, icon_hl = get_entry_icon(item)
  local perms = item.perms or (item.is_dir and 'drwxr-xr-x' or '-rw-r--r--')
  local sz = ('%' .. SIZE_COL_WIDTH .. 's'):format(format_size(item.size or 0)) .. GAP
  local disp = (item.text or '') .. (item.is_dir and '/' or '')
  if #disp > name_width then disp = disp:sub(1, name_width - 1) .. '...' end

  local hl = item.is_dir and 'Directory' or (item.is_broken and 'DiagnosticError' or (item.is_symlink and 'Identifier' or (item.is_executable and 'Special' or 'Normal')))
  local dt = (item.mtime and item.mtime.sec and item.mtime.sec > 0) and os.date('%b %d %H:%M', item.mtime.sec) or '--- -- --:--'

  return {
    { sz, 'Number' }, { icon_str, icon_hl }, { ' ' .. ('%-' .. name_width .. 's'):format(disp), hl },
    { GAP .. perms, 'Comment' }, { GAP .. dt, 'Constant' },
  }
end

local function fuzzy_match_component(dir, partial)
  if partial == '' or partial == '.' or partial == '..' or vim.fn.isdirectory(vim.fs.joinpath(dir, partial)) == 1 then return partial end
  local matches, plower = {}, partial:lower()
  for _, item in ipairs(scan_directory(dir)) do
    if item.is_dir then
      local name = item.name:lower()
      local pi = 1
      for ci = 1, #name do
        if name:sub(ci, ci) == plower:sub(pi, pi) then
          pi = pi + 1
          if pi > #plower then break end
        end
      end
      if pi > #plower then table.insert(matches, item.name) end
    end
  end
  return #matches == 1 and matches[1] or nil
end

local function resolve_path(input, default_dir)
  if not input or input == '' then return default_dir, '' end
  local expanded = (input:sub(1, 1) == '~' and vim.fn.expand(input) or input):gsub('/+', '/')
  if expanded == '' then return default_dir, '' end

  local is_trailing = expanded:sub(-1) == '/'
  local clean = is_trailing and (expanded:match('^(.-)/$') or expanded) or expanded
  if clean == '' then return '/', '' end

  local parts = vim.split(clean, '/')
  local curr = clean:sub(1, 1) == '/' and '/' or default_dir
  if clean:sub(1, 1) == '/' then table.remove(parts, 1) end

  local limit = is_trailing and #parts or (#parts - 1)
  for i = 1, limit do
    local part = parts[i]
    if part == '..' then
      curr = vim.fs.normalize(vim.fs.joinpath(curr, '..'))
    elseif part ~= '' and part ~= '.' then
      local matched = fuzzy_match_component(curr, part)
      if matched then
        curr = vim.fs.normalize(vim.fs.joinpath(curr, matched))
      elseif is_trailing then
        -- Trailing /: usa o nome literal se o fuzzy nao encontrar match
        curr = vim.fs.normalize(vim.fs.joinpath(curr, part))
      else
        local unresolved = table.concat(parts, '/', i)
        local pos = unresolved:match('^.*/')
        return vim.fs.normalize(pos and vim.fs.joinpath(curr, pos:sub(1, -2)) or curr), pos and unresolved:sub(#pos + 1) or unresolved
      end
    end
  end
  return vim.fs.normalize(curr), is_trailing and '' or parts[#parts]
end

function M.emacs_find_file(opts)
  opts = opts or {}
  local Snacks = require('snacks')
  local buf_path = vim.api.nvim_buf_get_name(0)
  local initial_dir = (buf_path ~= '' and vim.fn.filereadable(buf_path) == 1) and vim.fn.fnamemodify(buf_path, ':h') or vim.fn.expand('~')
  local cwd = vim.fs.normalize(opts.dir or initial_dir)
  local active_dir, is_navigating = cwd, false
  local fmt_ctx = { name_width = FALLBACK_NAME_WIDTH, glob_pattern = nil }

  local function navigate(picker, fp)
    is_navigating = true
    active_dir = fp
    picker:set_cwd(fp)
    picker.input:set('')
    picker:find({ refresh = true })
    is_navigating = false
  end

  local function execute_action(picker, item, open_cmd)
    open_cmd = open_cmd or 'edit '
    local input = picker.input:get() or ''
    if input ~= '' then
      local rd, bn = resolve_path(input, active_dir)
      local fp = vim.fs.normalize(vim.fs.joinpath(rd, bn))
      if vim.fn.isdirectory(fp) == 1 then navigate(picker, fp); return end
      if vim.fn.filereadable(fp) == 1 or not item then
        picker:close(); vim.cmd(open_cmd .. vim.fn.fnameescape(fp))
        return
      end
    end

    if item then
      if item.dir then navigate(picker, item.file)
      else picker:close(); vim.cmd(open_cmd .. vim.fn.fnameescape(item.file)) end
    end
  end

  Snacks.picker.pick({
    title = 'Find File', cwd = cwd, hidden = true, ignored = false, preview = false, prompt = 'Find file: ',
    layout = { layout = { box = 'vertical', backdrop = false, width = 0, height = 0.4, min_height = 5, position = 'bottom', border = 'none', { win = 'input', height = 1, border = 'none' }, { win = 'list', border = 'none' } } },
    highlights = { SnacksPickerInput = { bg = '#3a3a3a', fg = '#c0c0c0' }, SnacksPickerPrompt = { fg = '#a0a0a0' }, SnacksPickerInputSearch = { fg = '#d0d0d0', bold = true } },
    win = {
      input = {
        keys = {
          ['<C-s>'] = function(p, item) execute_action(p, item, 'split ') end,
          ['<C-v>'] = function(p, item) execute_action(p, item, 'vsplit ') end,
        },
      },
    },
    filter = {
      transform = function(picker, filter)
        if is_navigating then return end
        local input = filter.pattern or filter.search or ''
        local new_dir, basename = resolve_path(input, active_dir)

        if basename:match('[*?[]') then
          fmt_ctx.glob_pattern = basename
          filter.pattern, filter.search = '', basename
          if new_dir ~= active_dir then active_dir = new_dir; picker:set_cwd(new_dir) end
          return true
        end

        fmt_ctx.glob_pattern = nil
        filter.pattern, filter.search = basename, basename

        -- So atualiza active_dir se o diretorio resolvido existir
        if new_dir ~= active_dir and vim.uv.fs_stat(new_dir) then
          active_dir = new_dir
          picker:set_cwd(new_dir)
          if basename == '' then
            local new_path = vim.fn.fnamemodify(new_dir, ':~') .. '/'
            picker.input:set(new_path)
            vim.api.nvim_win_set_cursor(picker.input.win.win, { 1, #new_path })
          end
          return true
        end
      end,
    },
    finder = function(inner_opts)
      local dir, show_hidden = active_dir, inner_opts.hidden ~= false
      return function(cb)
        if fmt_ctx.glob_pattern then
          fmt_ctx.name_width = FALLBACK_NAME_WIDTH
          for _, fp in ipairs(vim.fn.glob(vim.fs.joinpath(dir, fmt_ctx.glob_pattern), false, true)) do
            local fstat = vim.uv.fs_stat(fp)
            local is_d = fstat and vim.fn.isdirectory(fp) == 1 or false
            cb({ text = vim.fn.fnamemodify(fp, ':t'), file = fp, dir = is_d, cwd = dir, is_dir = is_d, is_symlink = false, is_broken = not fstat, perms = fstat and permissions_str(is_d and 'directory' or 'file', fstat.mode) or '----------', size = fstat and fstat.size or 0, mtime = fstat and fstat.mtime or { sec = 0 } })
          end
          return
        end

        local items, name_width = scan_directory(dir)
        fmt_ctx.name_width = name_width
        for _, e in ipairs(items) do
          if show_hidden or e.name:sub(1, 1) ~= '.' then
            cb({ text = e.name, file = e.full_path, dir = e.is_dir, cwd = dir, perms = e.perms, size = e.size, mtime = e.mtime, is_dir = e.is_dir, is_symlink = e.is_symlink, is_broken = e.is_broken, is_executable = e.is_executable })
          end
        end
      end
    end,
    format = function(item) return item and format_ls_line(item, fmt_ctx.name_width) or {} end,
    confirm = function(picker, item)
      if fmt_ctx.glob_pattern then
        picker:close()
        for _, f in ipairs(vim.fn.glob(vim.fs.joinpath(active_dir, fmt_ctx.glob_pattern), false, true)) do vim.cmd('edit ' .. vim.fn.fnameescape(f)) end
        return
      end
      execute_action(picker, item, 'edit ')
    end,
    on_show = function(picker)
      local start_path = vim.fn.fnamemodify(initial_dir, ':~') .. '/'
      picker.input:set(start_path)
      vim.api.nvim_win_set_cursor(picker.input.win.win, { 1, #start_path })
      local buf = picker.input.win.buf
      local bs_to_initial = false -- false: proximo BS vai p/ initial_dir; true: vai p/ ~/

      vim.api.nvim_buf_set_keymap(buf, 'i', '<BS>', '', {
        noremap = true, nowait = true,
        callback = function()
          local text = vim.api.nvim_buf_get_lines(buf, 0, 1, false)[1] or ''
          if text == '' then
            if not bs_to_initial then
              -- Primeiro BS com input vazio: volta ao diretorio do buffer
              local fallback = vim.fn.fnamemodify(initial_dir, ':~') .. '/'
              vim.api.nvim_buf_set_lines(buf, 0, 1, false, { fallback })
              vim.api.nvim_win_set_cursor(picker.input.win.win, { 1, #fallback })
              bs_to_initial = true
            else
              -- Segundo BS com input vazio: volta pra ~/
              vim.api.nvim_buf_set_lines(buf, 0, 1, false, { '~/' })
              vim.api.nvim_win_set_cursor(picker.input.win.win, { 1, 2 })
            end
          else
            vim.api.nvim_buf_set_lines(buf, 0, 1, false, { text:sub(1, -2) })
            vim.api.nvim_win_set_cursor(picker.input.win.win, { 1, math.max(#text - 1, 0) })
          end
        end,
      })
      vim.api.nvim_buf_set_keymap(buf, 'i', '<C-u>', '', {
        noremap = true, nowait = true,
        callback = function()
          vim.api.nvim_buf_set_lines(buf, 0, 1, false, { '~/' })
          vim.api.nvim_win_set_cursor(picker.input.win.win, { 1, 2 })
        end,
      })
    end,
  })
end

return M

[edisj]

very nice! ... but no screenshot??

[echasnovski]

Thanks for sharing! I really like the idea of "interactively traverse directory tree without pressing <CR> to go into each directory". It might be a good candidate for something like MiniExtra.pickers.explorer_live, but its implementation will have to be concise enough. Because otherwise the picker from this discussion is already not that large.

Weird options.use_cache = true behavior (bug?)

This probably works as expected since the cache is done per prompt (concatenated query) by caching matching indexes. If it shows items like it does, then they were the ones used for the first time the prompt was cached. It is also reset after every set_picker_items(), so should work okay with this type of "dynamic" items. And, of course, caching is opt-in; so I'd indeed expect this type of picker to force disable it and potentially implement its own.

Why does extmark with virt_text_pos = "inline" at col 0 not get line hl?

Not sure. My guess would be that this has something to do with extmark priority and/or the fact that this is inline text. In both cases it might matter in which order the extmarks were added. Haven't really looked deep into this kind of interaction in 'mini.pick'.

How to autocomplete truncated paths?

This looks like a responsibility of custom match function. I.e. it should be smart enough to know how to prioritize this kind of "treat / differently" special case. The default_match{} doesn't do that and treats all characters the same, mostly because I find this type of matching a bit confusing.

Also the show function should also probably be updated since default_show highlights matched ranges based on the default_match logic.

[edisj]

MiniExtra.pickers.explorer_live makes a lot of sense! Would you be open to me writing a PR? I would love to contribute to your project. (but I definitely understand if you like to write it up yourself)

concise enough

do you mean in terms of LOC? Do you typically have a hard limit for extra pickers or is it case by case

[echasnovski]

MiniExtra.pickers.explorer_live makes a lot of sense! Would you be open to me writing a PR? I would love to contribute to your project. (but I definitely understand if you like to write it up yourself)

I'd do it myself in the spare time. The 'mini.extra' is already very large and adding more code to it is not the decision that'll come lightly. My initial guess is that it has low chances of being the part of 'mini.extra'. Maybe only if squishing both MiniExtra.pickers.explorer and potential MiniExtra.pickers.explorer_live with common helpers, but that is also unlikely since the explorer picker is already quite small. We'll see some day.

[asadzman]

Related: neovim/neovim#35456