feat: path_shorten using extmarks

Author: ibhagwan

lua/fzf-lua/defaults.lua

@@ -72,6 +72,8 @@ end
 ---@field fullscreen? boolean
 ---Use treesitter highlighting in fzf's main window. NOTE: Only works for file-like entries where treesitter parser exists and is loaded for the filetype.
 ---@field treesitter? fzf-lua.config.TreesitterWinopts|boolean
+---Use extmarks with conceal to visually shorten paths while keeping full paths for actions/preview. Set to `true` for 1 char, or a number for custom length. NOTE: Unlike the picker `path_shorten` option, this doesn't modify the actual entry text, making it compatible with `combine()`. NOTE: This option has no effect when using `fzf-tmux` as the fzf window runs in a tmux popup outside of Neovim where extmarks are not available.
+---@field path_shorten? boolean|integer
 ---Callback after the creation of the fzf-lua main terminal window.
 ---@field on_create? fun(e: { winid?: integer, bufnr?: integer })
 ---Callback after closing the fzf-lua window.

lua/fzf-lua/path.lua

@@ -273,7 +273,7 @@ end
 ---@param str string
 ---@param start_idx integer
 ---@return integer?
-local function find_next_separator(str, start_idx)
+function M.find_next_separator(str, start_idx)
   local SEPARATOR_BYTES = utils._if_win(
     { M.fslash_byte, M.bslash_byte }, { M.fslash_byte })
   for i = start_idx or 1, #str do
@@ -288,7 +288,7 @@ end
 ---@param s string
 ---@param i? integer
 ---@return integer?
-local function utf8_char_len(s, i)
+function M.utf8_char_len(s, i)
   -- Get byte count of unicode character (RFC 3629)
   local c = string_byte(s, i or 1)
   if not c then
@@ -321,7 +321,7 @@ local function utf8_sub(s, from, to)
   local byte_i, utf8_i = from, from
   -- Concat utf8 chars until "to" or end of string
   while byte_i <= #s and (not to or utf8_i <= to) do
-    local c_len = utf8_char_len(s, byte_i) ---@cast c_len-?
+    local c_len = M.utf8_char_len(s, byte_i) ---@cast c_len-?
     local c = string_sub(s, byte_i, byte_i + c_len - 1)
     ret = ret .. c
     byte_i = byte_i + c_len
@@ -343,7 +343,7 @@ function M.shorten(path, max_len, sep)
     start_idx = 4
   end
   repeat
-    local i = find_next_separator(path, start_idx)
+    local i = M.find_next_separator(path, start_idx)
     local end_idx = i and start_idx + math.min(i - start_idx, max_len) - 1 or nil
     local part = utf8_sub(path, start_idx, end_idx) ---@cast i-?
     if end_idx and part == "." and i - start_idx > 1 then

lua/fzf-lua/win.lua

@@ -1,10 +1,161 @@
 local utils = require "fzf-lua.utils"
 local libuv = require "fzf-lua.libuv"
 local actions = require "fzf-lua.actions"
+local path = require "fzf-lua.path"
 
 local api = vim.api
 local fn = vim.fn
 
