nvim 0.12 wip

.config/nvim/lua/config/autocmds.lua

@@ -0,0 +1,143 @@
+local function augroup(name)
+  return vim.api.nvim_create_augroup("user_" .. name, { clear = true })
+end
+
+-- Check if we need to reload the file when it changed
+vim.api.nvim_create_autocmd({ "FocusGained", "TermClose", "TermLeave" }, {
+  group = augroup("checktime"),
+  callback = function()
+    if vim.o.buftype ~= "nofile" then
+      vim.cmd("checktime")
+    end
+  end,
+})
+
+-- Highlight on yank
+vim.api.nvim_create_autocmd("TextYankPost", {
+  group = augroup("highlight_yank"),
+  callback = function()
+    (vim.hl or vim.highlight).on_yank()
+  end,
+})
+
+-- resize splits if window got resized
+vim.api.nvim_create_autocmd({ "VimResized" }, {
+  group = augroup("resize_splits"),
+  callback = function()
+    local current_tab = vim.fn.tabpagenr()
+    vim.cmd("tabdo wincmd =")
+    vim.cmd("tabnext " .. current_tab)
+  end,
+})
+
+
+-- make it easier to close man-files when opened inline
+vim.api.nvim_create_autocmd("FileType", {
+  group = augroup("man_unlisted"),
+  pattern = { "man" },
+  callback = function(event)
+    vim.bo[event.buf].buflisted = false
+  end,
+})
+
+-- close some filetypes with <q>
+vim.api.nvim_create_autocmd("FileType", {
+  group = augroup("close_with_q"),
+  pattern = {
+    "PlenaryTestPopup",
+    "checkhealth",
+    "dbout",
+    "gitsigns-blame",
+    "grug-far",
+    "help",
+    "lspinfo",
+    "neotest-output",
+    "neotest-output-panel",
+    "neotest-summary",
+    "notify",
+    "qf",
+    "spectre_panel",
+    "startuptime",
+    "tsplayground",
+  },
+  callback = function(event)
+    vim.bo[event.buf].buflisted = false
+    vim.schedule(function()
+      vim.keymap.set("n", "q", function()
+        vim.cmd("close")
+        pcall(vim.api.nvim_buf_delete, event.buf, { force = true })
+      end, {
+        buffer = event.buf,
+        silent = true,
+        desc = "Quit buffer",
+      })
+    end)
+  end,
+})
+
+-- wrap and check for spell in text filetypes
+vim.api.nvim_create_autocmd("FileType", {
+  group = augroup("wrap_spell"),
+  pattern = { "text", "plaintex", "typst", "gitcommit", "markdown" },
+  callback = function()
+    vim.opt_local.wrap = true
+    vim.opt_local.spell = true
+  end,
+})
+
+-- Fix conceallevel for json files
+vim.api.nvim_create_autocmd({ "FileType" }, {
+  group = augroup("json_conceal"),
+  pattern = { "json", "jsonc", "json5" },
+  callback = function()
+    vim.opt_local.conceallevel = 0
+  end,
+})
+
+-- Auto create dir when saving a file, in case some intermediate directory does not exist
+vim.api.nvim_create_autocmd({ "BufWritePre" }, {
+  group = augroup("auto_create_dir"),
+  callback = function(event)
+    if event.match:match("^%w%w+:[/][/]") then
+      return
+    end
+    local file = vim.uv.fs_realpath(event.match) or event.match
+    vim.fn.mkdir(vim.fn.fnamemodify(file, ":p:h"), "p")
+  end,
+})
+
+-- Set filetype for .env and .env.* files
+vim.api.nvim_create_autocmd({ "BufRead", "BufNewFile" }, {
+  group = augroup("env_filetype"),
+  pattern = { "*.env", ".env.*" },
+  callback = function()
+    vim.opt_local.filetype = "sh"
+  end,
+})
+
+-- Set filetype for .toml files
+vim.api.nvim_create_autocmd({ "BufRead", "BufNewFile" }, {
+  group = augroup("toml_filetype"),
+  pattern = { "*.tomg-config*" },
+  callback = function()
+    vim.opt_local.filetype = "toml"
+  end,
+})
+
+-- Set filetype for .ejs files
+vim.api.nvim_create_autocmd({ "BufRead", "BufNewFile" }, {
+  group = augroup("ejs_filetype"),
+  pattern = { "*.ejs", "*.ejs.t" },
+  callback = function()
+    vim.opt_local.filetype = "embedded_template"
+  end,
+})
+
+-- Set filetype for .code-snippets files
+vim.api.nvim_create_autocmd({ "BufRead", "BufNewFile" }, {
+  group = augroup("code_snippets_filetype"),
+  pattern = { "*.code-snippets" },
+  callback = function()
+    vim.opt_local.filetype = "json"
+  end,
+})

