disable lsp progress

Very annoying in slow dart lsp

Makefile

@@ -1,10 +1,10 @@
 # prefer this if stow is available
 .PHONY: stow unstow
 stow:
-	stow nvim
+	stow nvim ghostty
 
 unstow:
-	stow -D nvim
+	stow -D nvim ghostty
 
 LN := ln -svf
 LNDIR := ln -sv
@@ -13,6 +13,7 @@ DOTFILES_DIR := $(shell pwd)
 TARGET_DIR := $(HOME)
 
 # if stow is not available, symlink configs instead
+# this is currently outdated
 .PHONY: link unlink
 link: nvim
 

ghostty/.config/ghostty/config.ghostty

@@ -0,0 +1,16 @@
+font-feature = -calt, -liga, -dlig
+
+# Allow terminal applications to read the clipboard without confirmation
+clipboard-read = allow
+
+# Use Alt for multi-teriminal management
+keybind = ctrl+shift+t=unbind
+keybind = alt+t=new_tab
+keybind = ctrl+shift+w=unbind
+keybind = alt+w=close_tab:this
+keybind = ctrl+enter=unbind
+keybind = alt+enter=toggle_fullscreen
+
+# Disable touchpad horizontal-swipe tab switching.
+# Will come in next version
+# gtk-horizontal-tab-scroll = false

install-scripts/android-sdk.md