+---@class fzf-lua.PathShortener
+---@field _ns integer?
+---@field _wins table<integer, { bufnr: integer, shorten_len: integer }>
+local PathShortener = {}
+
+PathShortener._wins = {}
+
+-- Hoist constant byte values for performance
+local DOT_BYTE = path.dot_byte
+
+function PathShortener.setup()
+  if PathShortener._ns then return end
+  PathShortener._ns = api.nvim_create_namespace("fzf-lua.win.path_shorten")
+
+  -- Register decoration provider with ephemeral extmarks
+  api.nvim_set_decoration_provider(PathShortener._ns, {
+    on_win = function(_, winid, bufnr, _topline, _botline)
+      -- Only process registered fzf windows
+      local win_data = PathShortener._wins[winid]
+      if not win_data or win_data.bufnr ~= bufnr then
+        return false
+      end
+      return true -- Continue to on_line callbacks
+    end,
+    on_line = function(_, winid, bufnr, row)
+      local win_data = PathShortener._wins[winid]
+      if not win_data then return end
+      PathShortener._apply_line(bufnr, row, win_data.shorten_len)
+    end,
+  })
+end
+
+---Apply path shortening to a single line using ephemeral extmarks
+---@param buf integer buffer number
+---@param row integer 0-indexed line number
+---@param shorten_len integer number of characters to keep
+function PathShortener._apply_line(buf, row, shorten_len)
+  local lines = api.nvim_buf_get_lines(buf, row, row + 1, false)
+  local line = lines[1]
+  if not line or #line == 0 then return end
+
+  -- Find the path portion of the line
+  -- Lines may have prefixes like icons separated by nbsp (U+2002)
+  -- Format: [fzf_pointer] [git_icon nbsp] [file_icon nbsp] path[:line:col:text]
+  -- When file_icons=false, there's no nbsp separator before the path
+  -- The fzf terminal also adds pointer/marker prefix (e.g., "> " or " ")
+  local path_start = 1
+  local last_nbsp = line:find(utils.nbsp, 1, true)
+  if last_nbsp then
+    -- Find the last nbsp (there may be multiple with git_icons + file_icons)
+    repeat
+      path_start = last_nbsp + #utils.nbsp
+      last_nbsp = line:find(utils.nbsp, path_start, true)
+    until not last_nbsp
+  else
+    -- No nbsp means no icons - skip fzf's pointer/marker prefix
+    -- Paths start with: alphanumeric, `/`, `~`, `.`, or drive letter (Windows)
+    -- Skip leading whitespace and pointer characters until we hit a path char
+    local first_path_char = line:find("[%w/~%.]")
+    if first_path_char then
+      path_start = first_path_char
+    end
+  end
+
+  -- Find where the path ends (at first colon after path_start, if any)
+  -- But be careful with Windows paths like C:\...
+  local path_end = #line
+  local colon_search_start = path_start
+  -- On Windows, skip the drive letter colon (e.g., C:)
+  -- Check if char at path_start+1 is colon AND char at path_start+2 is a path separator
+  if string.byte(line, path_start + 1) == path.colon_byte
+      and path.byte_is_separator(string.byte(line, path_start + 2)) then
+    colon_search_start = path_start + 2
+  end
+  local colon_pos = line:find(":", colon_search_start)
+  if colon_pos then
+    path_end = colon_pos - 1
+  end
+
+  -- Now process the path portion for shortening
+  -- We need to conceal directory components, keeping only `shorten_len` chars
+  local path_portion = line:sub(path_start, path_end)
+
+  -- Use path.find_next_separator to iterate through directory components
+  local prev_sep = 0
+  local sep_pos = path.find_next_separator(path_portion, 1)
+  while sep_pos do
+    local component_start = prev_sep + 1
+    local component = path_portion:sub(component_start, sep_pos - 1)
+    local component_len = #component
+
+    -- Count UTF-8 characters using vim.str_utfindex
+    -- Use "utf-32" to count code points (actual characters), not bytes.
+    -- "utf-8" would give byte positions, "utf-16" gives UTF-16 code units.
+    local _, component_charlen = vim.str_utfindex(component, "utf-32")
+    component_charlen = component_charlen or component_len -- fallback to byte length
+
+    -- Only conceal if the component has more characters than shorten_len
+    if component_charlen > shorten_len then
+      -- Handle special case: component starts with '.' (hidden files/dirs)
+      local keep_chars = shorten_len
+      if string.byte(component, 1) == DOT_BYTE and component_charlen > shorten_len + 1 then
+        -- Keep the dot plus shorten_len characters
+        keep_chars = shorten_len + 1
+      end
+
+      -- Bounds check to prevent errors
+      keep_chars = math.min(keep_chars, component_charlen)
+
+      -- Convert character count to byte offset using vim.str_byteindex
+      local keep_bytes = vim.str_byteindex(component, "utf-32", keep_chars, false)
+      keep_bytes = keep_bytes or keep_chars -- fallback to character count (ASCII approximation)
+
+      -- Calculate 0-indexed byte positions in the full line for extmark
+      -- path_start is 1-indexed, component_start is 1-indexed within path_portion
+      local line_offset = path_start - 1 + component_start - 1
+      local conceal_start = line_offset + keep_bytes
+      local conceal_end = line_offset + component_len -- end of component (before separator)
+
+      if conceal_end > conceal_start then
+        pcall(api.nvim_buf_set_extmark, buf, PathShortener._ns, row, conceal_start, {
+          end_col = conceal_end,
+          conceal = "",
+          ephemeral = true,
+        })
+      end
+    end
+    prev_sep = sep_pos
+    sep_pos = path.find_next_separator(path_portion, sep_pos + 1)
+  end
+end
+
+---Register a window for path shortening
+---@param winid integer window ID
+---@param bufnr integer buffer number
+---@param shorten_len integer|boolean number of characters to keep
+function PathShortener.attach(winid, bufnr, shorten_len)
+  if not winid or not bufnr then return end
+  PathShortener.setup()
+  shorten_len = (shorten_len == true) and 1 or tonumber(shorten_len) or 1
+  PathShortener._wins[winid] = { bufnr = bufnr, shorten_len = shorten_len }
+end
+
+---Unregister a window from path shortening
+---@param winid integer window ID
+function PathShortener.detach(winid)
+  if not winid then return end
+  PathShortener._wins[winid] = nil
+end
+
 ---@alias fzf-lua.win.previewPos "up"|"down"|"left"|"right"
 ---@alias fzf-lua.win.previewLayout { pos: fzf-lua.win.previewPos, size: number, str: string }
 