.config/nvim/lua/config/diagnostics.lua

@@ -0,0 +1,72 @@
+--- diagnostic settings
+local map = vim.keymap.set
+
+local palette = {
+  err = "#51202A",
+  warn = "#3B3B1B",
+  info = "#1F3342",
+  hint = "#1E2E1E",
+}
+
+vim.api.nvim_set_hl(0, "DiagnosticErrorLine", { bg = palette.err, blend = 20 })
+vim.api.nvim_set_hl(0, "DiagnosticWarnLine", { bg = palette.warn, blend = 15 })
+vim.api.nvim_set_hl(0, "DiagnosticInfoLine", { bg = palette.info, blend = 10 })
+vim.api.nvim_set_hl(0, "DiagnosticHintLine", { bg = palette.hint, blend = 10 })
+
+vim.api.nvim_set_hl(0, "DapBreakpointSign", { fg = "#FF0000", bg = nil, bold = true })
+vim.fn.sign_define("DapBreakpoint", {
+  text = "●", -- a large dot; change as desired
+  texthl = "DapBreakpointSign", -- the highlight group you just defined
+  linehl = "", -- no full-line highlight
+  numhl = "", -- no number-column highlight
+})
+
+local sev = vim.diagnostic.severity
+
+vim.diagnostic.config({
+  -- keep underline & severity_sort on for quick scanning
+  underline = true,
+  severity_sort = true,
+  update_in_insert = false, -- less flicker
+  float = {
+    border = "rounded",
+    source = true,
+  },
+  -- keep signs & virtual text, but tune them as you like
+  signs = {
+    text = {
+      [sev.ERROR] = " ",
+      [sev.WARN] = " ",
+      [sev.INFO] = " ",
+      [sev.HINT] = "󰌵 ",
+    },
+  },
+  virtual_text = {
+    spacing = 4,
+    source = "if_many",
+    prefix = "●",
+  },
+  -- NEW in 0.11 — dim whole line
+  linehl = {
+    [sev.ERROR] = "DiagnosticErrorLine",
+    [sev.WARN] = "DiagnosticWarnLine",
+    [sev.INFO] = "DiagnosticInfoLine",
+    [sev.HINT] = "DiagnosticHintLine",
+  },
+})
+
+-- diagnostic keymaps
+local diagnostic_goto = function(next, severity)
+  severity = severity and vim.diagnostic.severity[severity] or nil
+  return function()
+    vim.diagnostic.jump({ count = next and 1 or -1, float = true, severity = severity })
+  end
+end
+
+map("n", "<leader>cd", vim.diagnostic.open_float, { desc = "Line Diagnostics" })
+map("n", "]d", diagnostic_goto(true), { desc = "Next Diagnostic" })
+map("n", "[d", diagnostic_goto(false), { desc = "Prev Diagnostic" })
+map("n", "]e", diagnostic_goto(true, "ERROR"), { desc = "Next Error" })
+map("n", "[e", diagnostic_goto(false, "ERROR"), { desc = "Prev Error" })
+map("n", "]w", diagnostic_goto(true, "WARN"), { desc = "Next Warning" })
+map("n", "[w", diagnostic_goto(false, "WARN"), { desc = "Prev Warning" })

.config/nvim/lua/config/init.lua

@@ -0,0 +1,5 @@
+require("config.options")
+require("config.keymaps")
+require("config.diagnostics")
+require("config.autocmds")
+require("config.lsp")

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