@@ -0,0 +1,70 @@
+[source](https://pervoj.cz/blog/flutter-on-linux-installation)
+
+# Intall Java
+
+```sh
+sudo apt install openjdk-17-jdk
+```
+
+## Check it
+
+```sh
+java --version
+javac --version
+```
+
+# Android SDK
+
+[Download from here](https://developer.android.com/studio#command-line-tools-only)
+
+## Unzip exactly like this :)
+
+```sh
+zip_file="$HOME/Downloads/commandlinetools-linux-15859902_latest.zip"
+sdk_dir="$HOME/.local/share/android-sdk"
+
+temp_dir=$(mktemp -d)
+unzip "$zip_file" -d "$temp_dir"
+mkdir -p "$sdk_dir/cmdline-tools"
+mv "$temp_dir/cmdline-tools" "$sdk_dir/cmdline-tools/latest"
+rmdir "$temp_dir"
+```
+
+## Check nothing got messed up
+
+`ls -la ~/.local/share/android-sdk/cmdline-tools/latest`
+
+## Add this to `~/.bashrc`
+
+```text
+export ANDROID_SDK_ROOT="$HOME/.local/share/android-sdk"
+export ANDROID_HOME="$ANDROID_SDK_ROOT"
+export PATH="$ANDROID_SDK_ROOT/cmdline-tools/latest/bin:$ANDROID_SDK_ROOT/platform-tools:$PATH"
+```
+
+## Post install
+
+```sh
+source ~/.bashrc
+
+sdkmanager \
+  "platform-tools" \
+  "platforms;android-36" \
+  "build-tools;36.0.0"
+
+sdkmanager --licenses
+```
+
+## Validate
+
+```sh
+fvm flutter doctor
+```
+
+# Run like this
+
+```sh
+adb devices
+fvm flutter devices
+fvm flutter run
+```

nvim/.config/nvim/README.md

@@ -1,34 +1,42 @@
 # romanzy neovim config
 
 Inspirations:
+
 - [illya](https://codeberg.org/42nerds/nvim)
 - [nolan](https://github.com/Hrumble/sneaky-nvim-config)
 - [mats](https://github.com/BeerB34r/dotfiles)
 
+[Great guide on vim.pack](https://echasnovski.com/blog/2026-03-13-a-guide-to-vim-pack#delete)
+
+To remove a plugin run `:lua vim.pack.del({ "<plugin name>" })`.
+
 # Neovim Notes
 
 See custom keymaps with short descriptions with `<leader><leader>h`.
 
-Split shortcuts:
+General shortcuts:
+
+- `<leader>e` opens the file browser
+- `gx` opens an external viewer
+- `gR`, `<F5>` refresh
+
+Windowing shortcuts:
 
 - `<leader>sv` open a vertical split
 - `<leader>sh` open a horizontal split
 - `<leader>se` equalize split sizes
 - `<leader>sc` close the current window
-
-Resize shortcuts:
-
-- `<leader>rh` make the current window narrower
-- `<leader>rl` make the current window wider
-- `<leader>rj` make the current window shorter
-- `<leader>rk` make the current window taller
+- `<leader>r-hjkl` to resize
 - `<leader>re` equalize split sizes
+- `<C-hjkl>` move between windows
 
 Buffer shortcuts:
 
 - `<leader>bp` previous buffer
 - `<leader>bn` next buffer
 - `<leader>bd` delete the current buffer
+- `<leader>bc` force close all non-visible buffers
+- `<leader>bf` find buffers
 
 Telescope shortcuts:
 
@@ -41,31 +49,18 @@ Git shortcuts:
 
 - `:Git` to run commands directly (`:Git status`, `:Git log --oneline`)
 - `<leader>lg` open LazyGit
+- `<leader>dv` open Diffview
+- `<leader>dc` close Diffview
+- `[h`, `]h`, `[H`, `]H` jump to hunks
+- `<leader>th` — toggle the expanded hunk view
 
-Oil usage:
+Toggle shortcuts:
 
-- `<leader>dl` opens the file browser
-- `<CR>` opens a file or enters a directory
-- `-` goes to the parent directory
-- `<BS>` also goes to the parent directory
-- `<A-h>` also goes to the parent directory
-- `<A-l>` opens the selected file or enters the selected directory
-- `<C-p>` previews the selected entry
-- `gx` opens the file in external viewer
-
-## Window Navigation
-
-Move between windows with:
-
-```vim
-<C-hjkl>
-```
-
-Cycle through windows:
-
-```vim
-<C-w>w
-```
+- `<leader>tw` toggle soft wrap
+- `<leader>ts` toggle spell checking
+- `<leader>ti` toggle inline diagnostics
+- `<leader>tv` toggle virtual diagnostics
+- `<leader>th` — toggle the expanded hunk view
 
 ## Terminal
 
@@ -89,21 +84,24 @@ Useful Mason commands:
 
 Useful LSP commands:
 
+- `K` show the type and documentation for the symbol under the cursor
 - `gd` go to definition
 - `gD` go to declaration
 - `grd` list references
 - `grn` rename symbol
-- `<C-Space>` trigger completion
+- `<leader>ca` show code actions
+- `<leader>cf` apply quick fixes
+- `<leader>cs` show source actions
 
 Diagnostics:
 
 - `g.` open diagnostic float
 - `gl` send diagnostics to the location list
 - `gld` display diagnostic information
-- `gid` toggle inline diagnostics
-- `gvd` toggle virtual line diagnostics
-- `]g` jump to next warning or error
-- `[g` jump to previous warning or error
+- `]g`, `[g` jump to warning or error
+- `<leader>ti` toggle inline diagnostics
+- `<leader>tv` toggle virtual diagnostics
+- `<leader>xx` toggle project warnings and errors
 
 ## Tree-sitter
 

nvim/.config/nvim/lua/romanzy/custom/buffers.lua

@@ -0,0 +1,29 @@
+local M = {}
+
+function M.close_hidden()
+    local visible_buffers = {}
+    local closed_count = 0
+
+    for _, tabpage in ipairs(vim.api.nvim_list_tabpages()) do
+        for _, window in ipairs(vim.api.nvim_tabpage_list_wins(tabpage)) do
+            visible_buffers[vim.api.nvim_win_get_buf(window)] = true
+        end
+    end
+
+    for _, buffer in ipairs(vim.api.nvim_list_bufs()) do
+        if vim.bo[buffer].buflisted and not visible_buffers[buffer] then
+            vim.api.nvim_buf_delete(buffer, { force = true })
+            closed_count = closed_count + 1
+        end
+    end
+
+    if closed_count == 0 then
+        vim.notify("No hidden buffers to close", vim.log.levels.INFO)
+        return
+    end
+
+    local buffer_label = closed_count == 1 and "buffer" or "buffers"
+    vim.notify(string.format("Closed %d hidden %s", closed_count, buffer_label), vim.log.levels.INFO)
+end
+
+return M

nvim/.config/nvim/lua/romanzy/custom/dart.lua

@@ -0,0 +1,18 @@
+local M = {}
+
+-- This function returns project local dart, or fallsback to global
+function M.executable(path)
+    local directory = vim.fn.isdirectory(path) == 1 and path or vim.fs.dirname(path)
+    local root = vim.fs.root(directory, { "pubspec.yaml" })
+
+    if root then
+        local fvm_dart = root .. "/.fvm/flutter_sdk/bin/dart"
+        if vim.fn.executable(fvm_dart) == 1 then
+            return fvm_dart
+        end
+    end
+
+    return "dart"
+end
+
+return M

nvim/.config/nvim/lua/romanzy/custom/mini_files.lua

@@ -0,0 +1,426 @@
+-- Custom module to config a few things for the mini.files:
+-- - git highlighting
+-- - refresh
+-- - file open in external programs
+
+local M = {}
+
+local uv = vim.uv or vim.loop
+local cache_ttl_ms = 1000
+
+local status_cache = {}
+local git_root_cache = {}
+local known_git_roots = {}
+
+local function is_path_inside(path, root)
+    return path == root or vim.startswith(path, root .. "/")
+end
+
+local function new_status_node()
+    return {
+        children = {},
+        status = nil,
+        priority = 0,
+        is_dir_ignored = false,
+        is_dir_untracked = false,
+    }
+end
+
+local function is_conflict(status)
+    if #status < 2 then
+        return false
+    end
+
+    local index_status = status:sub(1, 1)
+    local worktree_status = status:sub(2, 2)
+    return index_status == "U"
+        or worktree_status == "U"
+        or status == "AA"
+        or status == "DD"
+end
+
+local function status_priority(status)
+    -- Folder aggregation follows the Zed-inspired order create < edit <
+    -- delete. `subtree_status()` uses the greatest priority, so deletion
+    -- must outrank every create or edit status.
+    if #status < 2 then
+        return 0
+    end
+
+    if is_conflict(status) then
+        return 8
+    end
+    if status == "!!" then
+        return 1
+    end
+    if status == "??" then
+        return 2
+    end
+
+    local index_status = status:sub(1, 1)
+    local worktree_status = status:sub(2, 2)
+
+    if index_status == "D" or worktree_status == "D" then
+        return 4
+    end
+    if index_status == "A" then
+        return 2
+    end
+    if index_status == "R" or index_status == "C" then
+        return 3
+    end
+    if index_status == "M" or worktree_status == "M" then
+        return 3
+    end
+
+    return 0
+end
+
+local function status_highlight(status)
+    if not status then
+        return nil
+    end
+    if status == "!!" then
+        return "Comment"
+    end
+    if is_conflict(status) then
+        return "MiniDiffSignDelete"
+    end
+    if status == "??" or status:sub(1, 1) == "A" then
+        return "MiniDiffSignAdd"
+    end
+    if status:sub(1, 1) == "D" or status:sub(2, 2) == "D" then
+        return "MiniDiffSignDelete"
+    end
+    if status:sub(1, 1) == "M"
+        or status:sub(1, 1) == "R"
+        or status:sub(1, 1) == "C"
+        or status:sub(2, 2) == "M"
+    then
+        return "MiniDiffSignChange"
+    end
+
+    return nil
+end
+
+local function insert_status(root, relative_path, status, is_directory)
+    local priority = status_priority(status)
+    if priority == 0 then
+        return
+    end
+
+    local node = root
+    local segments = vim.split(relative_path, "/", { plain = true, trimempty = true })
+    for index, segment in ipairs(segments) do
+        node.children[segment] = node.children[segment] or new_status_node()
+        node = node.children[segment]
+
+        if index == #segments then
+            if priority > node.priority then
+                node.status = status
+                node.priority = priority
+            end
+            if is_directory and status == "!!" then
+                node.is_dir_ignored = true
+            end
+            if is_directory and status == "??" then
+                node.is_dir_untracked = true
+            end
+        end
+    end
+end
+
+local function subtree_status(node)
+    local best_status = node.status
+    local best_priority = node.priority
+
+    for _, child in pairs(node.children) do
+        local child_status, child_priority = subtree_status(child)
+        if child_priority > best_priority then
+            best_status = child_status
+            best_priority = child_priority
+        end
+    end
+
+    return best_status, best_priority
+end
+
+local function parse_status(output, root)
+    local data = {
+        root = root,
+        statuses = {},
+        trie = new_status_node(),
+        timestamp = uv.now(),
+    }
+
+    local records = vim.split(output, "\0", { plain = true, trimempty = true })
+    local record_index = 1
+    while record_index <= #records do
+        local record = records[record_index]
+        if #record >= 4 then
+            local status = record:sub(1, 2)
+            local relative_path = record:sub(4)
+
+            -- With -z, rename/copy output contains the new path followed by
+            -- the old path. Oil highlights the new path only.
+            if status:sub(1, 1) == "R" or status:sub(1, 1) == "C" then
+                record_index = record_index + 1
+            end
+
+            local is_directory = relative_path:sub(-1) == "/"
+            relative_path = relative_path:gsub("^%./", ""):gsub("/$", "")
+            if relative_path ~= "" then
+                local absolute_path = vim.fs.normalize(vim.fs.joinpath(root, relative_path))
+                data.statuses[absolute_path] = status
+                insert_status(data.trie, relative_path, status, is_directory)
+            end
+        end
+        record_index = record_index + 1
+    end
+
+    return data
+end
+
+local function find_cached_root(path)
+    local result
+    for root in pairs(known_git_roots) do
+        if is_path_inside(path, root) and (result == nil or #root > #result) then
+            result = root
+        end
+    end
+    return result
+end
+
+local function find_git_root(path)
+    local cached_root = find_cached_root(path)
+    if cached_root ~= nil then
+        return cached_root
+    end
+
+    local cached = git_root_cache[path]
+    if cached ~= nil then
+        return cached or nil
+    end
+
+    local result = vim.system({ "git", "-C", path, "rev-parse", "--show-toplevel" }, { text = true }):wait()
+    if result.code ~= 0 then
+        git_root_cache[path] = false
+        return nil
+    end
+
+    local root = vim.trim(result.stdout)
+    if root == "" then
+        git_root_cache[path] = false
+        return nil
+    end
+
+    root = vim.fs.normalize(root)
+    git_root_cache[path] = root
+    known_git_roots[root] = true
+    return root
+end
+
+local function get_status_data(fs_entry)
+    local path = fs_entry.path
+    if fs_entry.fs_type ~= "directory" then
+        path = vim.fs.dirname(path)
+    end
+    path = vim.fs.normalize(path)
+
+    local root = find_git_root(path)
+    if root == nil then
+        return nil
+    end
+
+    local cached = status_cache[root]
+    if cached ~= nil and uv.now() - cached.timestamp < cache_ttl_ms then
+        return cached
+    end
+
+    local result = vim.system({
+        "git",
+        "-C",
+        root,
+        "--no-optional-locks",
+        "status",
+        "--porcelain",
+        "--ignored",
+        "-z",
+    }, { text = true }):wait()
+    if result.code ~= 0 then
+        status_cache[root] = parse_status("", root)
+        return status_cache[root]
+    end
+
+    local data = parse_status(result.stdout, root)
+    status_cache[root] = data
+    return data
+end
+
+local function lookup_status(data, fs_entry)
+    local path = vim.fs.normalize(fs_entry.path)
+    local direct_status = data.statuses[path]
+    if fs_entry.fs_type ~= "directory" and direct_status ~= nil then
+        return direct_status
+    end
+
+    if not is_path_inside(path, data.root) then
+        return nil
+    end
+
+    local relative_path = path:sub(#data.root + 2)
+    local node = data.trie
+    for _, segment in ipairs(vim.split(relative_path, "/", { plain = true, trimempty = true })) do
+        if node.is_dir_ignored then
+            return "!!"
+        end
+        if node.is_dir_untracked then
+            return "??"
+        end
+
+        node = node.children[segment]
+        if node == nil then
+            return nil
+        end
+    end
+
+    if node.is_dir_ignored then
+        return "!!"
+    end
+    if node.is_dir_untracked then
+        return "??"
+    end
+    if next(node.children) == nil then
+        return node.status
+    end
+
+    local status = subtree_status(node)
+    -- Match the Oil configuration: an ignored descendant does not grey its
+    -- parent directory unless Git reported that directory as ignored.
+    if fs_entry.fs_type == "directory" and status == "!!" then
+        return nil
+    end
+    return status
+end
+
+function M.filter(fs_entry)
+    return fs_entry.name ~= ".git"
+end
+
+local function get_entry_status(fs_entry)
+    local data = get_status_data(fs_entry)
+    if data == nil then
+        return nil
+    end
+
+    return lookup_status(data, fs_entry)
+end
+
+function M.highlight(fs_entry)
+    local status = get_entry_status(fs_entry)
+    return status_highlight(status)
+        or (fs_entry.fs_type == "directory" and "MiniFilesDirectory" or "MiniFilesFile")
+end
+
+function M.invalidate()
+    status_cache = {}
+    git_root_cache = {}
+    known_git_roots = {}
+end
+
+local function refresh()
+    M.invalidate()
+    if _G.MiniFiles == nil or MiniFiles.get_explorer_state() == nil then
+        return
+    end
+
+    vim.schedule(function()
+        if MiniFiles.get_explorer_state() ~= nil then
+            MiniFiles.refresh()
+        end
+    end)
+end
+
+local function refresh_filetree()
+    M.invalidate()
+    if _G.MiniFiles == nil or MiniFiles.get_explorer_state() == nil then
+        return
+    end
+
+    vim.schedule(function()
+        if MiniFiles.get_explorer_state() ~= nil then
+            MiniFiles.refresh({
+                content = {
+                    filter = M.filter,
+                    highlight = M.highlight,
+                },
+            })
+        end
+    end)
+end
+
+local function open_external()
+    local fs_entry = MiniFiles.get_fs_entry()
+    if fs_entry == nil then
+        vim.notify("No file system entry under the cursor", vim.log.levels.WARN)
+        return
+    end
+
+    vim.ui.open(fs_entry.path)
+end
+
+function M.setup()
+    local group = vim.api.nvim_create_augroup("romanzy_mini_files_git", { clear = true })
+
+    vim.api.nvim_create_autocmd("User", {
+        group = group,
+        pattern = "MiniFilesBufferCreate",
+        callback = function(args)
+            if args.data == nil then
+                return
+            end
+
+            for _, lhs in ipairs({ "gR", "<F5>" }) do
+                vim.keymap.set("n", lhs, refresh_filetree, {
+                    buffer = args.data.buf_id,
+                    desc = "refresh mini.files filetree",
+                })
+            end
+            vim.keymap.set("n", "gx", open_external, {
+                buffer = args.data.buf_id,
+                desc = "open mini.files entry externally",
+            })
+            vim.keymap.set("n", "<CR>", "L", {
+                buffer = args.data.buf_id,
+                remap = true,
+                desc = "go in entry plus (extra)",
+            })
+        end,
+    })
+    vim.api.nvim_create_autocmd({ "BufWritePost", "FocusGained", "TermClose" }, {
+        group = group,
+        callback = refresh,
+    })
+    vim.api.nvim_create_autocmd("User", {
+        group = group,
+        pattern = {
+            "GitSignsUpdate",
+            "LazyGitClosed",
+            "MiniFilesActionCreate",
+            "MiniFilesActionDelete",
+            "MiniFilesActionRename",
+            "MiniFilesActionCopy",
+            "MiniFilesActionMove",
+        },
+        callback = refresh,
+    })
+
+    return {
+        content = {
+            filter = M.filter,
+            highlight = M.highlight,
+        },
+    }
+end
+
+return M

nvim/.config/nvim/lua/romanzy/custom/spell.lua

@@ -0,0 +1,35 @@
+local M = {}
+
+--- Toggle spell checking for the current window.
+function M.toggle()
+    if vim.bo.buftype == "terminal" then
+        return
+    end
+
+    vim.opt_local.spell = not vim.wo.spell
+    vim.cmd("redrawstatus")
+end
+
+function M.setup()
+    vim.opt.spelllang = { "en_us" }
+    vim.opt.spell = true
+
+    local group = vim.api.nvim_create_augroup("RomanzySpell", { clear = true })
+
+    vim.api.nvim_create_autocmd("FileType", {
+        group = group,
+        pattern = "terminal",
+        callback = function()
+            vim.opt_local.spell = false
+        end,
+    })
+
+    vim.api.nvim_create_autocmd("TermOpen", {
+        group = group,
+        callback = function()
+            vim.cmd("setfiletype terminal")
+        end,
+    })
+end
+
+return M

nvim/.config/nvim/lua/romanzy/custom/tabline.lua

@@ -16,6 +16,9 @@ function M.render()
     return table.concat(parts)
 end
 
+function M.setup()
     _G.RomanzyTabline = M.render
+    vim.opt.tabline = "%!v:lua.RomanzyTabline()"
+end
 
 return M

nvim/.config/nvim/lua/romanzy/custom/wrap.lua

@@ -0,0 +1,18 @@
+local M = {}
+
+--- Toggle wrapping, or force it to the provided state.
+--- @param enabled? boolean
+function M.toggle(enabled)
+    if enabled == nil then
+        enabled = not vim.wo.wrap
+    end
+
+    vim.wo.wrap = enabled
+    vim.wo.linebreak = enabled
+    vim.wo.breakindent = enabled
+    vim.wo.colorcolumn = enabled and "" or "80"
+    vim.bo.textwidth = enabled and 0 or 80
+    vim.bo.wrapmargin = 0
+end
+
+return M

nvim/.config/nvim/lua/romanzy/keymaps.lua

@@ -18,20 +18,36 @@ local function telescope_picker(picker)
     end
 end
 
+local function open_mini_files_at_current_buffer()
+    local current_path = vim.api.nvim_buf_get_name(0)
+    if vim.bo.buftype ~= "" or current_path == "" then
+        current_path = nil
+    end
+
+    MiniFiles.open(current_path)
+end
+
 map("n", "<leader><leader>r", ":source ~/.config/nvim/init.lua<CR>", { desc = "reload init.lua" })
 map("n", "<leader><leader>h", telescope_picker("keymaps"), { desc = "show keymaps" })
-map("n", "<leader>dl", "<Cmd>Oil<CR>", { desc = "open oil" })
+map("n", "<leader>e", open_mini_files_at_current_buffer, { desc = "open mini.files" })
 map("n", "<leader>ff", telescope_picker("find_files"), { desc = "find files" })
 map("n", "<leader>fg", telescope_picker("live_grep"), { desc = "live grep" })
 map("n", "<leader>fb", telescope_picker("buffers"), { desc = "find buffers" })
 map("n", "<leader>fh", telescope_picker("help_tags"), { desc = "help tags" })
 map("n", "<leader>lg", "<Cmd>LazyGit<CR>", { desc = "open lazygit" })
+map("n", "<leader>dv", "<Cmd>DiffviewOpen<CR>", { desc = "open diffview" })
+map("n", "<leader>dc", "<Cmd>DiffviewClose<CR>", { desc = "close diffview" })
+map("n", "<leader>tw", require("romanzy.custom.wrap").toggle, { desc = "toggle soft wrap" })
+map("n", "<leader>ts", require("romanzy.custom.spell").toggle, { desc = "toggle spell checking" })
+map("n", "<leader>th", function()
+    MiniDiff.toggle_overlay()
+end, { desc = "toggle hunk view" })
 
--- map("n", "<leader>s", ":set spell!<CR>", { desc = "toggle spell" })
 map("n", "<leader>sv", "<Cmd>vs<CR>", { desc = "split vertical" })
 map("n", "<leader>sh", "<Cmd>sp<CR>", { desc = "split horizontal" })
 map("n", "<leader>se", "<C-w>=", { desc = "equalize splits" })
 map("n", "<leader>sc", "<C-w>c", { desc = "close split" })
+
 map("n", "<leader>rh", "<Cmd>vertical resize -10<CR>", { desc = "make buffer narrower" })
 map("n", "<leader>rl", "<Cmd>vertical resize +10<CR>", { desc = "make buffer wider" })
 map("n", "<leader>rj", "<Cmd>resize -5<CR>", { desc = "make buffer shorter" })
@@ -41,24 +57,22 @@ map("n", "<leader>re", "<C-w>=", { desc = "equalize buffer sizes" })
 map("n", "<leader>bp", "<Cmd>bprevious<CR>", { desc = "prev buffer" })
 map("n", "<leader>bn", "<Cmd>bnext<CR>", { desc = "next buffer" })
 map("n", "<leader>bd", "<Cmd>bdelete<CR>", { desc = "delete buffer" })
+map("n", "<leader>bc", require("romanzy.custom.buffers").close_hidden, { desc = "close hidden buffers" })
+map("n", "<leader>bf", telescope_picker("buffers"), { desc = "find buffers" })
 
 map({ "n", "v" }, "<leader>y", '"+y', { desc = "yank to system clipboard" })
 map("n", "<leader>Y", '"+Y', { desc = "yank line to system clipboard" })
 map("n", "<leader>p", '"+p', { desc = "paste from system clipboard" })
 map("n", "<leader>P", '"+P', { desc = "paste before from system clipboard" })
 
-map("t", "\\\\", "<C-\\><C-n>", { desc = "exit terminal" })
-map("t", "<C-\\><C-\\>", "<C-\\><C-n>", { desc = "exit terminal" })
-map("t", "<C-Esc>", "<C-\\><C-n>", { desc = "exit terminal" })
-map("t", "\\<Esc>", "<C-\\><C-n>", { desc = "exit terminal" })
+-- experimenting
+map("t", { "\\\\", "<C-\\><C-\\>", "<C-Esc>", "\\<Esc>" }, "<C-\\><C-n>", { desc = "exit terminal" })
 
 map("n", "<C-h>", "<C-w>h", { desc = "window left" })
 map("n", "<C-j>", "<C-w>j", { desc = "window down" })
 map("n", "<C-k>", "<C-w>k", { desc = "window up" })
 map("n", "<C-l>", "<C-w>l", { desc = "window right" })
-map("n", "gR", function()
-    vim.cmd.normal({ args = { vim.keycode("<C-l>") }, bang = true })
-end, { desc = "refresh current view" })
+map("n", { "gR", "<F5>" }, "<Cmd>edit<CR>", { desc = "refresh current buffer" })
 
 -- this is needed to disable refresh behavior for <C-l> for navigation
 vim.api.nvim_create_autocmd("FileType", {
@@ -72,7 +86,7 @@ vim.api.nvim_create_autocmd("FileType", {
 })
 
 -- hjkl supremacy
-map({ "n", "i", "v", "x", "s", "o", "c" }, { "<left>", "<right>", "<up>", "<down>" }, function()
+map({ "n", "v", "i" }, { "<left>", "<right>", "<up>", "<down>" }, function()
     vim.notify('hjkl supremacy', vim.log.levels.ERROR)
 end, { desc = "hjkl supremacy" })
 
@@ -100,18 +114,44 @@ vim.api.nvim_create_autocmd("LspAttach", {
     callback = function(ev)
         map("n", "gd", vim.lsp.buf.definition, { buffer = ev.buf, desc = "goto definition" })
         map("n", "gD", vim.lsp.buf.declaration, { buffer = ev.buf, desc = "goto declaration" })
-        map("n", "gfr", vim.lsp.buf.references, { buffer = ev.buf, desc = "list references" })
-        map("n", "grd", vim.lsp.buf.references, { buffer = ev.buf, desc = "list references" })
-        map("n", "grn", rename_without_default, { buffer = ev.buf, desc = "rename symbol from zero" })
-        map("n", "gRN", vim.lsp.buf.rename, { buffer = ev.buf, desc = "rename symbol" })
-        -- map("i", "<C-Space>", vim.lsp.completion.get, { buffer = ev.buf, desc = "trigger completion" })
+        map("n", "gfr", vim.lsp.buf.references, { buffer = ev.buf, desc = "find references" })
+        map("n", "grn", rename_without_default, { buffer = ev.buf, desc = "rename symbol (from empty)" })
+        map("n", "grN", vim.lsp.buf.rename, { buffer = ev.buf, desc = "rename symbol (from current)" })
+
+        map({ "n", "x" }, "<leader>ca", vim.lsp.buf.code_action, { buffer = ev.buf, desc = "code actions" })
+        map("n", "<leader>cf", function()
+            vim.lsp.buf.code_action({
+                apply = true,
+                context = {
+                    only = { "quickfix" },
+                },
+            })
+        end, { buffer = ev.buf, desc = "quick fixes" })
+        map({ "n", "x" }, "<leader>cs", function()
+            vim.lsp.buf.code_action({
+                context = {
+                    only = { "source" },
+                },
+            })
+        end, { buffer = ev.buf, desc = "source actions" })
     end,
 })
 
+-- diagnostics
+map("n", "<leader>xx", function()
+    require("trouble").toggle({
+        mode = "diagnostics",
+        filter = {
+            severity = {
+                vim.diagnostic.severity.ERROR,
+                vim.diagnostic.severity.WARN,
+            },
+        },
+    })
+end, { desc = "toggle project warnings and errors" })
 map("n", "g.", vim.diagnostic.open_float, { desc = "line diagnostics" })
 map("n", "gl", vim.diagnostic.setloclist, { desc = "diagnostic list" })
 
--- diagnostics on warnings and errors.
 map("n", "]g", function()
     vim.diagnostic.jump({
         count = 1,
@@ -130,9 +170,9 @@ map("n", "[g", function()
 end, { desc = "prev warning/error" })
 
 map("n", "gld", vim.diagnostic.setloclist, { desc = "display diagnostic information" })
-map("n", "gid", function()
+map("n", "<leader>ti", function()
     vim.diagnostic.config({ virtual_text = not vim.diagnostic.config().virtual_text })
 end, { desc = "toggle inline diagnostics" })
-map("n", "gvd", function()
+map("n", "<leader>tv", function()
     vim.diagnostic.config({ virtual_lines = not vim.diagnostic.config().virtual_lines })
-end, { desc = "toggle virtual line diagnostics" })
+end, { desc = "toggle virtual diagnostics" })

nvim/.config/nvim/lua/romanzy/options.lua

@@ -1,6 +1,5 @@
 local g = vim.g
 local o = vim.opt
-
 g.mapleader = " "       -- Uses space as the global leader key.
 g.maplocalleader = " "  -- Uses space as the local leader key.
 g.clipboard = "osc52"   -- Routes the + and * registers through OSC52 in terminal Neovim.
@@ -11,7 +10,7 @@ o.cursorline = true -- Highlights the line under the cursor.
 o.textwidth = 80        -- Wraps inserted text after 80 columns when formatting is active.
 o.scrolloff = 8         -- Keeps context lines visible around the cursor.
 o.signcolumn = "yes"    -- Always reserves space for signs in the gutter.
-o.colorcolumn = "+1" -- Highlights the preferred maximum line width.
+o.colorcolumn = "80"    -- Highlights the preferred maximum line width.
 o.wrap = false          -- Prevents long lines from wrapping on screen.
 o.list = true           -- Displays whitespace characters using listchars.
 o.listchars = {
@@ -30,10 +29,10 @@ o.expandtab = true -- Inserts spaces when indenting by default.
 o.smartindent = true                                         -- Adds indentation automatically on new lines.
 o.swapfile = false                                           -- Disables swapfile creation.
 o.incsearch = true                                           -- Updates search matches as you type.
+o.completeopt = { "menuone", "noinsert", "fuzzy", "nosort" } -- Enables fuzzy completion matching.
+o.pumheight = 8                                              -- Limits the completion popup menu size.
 o.updatetime = 50                                            -- Reduces idle delay for swap and CursorHold events.
-o.spelllang = { "en_us" } -- Uses US English for spell checking.
 o.shell = "bash"                                             -- Runs shell commands through bash.
-o.tabline = "%!v:lua.RomanzyTabline()" -- Shows native tabs with custom labels.
 
 -- Only show the invisible characters inside the code editing buffers
 vim.cmd([[autocmd BufWinEnter * if &buftype != '' | setlocal nolist | endif]])

nvim/.config/nvim/lua/romanzy/plugins.lua

@@ -1,14 +1,13 @@
 require("romanzy.plugins.rose-pine")
 require("romanzy.plugins.mini")
-require("romanzy.plugins.blink-cmp")
 require("romanzy.plugins.lazygit")
+require("romanzy.plugins.diffview")
+require("romanzy.plugins.trouble")
 require("romanzy.plugins.oil")
 require("romanzy.plugins.telescope")
 require("romanzy.plugins.nvim-treesitter")
 require("romanzy.plugins.conform")
 require("romanzy.plugins.lsp")
--- require("romanzy.plugins.header42")
 require("romanzy.plugins.codamheader")
-
--- custom "plugins"
-require("romanzy.custom.tabline")
+require("romanzy.custom.spell").setup()
+require("romanzy.custom.tabline").setup()

nvim/.config/nvim/lua/romanzy/plugins/blink-cmp.lua

@@ -1,39 +0,0 @@
-vim.pack.add({ 'https://github.com/saghen/blink.lib', 'https://github.com/saghen/blink.cmp' })
-
-local cmp = require('blink.cmp')
--- cmp.build():pwait()
-cmp.setup({
-    -- 'default' (recommended) for mappings similar to built-in completions (C-y to accept)
-    -- 'super-tab' for mappings similar to vscode (tab to accept)
-    -- 'enter' for enter to accept
-    -- 'none' for no mappings
-    --
-    -- All presets have the following mappings:
-    -- C-space: Open menu or open docs if already open
-    -- C-n/C-p or Up/Down: Select next/previous item
-    -- C-e: Hide menu
-    -- C-k: Toggle signature help (if signature.enabled = true)
-    --
-    -- See :h blink-cmp-config-keymap for defining your own keymap
-    keymap = { preset = 'default' },
-
-    completion = {
-        documentation = { auto_show = false },
-        -- list = {
-        --     selection = {
-        --         preselect = false,
-        --         auto_insert = false,
-        --     },
-        -- },
-    },
-
-    -- (Default) list of enabled providers defined so that you can extend it
-    -- elsewhere in your config, without redefining it, due to `opts_extend`
-    sources = { default = { 'lsp', 'path', 'snippets', 'buffer' } },
-
-    -- (Default) Rust fuzzy matcher for typo resistance and significantly better performance
-    -- You may use a lua implementation instead by using `implementation = "lua"`
-    -- See the fuzzy documentation for more information
-    -- fuzzy = { implementation = "prefer_rust_with_warning" }
-    fuzzy = { implementation = "lua" }
-})

nvim/.config/nvim/lua/romanzy/plugins/conform.lua

@@ -5,16 +5,35 @@ vim.pack.add({
     },
 })
 
+local dart = require("romanzy.custom.dart")
+
 require("conform").setup({
     formatters_by_ft = {
+        dart = { "dart_format" },
         javascript = { "prettier" },
         javascriptreact = { "prettier" },
         typescript = { "prettier" },
         typescriptreact = { "prettier" },
+        markdown = { "prettier" },
         c = { filter = function() return false end },
         cpp = { filter = function() return false end },
         h = { filter = function() return false end }
     },
+    formatters = {
+        prettier = {
+            prepend_args = function(_, ctx)
+                if vim.bo[ctx.buf].filetype == "markdown" then
+                    return { "--prose-wrap=always", "--print-width=80" }
+                end
+                return {}
+            end,
+        },
+        dart_format = {
+            command = function(_, ctx)
+                return dart.executable(ctx.filename)
+            end,
+        },
+    },
     format_on_save = {
         lsp_format = "fallback",
         timeout_ms = 2000,

nvim/.config/nvim/lua/romanzy/plugins/diffview.lua

@@ -0,0 +1,6 @@
+vim.pack.add({
+    {
+        src = "https://github.com/sindrets/diffview.nvim",
+        name = "diffview.nvim",
+    },
+})

nvim/.config/nvim/lua/romanzy/plugins/header42.lua

@@ -1,27 +0,0 @@
-vim.pack.add({
-  { src = "https://codeberg.org/42nerds/header42.nvim" },
-})
-
-local function load_header42()
-  -- Prevent double loading
-  if _G.header42_loaded then return end
-  _G.header42_loaded = true
-
-  -- Configure the plugin
-  require("header42").setup({
-    -- autocmd = { create = false },
-    username = "rvolovoy",
-    email = "rvolovoy@student.codam.nl",
-  })
-end
-
--- load it right away
--- load_header42();
-
-vim.api.nvim_create_autocmd("FileType", {
-  pattern = { "c", "cpp", "python" },
-  once = true,
-  callback = function()
-    load_header42()
-  end,
-})

nvim/.config/nvim/lua/romanzy/plugins/lsp.lua

@@ -15,25 +15,13 @@ vim.pack.add({
 
 local mason_lspconfig = require("mason-lspconfig")
 
-local diag_inline_enabled = true
-
-local function diag_virtual_text()
-    if not diag_inline_enabled then
-        return false
-    end
-
-    return {
-        severity = vim.diagnostic.severity.WARN,
-    }
-end
-
 local function configure_diagnostics()
     vim.diagnostic.config({
         severity_sort = true,
         signs = true,
         underline = true,
         update_in_insert = false,
-        virtual_text = diag_virtual_text(),
+        virtual_text = true,
         float = {
             border = "rounded",
             source = "if_many",
@@ -43,26 +31,32 @@ end
 
 configure_diagnostics()
 
-local capabilities = require("blink.cmp").get_lsp_capabilities()
+local capabilities = require("mini.completion").get_lsp_capabilities()
+local dart = require("romanzy.custom.dart")
 local managed_servers = {
     "bashls",
     "clangd",
+    "gopls",
     "jsonls",
     "lua_ls",
     "marksman",
     "taplo",
-    "tailwindcss",
-    "ts_ls",
     "yamlls",
+    "ts_ls",
+    "tailwindcss",
+    "eslint",
+    "tinymist",
+}
+local managed_tools = {
+    "prettier",
 }
 local servers = {
     bashls = {},
     clangd = {},
+    gopls = {},
     jsonls = {},
     marksman = {},
     taplo = {},
-    tailwindcss = {},
-    ts_ls = {},
     yamlls = {},
     lua_ls = {
         settings = {
@@ -80,6 +74,22 @@ local servers = {
             },
         },
     },
+    ts_ls = {},
+    tailwindcss = {},
+    eslint = {},
+    tinymist = {},
+    dartls = {
+        cmd = function(dispatchers, config)
+            return vim.lsp.rpc.start({
+                dart.executable(config.root_dir),
+                "language-server",
+                "--protocol=lsp",
+            }, dispatchers, {
+                cwd = config.root_dir,
+                detached = config.detached,
+            })
+        end,
+    },
 }
 
 for server_name, config in pairs(servers) do
@@ -93,3 +103,15 @@ mason_lspconfig.setup({
     ensure_installed = managed_servers,
     automatic_enable = managed_servers,
 })
+
+vim.lsp.enable("dartls")
+
+local mason_registry = require("mason-registry")
+mason_registry.refresh(vim.schedule_wrap(function()
+    for _, tool_name in ipairs(managed_tools) do
+        local tool = mason_registry.get_package(tool_name)
+        if not tool:is_installed() and not tool:is_installing() then
+            tool:install()
+        end
+    end
+end))

nvim/.config/nvim/lua/romanzy/plugins/mini.lua

@@ -6,24 +6,34 @@ vim.pack.add({
     },
 })
 
-local clue = require("mini.clue")
 local icons = require("mini.icons")
+local input = require("mini.input")
+local clue = require("mini.clue")
+local completion = require("mini.completion")
+local files = require("mini.files")
 local git = require("mini.git")
 local diff = require("mini.diff")
 local statusline = require("mini.statusline")
+local cmdline = require("mini.cmdline")
 local hipatterns = require("mini.hipatterns")
+local pairs = require("mini.pairs")
 local ai = require("mini.ai")
 local notify = require("mini.notify")
 local surround = require("mini.surround")
 
-local function set_mini_diff_highlights()
-    vim.api.nvim_set_hl(0, "MiniDiffSignAdd", { fg = "#9ccf8d" })
-    vim.api.nvim_set_hl(0, "MiniDiffSignChange", { fg = "#f6c177" })
-    vim.api.nvim_set_hl(0, "MiniDiffSignDelete", { fg = "#eb6f92" })
-    vim.api.nvim_set_hl(0, "MiniDiffOverAdd", { fg = "#9ccf8d" })
-    vim.api.nvim_set_hl(0, "MiniDiffOverChange", { fg = "#f6c177" })
-    vim.api.nvim_set_hl(0, "MiniDiffOverDelete", { fg = "#eb6f92" })
-end
+icons.setup({})
+
+local input_view = input.gen_view.floatwin({
+    -- other interesting symbols for the caret `▏` `⎕` `░` `▒` `▓`
+    to_chunks = function(state, max_width)
+        return input.state_to_chunks(state, max_width, {
+            include_prompt = false,
+            include_hint = false,
+            symbol_caret = "█",
+        })
+    end,
+})
+input.setup({ handlers = { view = input_view } })
 
 clue.setup({
     triggers = {
@@ -46,32 +56,103 @@ clue.setup({
     },
 })
 
-icons.setup({})
+files.setup(require("romanzy.custom.mini_files").setup())
+
 git.setup({})
+
 diff.setup({})
+local function set_mini_diff_highlights()
+    vim.api.nvim_set_hl(0, "MiniDiffSignAdd", { fg = "#9ccf8d", bold = true })
+    vim.api.nvim_set_hl(0, "MiniDiffSignChange", { fg = "#f6c177", bold = true })
+    vim.api.nvim_set_hl(0, "MiniDiffSignDelete", { fg = "#eb6f92", bold = true })
+    vim.api.nvim_set_hl(0, "MiniDiffOverAdd", { fg = "#9ccf8d", bg = "#333c48", bold = true })
+    vim.api.nvim_set_hl(0, "MiniDiffOverChange", { fg = "#eb6f92", bg = "#43293a", bold = true })
+    vim.api.nvim_set_hl(0, "MiniDiffOverChangeBuf", { fg = "#9ccf8d", bg = "#333c48", bold = true })
+    vim.api.nvim_set_hl(0, "MiniDiffOverContext", { fg = "#908caa", bg = "#26233a" })
+    vim.api.nvim_set_hl(0, "MiniDiffOverContextBuf", { fg = "#e0def4", bg = "#1f1d2e" })
+    vim.api.nvim_set_hl(0, "MiniDiffOverDelete", { fg = "#eb6f92", bg = "#43293a", bold = true })
+end
 set_mini_diff_highlights()
 vim.api.nvim_create_autocmd("ColorScheme", {
     callback = set_mini_diff_highlights,
 })
-statusline.setup({ use_icons = true })
+
+-- Custom de-cluttered status line output. The default was waaay to noisy
+local function statusline_active()
+    local function statusline_filetype()
+        local filetype = vim.bo.filetype
+        if filetype == "" then
+            return ""
+        end
+
+        local icon = MiniIcons.get("filetype", filetype)
+        return icon .. " " .. filetype
+    end
+
+    local function statusline_spell()
+        return vim.wo.spell and "spell" or ""
+    end
+
+    local mode, mode_hl = statusline.section_mode({ trunc_width = 120 })
+    local git_info = statusline.section_git({ trunc_width = 40 })
+    -- local diff_info = statusline.section_diff({ trunc_width = 75 })
+    -- local diagnostics = statusline.section_diagnostics({ trunc_width = 75 })
+    local lsp = statusline.section_lsp({ trunc_width = 75 })
+    local filename = statusline.section_filename({ trunc_width = 140 })
+    local spell = statusline_spell()
+    local fileinfo = statusline_filetype()
+    local search = statusline.section_searchcount({ trunc_width = 75 })
+
+    return statusline.combine_groups({
+        { hl = mode_hl,                 strings = { mode } },
+        { hl = "MiniStatuslineDevinfo", strings = { git_info, lsp } },
+        "%<",
+        { hl = "MiniStatuslineFilename", strings = { filename } },
+        "%=",
+        { hl = "MiniStatuslineFileinfo", strings = { spell, fileinfo } },
+        { hl = mode_hl,                  strings = { search } },
+    })
+end
+
+statusline.setup({
+    use_icons = true,
+    content = { active = statusline_active },
+})
+
+cmdline.setup({})
+
 hipatterns.setup({
     highlighters = {
         fixme = { pattern = "%f[%w]()FIXME()%f[%W]", group = "MiniHipatternsFixme" },
         hack = { pattern = "%f[%w]()HACK()%f[%W]", group = "MiniHipatternsHack" },
         todo = { pattern = "%f[%w]()TODO()%f[%W]", group = "MiniHipatternsTodo" },
         note = { pattern = "%f[%w]()NOTE()%f[%W]", group = "MiniHipatternsNote" },
-        file = { pattern = "%f[%w]()FILE()%f[%W]", group = "MiniHipatternsNote" },
         hex_color = hipatterns.gen_highlighter.hex_color(),
     },
 })
+
+pairs.setup({
+    modes = { insert = true, command = true, terminal = false },
+})
+
+completion.setup({})
+vim.keymap.set("i", "<CR>", function()
+    if vim.fn.complete_info({ "selected" }).selected ~= -1 then
+        return "\25"
+    end
+
+    return MiniPairs.cr()
+end, { expr = true })
+
 ai.setup({})
+
 notify.setup({
     lsp_progress = {
         -- the message "lua_ls: processing completion..." and
         -- "lua_ls: Diagnosing" is very annoying
-        enable = true,
+        -- enable = true,
     },
 })
-
 vim.notify = notify.make_notify()
+
 surround.setup({})

nvim/.config/nvim/lua/romanzy/plugins/nvim-treesitter.lua

@@ -2,6 +2,7 @@ local parsers = {
     "bash",
     "c",
     "gitcommit",
+    "go",
     "javascript",
     "json",
     "lua",
@@ -18,6 +19,7 @@ local filetypes = {
     "bash",
     "c",
     "gitcommit",
+    "go",
     "javascript",
     "json",
     "lua",

nvim/.config/nvim/lua/romanzy/plugins/oil.lua

@@ -1,57 +1,89 @@
-vim.pack.add({
-    {
-        src = "https://github.com/stevearc/oil.nvim",
-        name = "oil.nvim",
-    },
-    {
-        src = "https://github.com/malewicz1337/oil-git.nvim",
-        name = "oil-git.nvim",
-    },
-})
-
-local function set_oil_git_highlights()
-    vim.api.nvim_set_hl(0, "OilGitAdded", { link = "MiniDiffSignAdd" })
-    vim.api.nvim_set_hl(0, "OilGitUntracked", { link = "MiniDiffSignAdd" })
-    vim.api.nvim_set_hl(0, "OilGitModifiedStaged", { link = "MiniDiffSignChange" })
-    vim.api.nvim_set_hl(0, "OilGitModifiedUnstaged", { link = "MiniDiffSignChange" })
-    vim.api.nvim_set_hl(0, "OilGitRenamed", { link = "MiniDiffSignChange" })
-    vim.api.nvim_set_hl(0, "OilGitCopied", { link = "MiniDiffSignChange" })
-    vim.api.nvim_set_hl(0, "OilGitDeleted", { link = "MiniDiffSignDelete" })
-    vim.api.nvim_set_hl(0, "OilGitConflict", { link = "MiniDiffSignDelete" })
-end
-
-require("oil").setup({
-    keymaps = {
-        ["<C-h>"] = false,
-        ["<C-j>"] = false,
-        ["<C-k>"] = false,
-        ["<C-l>"] = false,
-        ["gR"] = "actions.refresh", -- replaces default <C-l> behavior
-        ["<C-s>"] = false,
-        ["<C-p>"] = { "actions.preview", opts = { vertical = true, split = "belowright" } },
-        ["<BS>"] = { "actions.parent", mode = "n" },
-    },
-    view_options = {
-        show_hidden = true,
-        is_hidden_file = function(name, _)
-            return vim.startswith(name, ".")
-        end,
-        is_always_hidden = function(name, _)
-            return name == ".git"
-        end,
-    },
-})
-
-require("oil-git").setup({
-    show_file_highlights = true,
-    show_directory_highlights = true,
-    show_file_symbols = true,
-    show_directory_symbols = true,
-    symbol_position = "none",
-})
-
-set_oil_git_highlights()
-vim.api.nvim_create_autocmd("ColorScheme", {
-    group = vim.api.nvim_create_augroup("romanzy_oil_git_highlights", { clear = true }),
-    callback = set_oil_git_highlights,
-})
+-- vim.pack.add({
+--     {
+--         src = "https://github.com/stevearc/oil.nvim",
+--         name = "oil.nvim",
+--     },
+--     {
+--         src = "https://github.com/malewicz1337/oil-git.nvim",
+--         name = "oil-git.nvim",
+--     },
+-- })
+--
+-- local function set_oil_git_highlights()
+--     vim.api.nvim_set_hl(0, "OilGitAdded", { link = "MiniDiffSignAdd" })
+--     vim.api.nvim_set_hl(0, "OilGitUntracked", { link = "MiniDiffSignAdd" })
+--     vim.api.nvim_set_hl(0, "OilGitModifiedStaged", { link = "MiniDiffSignChange" })
+--     vim.api.nvim_set_hl(0, "OilGitModifiedUnstaged", { link = "MiniDiffSignChange" })
+--     vim.api.nvim_set_hl(0, "OilGitRenamed", { link = "MiniDiffSignChange" })
+--     vim.api.nvim_set_hl(0, "OilGitCopied", { link = "MiniDiffSignChange" })
+--     vim.api.nvim_set_hl(0, "OilGitDeleted", { link = "MiniDiffSignDelete" })
+--     vim.api.nvim_set_hl(0, "OilGitConflict", { link = "MiniDiffSignDelete" })
+--     vim.api.nvim_set_hl(0, "OilGitIgnored", { link = "Comment" })
+-- end
+--
+-- require("oil").setup({
+--     keymaps = {
+--         ["<C-h>"] = false,
+--         ["<C-j>"] = false,
+--         ["<C-k>"] = false,
+--         ["<C-l>"] = false,
+--         ["gR"] = "actions.refresh", -- replaces default <C-l> behavior
+--         ["<F5>"] = "actions.refresh",
+--         ["<C-s>"] = false,
+--         ["<C-p>"] = { "actions.preview", opts = { vertical = true, split = "belowright" } },
+--         ["<BS>"] = { "actions.parent", mode = "n" },
+--     },
+--     view_options = {
+--         show_hidden = true,
+--         is_hidden_file = function(_, _)
+--             return false
+--         end,
+--         is_always_hidden = function(name, _)
+--             return name == ".git"
+--         end,
+--     },
+-- })
+--
+-- local oil_git_trie = require("oil-git.trie")
+-- local oil_git_lookup = oil_git_trie.lookup
+--
+-- -- ugly internal monkey patch to not show partially git-ignored foldres as grey
+-- rawset(oil_git_trie, "lookup", function(root, entry_path, git_root, exclude_ignored)
+--     local status = oil_git_lookup(root, entry_path, git_root, exclude_ignored)
+--     if status ~= "!!" or exclude_ignored then
+--         return status
+--     end
+--
+--     local relative_path = entry_path:sub(#git_root + 2)
+--     local node = root
+--     for segment in relative_path:gmatch("[^/\\]+") do
+--         node = node.children[segment]
+--         if not node then
+--             return nil
+--         end
+--     end
+--
+--     -- oil-git normally propagates an ignored child's status to every parent.
+--     -- Only grey a directory when Git reported that directory itself as ignored.
+--     if not node.is_dir_ignored then
+--         return nil
+--     end
+--
+--     return status
+-- end)
+--
+-- require("oil-git").setup({
+--     show_file_highlights = true,
+--     show_directory_highlights = true,
+--     show_ignored_files = true,
+--     show_ignored_directories = true,
+--     show_file_symbols = true,
+--     show_directory_symbols = true,
+--     symbol_position = "none",
+-- })
+--
+-- set_oil_git_highlights()
+-- vim.api.nvim_create_autocmd("ColorScheme", {
+--     group = vim.api.nvim_create_augroup("romanzy_oil_git_highlights", { clear = true }),
+--     callback = set_oil_git_highlights,
+-- })

nvim/.config/nvim/lua/romanzy/plugins/telescope.lua

@@ -15,7 +15,7 @@ require("telescope").setup({
             filesize_limit = 0.1, -- in MB
         },
         initial_mode = "insert",
-        -- winblend = 30,
+        -- winblend = 50,
         file_ignore_patterns = {
             "%.git/.*",
             "%.cache/.*",

nvim/.config/nvim/lua/romanzy/plugins/trouble.lua

@@ -0,0 +1,8 @@
+vim.pack.add({
+    {
+        src = "https://github.com/folke/trouble.nvim",
+        name = "trouble.nvim",
+    },
+})
+
+require("trouble").setup()

nvim/.config/nvim/nvim-pack-lock.json

@@ -1,13 +1,5 @@
 {
   "plugins": {
-    "blink.cmp": {
-      "rev": "bda905a4bf1b3edfa708b0be193b8c63d8620c96",
-      "src": "https://github.com/saghen/blink.cmp"
-    },
-    "blink.lib": {
-      "rev": "5876dd95deeb70aadbe9f1c0b7117a135061cdac",
-      "src": "https://github.com/saghen/blink.lib"
-    },
     "codam-header.nvim": {
       "rev": "a8fbd2a7003eecbf6e85693e85d7d4d464625193",
       "src": "https://github.com/BeerB34r/codam-header.nvim"
@@ -16,16 +8,16 @@
       "rev": "619363c30309d29ffa631e67c8183f2a72caa373",
       "src": "https://github.com/stevearc/conform.nvim"
     },
-    "header42.nvim": {
-      "rev": "d41468df1c53081c909fc78248cf233893b59809",
-      "src": "https://codeberg.org/42nerds/header42.nvim"
+    "diffview.nvim": {
+      "rev": "4516612fe98ff56ae0415a259ff6361a89419b0a",
+      "src": "https://github.com/sindrets/diffview.nvim"
     },
     "lazygit.nvim": {
       "rev": "a04ad0dbc725134edbee3a5eea29290976695357",
       "src": "https://github.com/kdheepak/lazygit.nvim"
     },
     "mason-lspconfig.nvim": {
-      "rev": "21c5b3ebeaa0412e28096bb0701434c51c1fbf76",
+      "rev": "47059d71b42d74b0a1e9f61c1d99d301039c3b5b",
       "src": "https://github.com/mason-org/mason-lspconfig.nvim"
     },
     "mason.nvim": {
@@ -33,11 +25,11 @@
       "src": "https://github.com/mason-org/mason.nvim"
     },
     "mini.nvim": {
-      "rev": "1599a473aa6f5290a5d740b1144846e6f0c3963d",
+      "rev": "c5cdbadeb423ff724e27a42ab2d1c504d1d6fc5a",
       "src": "https://github.com/echasnovski/mini.nvim"
     },
     "nvim-lspconfig": {
-      "rev": "bfcc0171a43f22afa61d927ffe9fcb6cb85dc99e",
+      "rev": "292f44408498103c47996ff5c18fd366293840d8",
       "src": "https://github.com/neovim/nvim-lspconfig"
     },
     "nvim-treesitter": {
@@ -63,6 +55,10 @@
     "telescope.nvim": {
       "rev": "427b576c16792edad01a92b89721d923c19ad60f",
       "src": "https://github.com/nvim-telescope/telescope.nvim"
+    },
+    "trouble.nvim": {
+      "rev": "bd67efe408d4816e25e8491cc5ad4088e708a69a",
+      "src": "https://github.com/folke/trouble.nvim"
     }
   }
 }