@@ -773,6 +924,26 @@ function FzfWin:treesitter_attach()
   self.on_closes.tsinjector = self.tsinjector.attach(self, self.fzf_bufnr, self._o._treesitter)
 end
 
+function FzfWin:path_shorten_detach()
+  PathShortener.detach(self.fzf_winid)
+  -- Reset conceallevel when path shortening is disabled (e.g., on window reuse)
+  if api.nvim_win_is_valid(self.fzf_winid) then
+    vim.wo[self.fzf_winid].conceallevel = 0
+    vim.wo[self.fzf_winid].concealcursor = ""
+  end
+end
+
+function FzfWin:path_shorten_attach()
+  local path_shorten = self._o.winopts.path_shorten
+  if not path_shorten then return end
+  -- Enable conceallevel for the fzf window to show concealed text
+  if api.nvim_win_is_valid(self.fzf_winid) then
+    vim.wo[self.fzf_winid].conceallevel = 2
+    vim.wo[self.fzf_winid].concealcursor = "nvic"
+  end
+  PathShortener.attach(self.fzf_winid, self.fzf_bufnr, path_shorten)
+end
+
 ---@param buf integer
 function FzfWin:close_buf(buf)
   utils.nvim_buf_delete(buf, { force = true })
@@ -850,6 +1021,12 @@ function FzfWin:create()
     self:setup_autocmds()
     self:setup_keybinds()
     self:treesitter_attach()
+    -- attach/detach path shortening
+    if self._o.winopts.path_shorten then
+      self:path_shorten_attach()
+    else
+      self:path_shorten_detach()
+    end
     self:reset_winhl(self.fzf_winid)
     -- also recall the user's 'on_create' (#394)
     if type(self.winopts.on_create) == "function" then
@@ -931,6 +1108,8 @@ function FzfWin:create()
   self:setup_autocmds()
   self:setup_keybinds()
   self:treesitter_attach()
+  -- Use extmarks to visually shorten paths while keeping full paths for actions
+  self:path_shorten_attach()
   self:reset_winhl(self.fzf_winid)
 
   -- potential workarond for `<C-c>` freezing neovim (#1091)
@@ -1007,6 +1186,8 @@ function FzfWin:close(fzf_bufnr, hide)
   if not hide and self.fzf_bufnr then
     self:close_buf(self.fzf_bufnr)
   end
+  -- Detach path shortening decoration provider
+  PathShortener.detach(self.fzf_winid)
   for k, _ in pairs(self.on_closes) do
     self.on_closes[k](hide)
     self.on_closes[k] = nil