@@ -0,0 +1,222 @@
+local map = vim.keymap.set
+local opts = { noremap = true, silent = true }
+
+-- ═══════════════════════════════════════════════════════════
+-- BUFFER NAVIGATION (think browser tabs)
+-- ═══════════════════════════════════════════════════════════
+
+-- Tab/Shift-Tab: Like browser tabs, feels natural
+map("n", "<Tab>", ":bnext<CR>", { desc = "Next buffer" })
+map("n", "<S-Tab>", ":bprevious<CR>", { desc = "Previous buffer" })
+
+-- Alternative buffer switching (vim-style)
+map("n", "<leader>bn", ":bnext<CR>", { desc = "Next buffer" })
+map("n", "<leader>bp", ":bprevious<CR>", { desc = "Previous buffer" })
+map("n", "<S-h>", "<cmd>bprevious<cr>", { desc = "Prev Buffer" })
+map("n", "<S-l>", "<cmd>bnext<cr>", { desc = "Next Buffer" })
+map("n", "[b", "<cmd>bprevious<cr>", { desc = "Prev Buffer" })
+map("n", "]b", "<cmd>bnext<cr>", { desc = "Next Buffer" })
+
+-- Quick switch to last edited file (super useful!)
+map("n", "<leader>bb", "<cmd>e #<cr>", { desc = "Switch to Other Buffer" })
+map("n", "<leader>`", "<cmd>e #<cr>", { desc = "Switch to Other Buffer" })
+
+-- ═══════════════════════════════════════════════════════════
+-- WINDOW MANAGEMENT (splitting and navigation)
+-- ═══════════════════════════════════════════════════════════
+
+-- Move between windows with Ctrl+hjkl (like tmux)
+map("n", "<C-h>", "<C-w>h", { desc = "Go to Left Window", remap = true })
+map("n", "<C-j>", "<C-w>j", { desc = "Go to Lower Window", remap = true })
+map("n", "<C-k>", "<C-w>k", { desc = "Go to Upper Window", remap = true })
+map("n", "<C-l>", "<C-w>l", { desc = "Go to Right Window", remap = true })
+
+-- Resize windows with Ctrl+Shift+arrows (macOS friendly)
+map("n", "<C-S-Up>", "<cmd>resize +5<CR>", opts)
+map("n", "<C-S-Down>", "<cmd>resize -5<CR>", opts)
+map("n", "<C-S-Left>", "<cmd>vertical resize -5<CR>", opts)
+map("n", "<C-S-Right>", "<cmd>vertical resize +5<CR>", opts)
+
+-- Window splitting
+map("n", "<leader>ww", "<C-W>p", { desc = "Other Window", remap = true })
+map("n", "<leader>wd", "<C-W>c", { desc = "Delete Window", remap = true })
+map("n", "<leader>w-", "<C-W>s", { desc = "Split Window Below", remap = true })
+map("n", "<leader>sh", "<C-W>s", { desc = "Split Window Below", remap = true })
+map("n", "<leader>w|", "<C-W>v", { desc = "Split Window Right", remap = true })
+map("n", "<leader>|", "<C-W>v", { desc = "Split Window Right", remap = true })
+map("n", "<leader>sv", "<C-W>v", { desc = "Split Window Right", remap = true })
+
+-- ═══════════════════════════════════════════════════════════
+-- SMART LINE MOVEMENT (the VSCode experience)
+-- ═══════════════════════════════════════════════════════════
+
+-- Smart j/k: moves by visual lines when no count, real lines with count
+map({ "n", "x" }, "j", "v:count == 0 ? 'gj' : 'j'", { desc = "Down", expr = true, silent = true })
+map({ "n", "x" }, "<Down>", "v:count == 0 ? 'gj' : 'j'", { desc = "Down", expr = true, silent = true })
+map({ "n", "x" }, "k", "v:count == 0 ? 'gk' : 'k'", { desc = "Up", expr = true, silent = true })
+map({ "n", "x" }, "<Up>", "v:count == 0 ? 'gk' : 'k'", { desc = "Up", expr = true, silent = true })
+
+-- Move lines up/down (Alt+j/k like VSCode)
+map("n", "<A-j>", "<cmd>execute 'move .+' . v:count1<cr>==", { desc = "Move Down" })
+map("n", "<A-k>", "<cmd>execute 'move .-' . (v:count1 + 1)<cr>==", { desc = "Move Up" })
+map("i", "<A-j>", "<esc><cmd>m .+1<cr>==gi", { desc = "Move Down" })
+map("i", "<A-k>", "<esc><cmd>m .-2<cr>==gi", { desc = "Move Up" })
+map("v", "<A-j>", ":<C-u>execute \"'<,'>move '>+\" . v:count1<cr>gv=gv", { desc = "Move Down" })
+map("v", "<A-k>", ":<C-u>execute \"'<,'>move '<-\" . (v:count1 + 1)<cr>gv=gv", { desc = "Move Up" })
+
+-- Alternative line movement (for terminals that don't support Alt)
+map("v", "J", ":move '>+1<CR>gv=gv", { desc = "Move Block Down" })
+map("v", "K", ":move '<-2<CR>gv=gv", { desc = "Move Block Up" })
+map("n", "<A-Down>", ":m .+1<CR>", opts)
+map("n", "<A-Up>", ":m .-2<CR>", opts)
+map("i", "<A-Down>", "<Esc>:m .+1<CR>==gi", opts)
+map("i", "<A-Up>", "<Esc>:m .-2<CR>==gi", opts)
+map("v", "<A-Down>", ":m '>+1<CR>gv=gv", opts)
+map("v", "<A-Up>", ":m '<-2<CR>gv=gv", opts)
+
+-- ═══════════════════════════════════════════════════════════
+-- SEARCH & NAVIGATION (ergonomic improvements)
+-- ═══════════════════════════════════════════════════════════
+
+-- Better line start/end (more comfortable than $ and ^)
+map("n", "gl", "$", { desc = "Go to end of line" })
+map("n", "gh", "^", { desc = "Go to start of line" })
+map("n", "<A-h>", "^", { desc = "Go to start of line", silent = true })
+map("n", "<A-l>", "$", { desc = "Go to end of line", silent = true })
+
+-- Select all content
+map("n", "==", "gg<S-v>G")
+map("n", "<A-a>", "ggVG", { noremap = true, silent = true, desc = "Select all" })
+
+-- Clear search highlighting
+map({ "i", "n" }, "<esc>", "<cmd>noh<cr><esc>", { desc = "Escape and Clear hlsearch" })
+map("n", "<leader>ur", "<Cmd>nohlsearch<Bar>diffupdate<Bar>normal! <C-L><CR>", { desc = "Redraw / Clear hlsearch / Diff Update" })
+
+-- Smart search navigation (n always goes forward, N always backward)
+map("n", "n", "'Nn'[v:searchforward].'zv'", { expr = true, desc = "Next Search Result" })
+map("x", "n", "'Nn'[v:searchforward]", { expr = true, desc = "Next Search Result" })
+map("o", "n", "'Nn'[v:searchforward]", { expr = true, desc = "Next Search Result" })
+map("n", "N", "'nN'[v:searchforward].'zv'", { expr = true, desc = "Prev Search Result" })
+map("x", "N", "'nN'[v:searchforward]", { expr = true, desc = "Prev Search Result" })
+map("o", "N", "'nN'[v:searchforward]", { expr = true, desc = "Prev Search Result" })
+
+-- ═══════════════════════════════════════════════════════════
+-- SMART TEXT EDITING
+-- ═══════════════════════════════════════════════════════════
+
+-- Better indenting (stay in visual mode)
+map("v", "<", "<gv")
+map("v", ">", ">gv")
+
+-- Better paste (doesn't replace clipboard with deleted text)
+map("v", "p", '"_dP', opts)
+
+-- Copy whole file to clipboard
+map("n", "<C-c>", ":%y+<CR>", opts)
+
+-- Smart undo break-points (create undo points at logical stops)
+map("i", ",", ",<c-g>u")
+map("i", ".", ".<c-g>u")
+map("i", ";", ";<c-g>u")
+
+-- Auto-close pairs (simple, no plugin needed)
+map("i", "`", "``<left>")
+map("i", '"', '""<left>')
+map("i", "(", "()<left>")
+map("i", "[", "[]<left>")
+map("i", "{", "{}<left>")
+map("i", "<", "<><left>")
+-- Note: Single quotes commented out to avoid conflicts in some contexts
+-- map("i", "'", "''<left>")
+
+-- ═══════════════════════════════════════════════════════════
+-- FILE OPERATIONS
+-- ═══════════════════════════════════════════════════════════
+
+-- Save file (works in all modes)
+map({ "i", "x", "n", "s" }, "<C-s>", "<cmd>w<cr><esc>", { desc = "Save File" })
+
+-- Create new file
+map("n", "<leader>fn", "<cmd>enew<cr>", { desc = "New File" })
+
+-- Quit operations
+map("n", "<leader>qq", "<cmd>qa<cr>", { desc = "Quit All" })
+
+-- ═══════════════════════════════════════════════════════════
+-- DEVELOPMENT TOOLS
+-- ═══════════════════════════════════════════════════════════
+
+-- Commenting (add comment above/below current line)
+map("n", "gco", "o<esc>Vcx<esc><cmd>normal gcc<cr>fxa<bs>", { desc = "Add Comment Below" })
+map("n", "gcO", "O<esc>Vcx<esc><cmd>normal gcc<cr>fxa<bs>", { desc = "Add Comment Above" })
+
+-- Quickfix and location lists
+map("n", "<leader>xl", function()
+  local success, err = pcall(vim.fn.getloclist(0, { winid = 0 }).winid ~= 0 and vim.cmd.lclose or vim.cmd.lopen)
+  if not success and err then
+    vim.notify(err, vim.log.levels.ERROR)
+  end
+end, { desc = "Location List" })
+
+map("n", "<leader>xq", function()
+  local success, err = pcall(vim.fn.getqflist({ winid = 0 }).winid ~= 0 and vim.cmd.cclose or vim.cmd.copen)
+  if not success and err then
+    vim.notify(err, vim.log.levels.ERROR)
+  end
+end, { desc = "Quickfix List" })
+
+map("n", "[q", vim.cmd.cprev, { desc = "Previous Quickfix" })
+map("n", "]q", vim.cmd.cnext, { desc = "Next Quickfix" })
+
+-- Inspection tools (useful for debugging highlights and treesitter)
+map("n", "<leader>ui", vim.show_pos, { desc = "Inspect Pos" })
+map("n", "<leader>uI", "<cmd>InspectTree<cr>", { desc = "Inspect Tree" })
+
+-- Keyword program (K for help on word under cursor)
+map("n", "<leader>K", "<cmd>norm! K<cr>", { desc = "Keywordprg" })
+
+-- ═══════════════════════════════════════════════════════════
+-- TERMINAL INTEGRATION
+-- ═══════════════════════════════════════════════════════════
+
+-- Terminal mode navigation
+map("t", "<esc><esc>", "<c-\\><c-n>", { desc = "Enter Normal Mode" })
+map("t", "<C-h>", "<cmd>wincmd h<cr>", { desc = "Go to Left Window" })
+map("t", "<C-j>", "<cmd>wincmd j<cr>", { desc = "Go to Lower Window" })
+map("t", "<C-k>", "<cmd>wincmd k<cr>", { desc = "Go to Upper Window" })
+map("t", "<C-l>", "<cmd>wincmd l<cr>", { desc = "Go to Right Window" })
+map("t", "<C-/>", "<cmd>close<cr>", { desc = "Hide Terminal" })
+map("t", "<c-_>", "<cmd>close<cr>", { desc = "which_key_ignore" })
+
+-- ═══════════════════════════════════════════════════════════
+-- TAB MANAGEMENT (when you need multiple workspaces)
+-- ═══════════════════════════════════════════════════════════
+
+map("n", "<leader><tab>l", "<cmd>tablast<cr>", { desc = "Last Tab" })
+map("n", "<leader><tab>o", "<cmd>tabonly<cr>", { desc = "Close Other Tabs" })
+map("n", "<leader><tab>f", "<cmd>tabfirst<cr>", { desc = "First Tab" })
+map("n", "<leader><tab><tab>", "<cmd>tabnew<cr>", { desc = "New Tab" })
+map("n", "<leader><tab>]", "<cmd>tabnext<cr>", { desc = "Next Tab" })
+map("n", "<leader><tab>d", "<cmd>tabclose<cr>", { desc = "Close Tab" })
+map("n", "<leader><tab>[", "<cmd>tabprevious<cr>", { desc = "Previous Tab" })
+
+-- ═══════════════════════════════════════════════════════════
+-- FOLDING NAVIGATION (for code organization)
+-- ═══════════════════════════════════════════════════════════
+
+-- Close all folds except current one (great for focus)
+map("n", "zv", "zMzvzz", { desc = "Close all folds except the current one" })
+
+-- Smart fold navigation (closes current, opens next/previous)
+map("n", "zj", "zcjzOzz", { desc = "Close current fold when open. Always open next fold." })
+map("n", "zk", "zckzOzz", { desc = "Close current fold when open. Always open previous fold." })
+
+-- ═══════════════════════════════════════════════════════════
+-- UTILITY SHORTCUTS
+-- ═══════════════════════════════════════════════════════════
+
+-- Toggle line wrapping
+map("n", "<leader>tw", "<cmd>set wrap!<CR>", { desc = "Toggle Wrap", silent = true })
+
+-- Fix spelling (picks first suggestion)
+map("n", "z0", "1z=", { desc = "Fix word under cursor" })

.config/nvim/lua/config/lsp.lua

@@ -0,0 +1,62 @@
+-- LSP
+local function augroup(name)
+  return vim.api.nvim_create_augroup("user_" .. name, { clear = true })
+end
+
+local default_keymaps = {
+  { keys = "<leader>ca", func = vim.lsp.buf.code_action, desc = "Code Actions" },
+  { keys = "<leader>cr", func = vim.lsp.buf.rename, desc = "Code Rename" },
+  { keys = "<leader>k", func = vim.lsp.buf.hover, desc = "Hover Documentation", has = "hoverProvider" },
+  { keys = "K", func = vim.lsp.buf.hover, desc = "Hover (alt)", has = "hoverProvider" },
+  { keys = "gd", func = vim.lsp.buf.definition, desc = "Goto Definition", has = "definitionProvider" },
+}
+
+-- I use blink.cmp for completion, but you can use native completion too
+local completion = vim.g.completion_mode or "blink" -- or 'native' for built-in completion
+vim.api.nvim_create_autocmd("LspAttach", {
+  group = augroup("lsp_attach"),
+  callback = function(args)
+    local client = vim.lsp.get_client_by_id(args.data.client_id)
+    local buf = args.buf
+    if client then
+      -- Built-in completion
+      if completion == "native" and client:supports_method("textDocument/completion") then
+        vim.lsp.completion.enable(true, client.id, args.buf, { autotrigger = true })
+      end
+
+      -- Inlay hints
+      if client:supports_method("textDocument/inlayHints") then
+        vim.lsp.inlay_hint.enable(true, { bufnr = args.buf })
+      end
+
+      if client:supports_method("textDocument/documentColor") then
+        vim.lsp.document_color.enable(true, args.buf, {
+          style = "background", -- 'background', 'foreground', or 'virtual'
+        })
+      end
+
+      for _, km in ipairs(default_keymaps) do
+        -- Only bind if there's no `has` requirement, or the server supports it
+        if not km.has or client.server_capabilities[km.has] then
+          vim.keymap.set(
+            km.mode or "n",
+            km.keys,
+            km.func,
+            { buffer = buf, desc = "LSP: " .. km.desc, nowait = km.nowait }
+          )
+        end
+      end
+    end
+  end,
+})
+
+-- Enable LSP servers for Neovim 0.11+
+vim.lsp.enable({
+  "lua_ls",
+})
+
+-- Load Lsp on-demand, e.g: eslint is disable by default
+-- e.g: We could enable eslint by set vim.g.lsp_on_demands = {"eslint"}
+if vim.g.lsp_on_demands then
+  vim.lsp.enable(vim.g.lsp_on_demands)
+end

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

@@ -0,0 +1,137 @@
+local opt = vim.opt
+
+opt.number = true -- Line numbers
+opt.relativenumber = true -- Relative line numbers
+opt.cursorline = true -- Highlight current line
+opt.wrap = false -- Don't wrap lines
+opt.scrolloff = 10 -- Keep 10 lines above/below cursor
+opt.sidescrolloff = 8 -- Keep 8 columns left/right of cursor
+
+-- Indentation
+opt.tabstop = 2 -- Tab width
+opt.shiftwidth = 2 -- Indent width
+opt.softtabstop = 2 -- Soft tab stop
+opt.expandtab = true -- Use spaces instead of tabs
+opt.smartindent = true -- Smart auto-indenting
+opt.autoindent = true -- Copy indent from current line
+
+-- Search settings
+opt.ignorecase = true -- Case insensitive search
+opt.smartcase = true -- Case sensitive if uppercase in search
+opt.hlsearch = false -- Don't highlight search results
+opt.incsearch = true -- Show matches as you type
+
+-- Visual settings
+opt.termguicolors = true -- Enable 24-bit colors
+opt.signcolumn = "yes" -- Always show sign column
+opt.showmatch = true -- Highlight matching brackets
+opt.matchtime = 2 -- How long to show matching bracket
+opt.cmdheight = 1 -- Command line height
+opt.showmode = false -- Don't show mode in command line
+opt.pumheight = 10 -- Popup menu height
+opt.pumblend = 10 -- Popup menu transparency
+opt.winblend = 0 -- Floating window transparency
+opt.completeopt = "menu,menuone,noselect"
+opt.conceallevel = 2 -- Hide * markup for bold and italic, but not markers with substitutions
+opt.confirm = true -- Confirm to save changes before exiting modified buffer
+opt.concealcursor = "" -- Don't hide cursor line markup
+opt.synmaxcol = 300 -- Syntax highlighting limit
+opt.ruler = false -- Disable the default ruler
+opt.virtualedit = "block" -- Allow cursor to move where there is no text in visual block mode
+opt.winminwidth = 5 -- Minimum window width
+
+-- File handling
+opt.backup = false -- Don't create backup files
+opt.writebackup = false -- Don't create backup before writing
+opt.swapfile = false -- Don't create swap files
+opt.undofile = true -- Persistent undo
+opt.undolevels = 10000
+opt.undodir = vim.fn.expand("~/.vim/undodir") -- Undo directory
+opt.updatetime = 300 -- Faster completion
+opt.timeoutlen = vim.g.vscode and 1000 or 300 -- Lower than default (1000) to quickly trigger which-key
+opt.ttimeoutlen = 0 -- Key code timeout
+opt.autoread = true -- Auto reload files changed outside vim
+opt.autowrite = true -- Auto save
+
+-- Behavior settings
+opt.hidden = true -- Allow hidden buffers
+opt.errorbells = false -- No error bells
+opt.backspace = "indent,eol,start" -- Better backspace behavior
+opt.autochdir = false -- Don't auto change directory
+opt.iskeyword:append("-") -- Treat dash as part of word
+opt.path:append("**") -- include subdirectories in search
+opt.selection = "exclusive" -- Selection behavior
+opt.mouse = "a" -- Enable mouse support
+opt.clipboard = vim.env.SSH_TTY and "" or "unnamedplus" -- Sync with system clipboard
+opt.modifiable = true -- Allow buffer modifications
+opt.encoding = "UTF-8" -- Set encoding
+
+-- Folding settings
+opt.smoothscroll = true
+vim.wo.foldmethod = "expr"
+opt.foldlevel = 99 -- Start with all folds open
+opt.formatoptions = "jcroqlnt" -- tcqj
+opt.grepformat = "%f:%l:%c:%m"
+opt.grepprg = "rg --vimgrep"
+
+-- Split behavior
+opt.splitbelow = true -- Horizontal splits go below
+opt.splitright = true -- Vertical splits go right
+opt.splitkeep = "screen"
+
+-- Command-line completion
+opt.wildmenu = true
+opt.wildmode = "longest:full,full"
+opt.wildignore:append({ "*.o", "*.obj", "*.pyc", "*.class", "*.jar" })
+
+-- Better diff options
+opt.diffopt:append("linematch:60")
+
+-- Performance improvements
+opt.redrawtime = 10000
+opt.maxmempattern = 20000
+
+-- Create undo directory if it doesn't exist
+local undodir = vim.fn.expand("~/.vim/undodir")
+if vim.fn.isdirectory(undodir) == 0 then
+  vim.fn.mkdir(undodir, "p")
+end
+
+vim.g.autoformat = true
+vim.g.trouble_lualine = true
+
+--[[
+opt.fillchars = {
+  foldopen = "",
+  foldclose = "",
+  fold = " ",
+  foldsep = " ",
+  diff = "╱",
+  eob = " ",
+}
+]]
+
+opt.jumpoptions = "view"
+opt.laststatus = 3 -- global statusline
+opt.list = false
+opt.linebreak = true -- Wrap lines at convenient points
+opt.list = true -- Show some invisible characters (tabs...
+opt.shiftround = true -- Round indent
+opt.shiftwidth = 2 -- Size of an indent
+opt.shortmess:append({ W = true, I = true, c = true, C = true })
+
+vim.g.markdown_recommended_style = 0
+
+vim.filetype.add({
+  extension = {
+    env = "dotenv",
+  },
+  filename = {
+    [".env"] = "dotenv",
+    ["env"] = "dotenv",
+  },
+  pattern = {
+    ["[jt]sconfig.*.json"] = "jsonc",
+    ["%.env%.[%w_.-]+"] = "dotenv",
+  },
+})