Install Aider

codecompanion-workspace.json

@@ -0,0 +1,114 @@
+{
+    "name": "Neovim Configuration",
+    "version": "1.0.0",
+    "system_prompt": "You are an expert Neovim configuration assistant. Help the user understand and modify their Neovim setup. Focus on clear explanations and suggest improvements when appropriate.",
+    "vars": {
+        "lua_dir": "lua"
+    },
+    "groups": [
+        {
+            "name": "Core Configuration",
+            "system_prompt": "These files define the core Neovim behavior including options, keymaps, and autocommands. When suggesting changes, ensure they align with Neovim best practices.",
+            "data": [
+                "core_opt",
+                "core_keymap",
+                "core_autocmd",
+                "core_helpers"
+            ]
+        },
+        {
+            "name": "Plugin Management",
+            "system_prompt": "This file contains the plugin manager setup. Help the user understand plugin dependencies and installation patterns.",
+            "data": [
+                "lazy_init"
+            ]
+        },
+        {
+            "name": "LSP Configuration",
+            "system_prompt": "These files define the Language Server Protocol setup. Help the user configure language servers, diagnostics, and code actions.",
+            "data": [
+                "lsp_config"
+            ]
+        },
+        {
+            "name": "Frequently Used Plugins",
+            "system_prompt": "These are plugins the user frequently configures. Provide detailed explanations about their options and how they interact with the rest of the configuration.",
+            "data": [
+                "plugin_codecompanion",
+                "plugin_edgy",
+                "plugin_snacks",
+                "plugin_mini",
+                "plugin_telescope"
+            ]
+        },
+        {
+            "name": "UI and Theme",
+            "system_prompt": "These files define the visual appearance of Neovim. Help the user understand how to customize colors and UI elements.",
+            "data": [
+                "plugin_colorscheme"
+            ]
+        }
+    ],
+    "data": {
+        "core_opt": {
+            "type": "file",
+            "path": "${lua_dir}/opt.lua",
+            "description": "Neovim options configuration"
+        },
+        "core_keymap": {
+            "type": "file", 
+            "path": "${lua_dir}/keymap.lua",
+            "description": "Key mappings configuration"
+        },
+        "core_autocmd": {
+            "type": "file",
+            "path": "${lua_dir}/autocmd.lua",
+            "description": "Automatic commands configuration"
+        },
+        "core_helpers": {
+            "type": "file",
+            "path": "${lua_dir}/helpers.lua",
+            "description": "Helper functions for Neovim configuration"
+        },
+        "lazy_init": {
+            "type": "file",
+            "path": "${lua_dir}/lazy_init.lua",
+            "description": "Lazy plugin manager initialization"
+        },
+        "lsp_config": {
+            "type": "file",
+            "path": "${lua_dir}/plugins/lsp.lua",
+            "description": "LSP plugins and configuration"
+        },
+        "plugin_codecompanion": {
+            "type": "file",
+            "path": "${lua_dir}/plugins/codecompanion.lua",
+            "description": "CodeCompanion plugin configuration"
+        },
+        "plugin_edgy": {
+            "type": "file",
+            "path": "${lua_dir}/plugins/edgy.lua",
+            "description": "Edgy plugin configuration"
+        },
+        "plugin_snacks": {
+            "type": "file",
+            "path": "${lua_dir}/plugins/snacks.lua",
+            "description": "Snacks plugin configuration"
+        },
+        "plugin_mini": {
+            "type": "file",
+            "path": "${lua_dir}/plugins/mini.lua",
+            "description": "Mini plugins configuration"
+        },
+        "plugin_telescope": {
+            "type": "file",
+            "path": "${lua_dir}/plugins/telescope.lua",
+            "description": "Telescope fuzzy finder configuration"
+        },
+        "plugin_colorscheme": {
+            "type": "file",
+            "path": "${lua_dir}/plugins/color.lua",
+            "description": "Color scheme and UI appearance configuration"
+        }
+    }
+}

init.lua

@@ -12,455 +12,32 @@ require 'keymap'
 require 'autocmd'
 require 'lazy_init'
 
--- nnoremap <Leader>ev :tabedit $MYVIMRC<CR>
+require('helpers').edit_cf('v', '/init.lua')
 
--- The line beneath this is called `modeline`. See `:help modeline`
--- vim: ts=2 sts=2 sw=2 et
+--[[
+TODO: Neovim configurations I want to add:
+- Clearer line numbers (weirdly not as simple as it sounds)
+- Debugging keymap that works like PHPStorm
+- Improve snippet expansion (an get rid of that stupid #endsection snippet)
+- Better organising of buffers when opening side panels (like AI chat and test summary)
+- Close test panel when opening debugger and vice versa using edgy
+- Close terminal from inside terminal buffer
+- Get shift key bindings working inside tmux
+- Fix ctrl+shift+a keybinding for AI actions
+- Get VectorCode working
+- Add LSP symbols for Pest tests
+- More prompts
+- Give AI better context and tools for working with Hylark
+- Figure out workspaces
+- Figure out agentic workflow
+- Figure out a better way to add relevant buffers to AI
+- Figure out debug expressions
+- Better keymaps for debug movements
+- Chat history
+]]
 
--- " Mappings --- {{{
--- " Editing files - {{{
--- "Make it easy to edit the vimrc file
--- " }}}
---
--- "Changing unused ctrl bindings
--- "Turn on git blame
--- nnoremap <C-S-A> <CMD>Git blame<CR>
--- "List all tags in the current buffer (replaced pageup, use CTRL-u instead)
--- nnoremap <C-Q> <CMD>CocFzfList outline<CR>
--- "List all tags in directory
--- "nnoremap <C-S-B> <CMD>Tags<CR>
--- "List all the recently opened files (replaced scroll one line up, use "k")
--- nnoremap <C-E> <CMD>History<CR>
--- "Search within the current buffer (replaced pagedown, use CTRL-d instead)
--- "nnoremap <C-F> /
--- "Search within the whole project
--- nnoremap <C-F> <CMD>Rg<CR>
--- "Move line down (uses vim-unimpaired) (replaced move down, use "j")
--- nnoremap <C-J> <C-E>
--- "Move line up (uses vim-unimpaired) (replaced move up, use "k")
--- nnoremap <C-K> <C-Y>
--- "Does not work because of legacy reasons
--- " nnoremap <C-M>
--- "Search marks (replaced "j" clone)
--- nnoremap <C-N> <CMD>Marks<CR>
--- "Search version controlled files (replaced move up, use "k")
--- nnoremap <C-P> <CMD>GFiles<CR>
--- "Search all files in directory
--- nnoremap <C-S-P> <CMD>Files<CR>
--- "Toggle file draw
--- nnoremap <C-S-Q> <CMD>CHADopen<CR>
--- "Search all snippets (uses ultisnips)
--- nnoremap <C-S> <CMD>Snippets<CR>
--- "Search git history (replaced scroll one line up, use "k")
--- nnoremap <C-Y> <CMD>Commits<CR>
--- "Search git history within current buffer/selection
--- nnoremap <C-S-Y> <CMD>BCommits<CR>
---
--- "Turn on git blame
--- inoremap <C-S-A> <CMD>Git blame<CR>
--- "List all tags in the current buffer
--- inoremap <C-Q> <CMD>BTags<CR>
--- "List all tags in directory
--- inoremap <C-S-Q> <CMD>Tags<CR>
--- "List all the recently opened files (replaced inserting characters from below)
--- inoremap <C-E> <CMD>History<CR>
--- "Search within the current buffer
--- inoremap <C-F> <Esc>/
--- "Search within the whole project
--- inoremap <C-S-F> <CMD>Rg<CR>
--- "Move line down (uses vim-unimpaired) (replaced <CR> clone)
--- inoremap <C-J> <Esc>ddpi
--- "Move line up (uses vim-unimpaired) (replaced start digraph, use command instead)
--- inoremap <C-K> <Esc>ddkPi
--- "Does not work because of legacy reasons
--- " inoremap <C-M> <CMD>Marks<CR>
--- "Add line below (replaced execute single command in normal)
--- inoremap <C-O> <Esc>o
--- "Add line above
--- inoremap <C-S-O> <Esc>O
--- "Search version controlled files (replaced autocomplete reverse)
--- inoremap <C-P> <CMD>GFiles<CR>
--- "Search all files in directory
--- inoremap <C-S-P> <CMD>Files<CR>
--- "Toggle file draw (replaces CTRL-v clone)
--- inoremap <C-S-Q> <CMD>CHADopen<CR>
--- "Search all snippets (uses ultisnips)
--- inoremap <C-S> <CMD>Snippets<CR>
--- "Search git history (replaced inserting characters from above)
--- inoremap <C-Y> <CMD>Commits<CR>
--- "Search git history within current buffer/selection
--- inoremap <C-S-Y> <CMD>BCommits<CR>
---
--- "Add simple highlight removal
--- nnoremap <Leader><Space> :nohlsearch<CR>
---
--- "Convert tabs to spaces
--- nnoremap <Leader><Tab> :retab<CR>
---
--- "Git mappings
--- nnoremap ga :Git add %<CR>
--- nnoremap gb :Git blame<CR>
--- nnoremap gC :Git commit<CR>
--- nnoremap gp :Git push<CR>
--- nnoremap gP :Git pull<CR>
---
--- "Map movement keys to Escape
--- inoremap jj <Esc>
--- inoremap jk <Esc>
--- inoremap kk <Esc>
--- inoremap hh <Esc>
---
--- "Delete a line in insert mode
--- " inoremap <C-D> <Esc>ddi
---
--- "Use semicolon instead of colon for commands
--- nnoremap ; :
--- nnoremap : ;
---
--- "Append the line with a semicolon
--- inoremap <Leader>; <Esc>mzA;<Esc>`za
--- nnoremap <Leader>; mzA;<Esc>`za<Esc>
---
--- "Easily navigate items in the quickfix menu
--- nnoremap <Leader>] :cnext<CR>
--- nnoremap <Leader>[ :cprevious<CR>
---
--- "Indent arrays
--- nnoremap <Leader>{ mzF[`a<CR><Esc>``%i<CR><Esc>`z
--- nnoremap <Leader>} mzF[`a<CR><Esc>``%i<CR><Esc>`zvi[:s/,\s*/,\r/g<CR>vi[=<Esc>`z:nohlsearch<CR>
---
--- "A command to properly indent json code
--- command! FormatJSON %!python -m json.tool
---
--- " Allow saving of files as doas
--- command! W execute 'silent! w !doas /usr/bin/tee % >/dev/null' <BAR> edit!
--- command! X execute 'silent! x !doas /usr/bin/tee % >/dev/null' <BAR> edit!
---
--- " }}}
---
--- " Plugins --- {{{
---
--- " COC --- {{{
--- " Use tab for trigger completion with characters ahead and navigate
--- " NOTE: There's always complete item selected by default, you may want to enable
--- " no select by `"suggest.noselect": true` in your configuration file
--- " NOTE: Use command ':verbose imap <tab>' to make sure tab is not mapped by
--- " other plugin before putting this into your config
--- inoremap <silent><expr> <TAB>
---     \ coc#pum#visible() ? coc#pum#next(1) :
---     \ CheckBackspace() ? "\<Tab>" :
---     \ coc#refresh()
--- inoremap <expr><S-TAB> coc#pum#visible() ? coc#pum#prev(1) : "\<C-h>"
---
--- " Make <CR> to accept selected completion item or notify coc.nvim to format
--- " <C-g>u breaks current undo, please make your own choice
--- inoremap <silent><expr> <CR> coc#pum#visible() ? coc#pum#confirm()
---                               \: "\<C-g>u\<CR>\<c-r>=coc#on_enter()\<CR>"
---
--- function! CheckBackspace() abort
---     let col = col('.') - 1
---     return !col || getline('.')[col - 1]  =~# '\s'
--- endfunction
---
--- if has('nvim')
---     inoremap <silent><expr> <c-space> coc#refresh()
--- else
---     inoremap <silent><expr> <c-@> coc#refresh()
--- endif
---
--- " Use `[g` and `]g` to navigate diagnostics
--- " Use `:CocDiagnostics` to get all diagnostics of current buffer in location list
--- nmap <silent> [g <Plug>(coc-diagnostic-prev)
--- nmap <silent> ]g <Plug>(coc-diagnostic-next)
---
--- " GoTo code navigation
--- nmap <silent> gd <Plug>(coc-definition)
--- nmap <silent> gy <Plug>(coc-type-definition)
--- nmap <silent> gi <Plug>(coc-implementation)
--- nmap <silent> gr <Plug>(coc-references)
---
--- " Use K to show documentation in preview window
--- nnoremap <silent> K :call ShowDocumentation()<CR>
---
--- function! ShowDocumentation()
---   if CocAction('hasProvider', 'hover')
---     call CocActionAsync('doHover')
---   else
---     call feedkeys('K', 'in')
---   endif
--- endfunction
---
--- " Highlight the symbol and its references when holding the cursor
--- autocmd CursorHold * silent call CocActionAsync('highlight')
---
--- " Symbol renaming
--- nmap <leader>rn <Plug>(coc-rename)
---
--- " Formatting selected code
--- xmap <leader>f  <Plug>(coc-format-selected)
--- nmap <leader>f  <Plug>(coc-format-selected)
---
--- augroup mygroup
---   autocmd!
---   " Setup formatexpr specified filetype(s)
---   autocmd FileType typescript,json setl formatexpr=CocAction('formatSelected')
---   " Update signature help on jump placeholder
---   autocmd User CocJumpPlaceholder call CocActionAsync('showSignatureHelp')
--- augroup end
---
--- " Applying code actions to the selected code block
--- " Example: `<leader>aap` for current paragraph
--- xmap <leader>a  <Plug>(coc-codeaction-selected)
--- nmap <leader>a  <Plug>(coc-codeaction-selected)
---
--- " Remap keys for applying code actions at the cursor position
--- nmap <leader>ac  <Plug>(coc-codeaction-cursor)
--- " Remap keys for apply code actions affect whole buffer
--- nmap <leader>as  <Plug>(coc-codeaction-source)
--- " Apply the most preferred quickfix action to fix diagnostic on the current line
--- nmap <leader>qf  <Plug>(coc-fix-current)
---
--- " Remap keys for applying refactor code actions
--- nmap <silent> <leader>re <Plug>(coc-codeaction-refactor)
--- xmap <silent> <leader>r  <Plug>(coc-codeaction-refactor-selected)
--- nmap <silent> <leader>r  <Plug>(coc-codeaction-refactor-selected)
---
--- " Run the Code Lens action on the current line
--- nmap <leader>cl  <Plug>(coc-codelens-action)
---
--- " Map function and class text objects
--- " NOTE: Requires 'textDocument.documentSymbol' support from the language server
--- xmap if <Plug>(coc-funcobj-i)
--- omap if <Plug>(coc-funcobj-i)
--- xmap af <Plug>(coc-funcobj-a)
--- omap af <Plug>(coc-funcobj-a)
--- xmap ic <Plug>(coc-classobj-i)
--- omap ic <Plug>(coc-classobj-i)
--- xmap ac <Plug>(coc-classobj-a)
--- omap ac <Plug>(coc-classobj-a)
---
--- " Remap <C-f> and <C-b> to scroll float windows/popups
--- " if has('nvim-0.4.0') || has('patch-8.2.0750')
--- "   nnoremap <silent><nowait><expr> <C-f> coc#float#has_scroll() ? coc#float#scroll(1) : "\<C-f>"
--- "   nnoremap <silent><nowait><expr> <C-b> coc#float#has_scroll() ? coc#float#scroll(0) : "\<C-b>"
--- "   inoremap <silent><nowait><expr> <C-f> coc#float#has_scroll() ? "\<c-r>=coc#float#scroll(1)\<cr>" : "\<Right>"
--- "   inoremap <silent><nowait><expr> <C-b> coc#float#has_scroll() ? "\<c-r>=coc#float#scroll(0)\<cr>" : "\<Left>"
--- "   vnoremap <silent><nowait><expr> <C-f> coc#float#has_scroll() ? coc#float#scroll(1) : "\<C-f>"
--- "   vnoremap <silent><nowait><expr> <C-b> coc#float#has_scroll() ? coc#float#scroll(0) : "\<C-b>"
--- " endif
---
--- " Use CTRL-S for selections ranges
--- " Requires 'textDocument/selectionRange' support of language server
--- nmap <silent> <C-s> <Plug>(coc-range-select)
--- xmap <silent> <C-s> <Plug>(coc-range-select)
---
--- " Add `:Format` command to format current buffer
--- command! -nargs=0 Format :call CocActionAsync('format')
---
--- " Add `:Fold` command to fold current buffer
--- command! -nargs=? Fold :call     CocAction('fold', <f-args>)
---
--- " Add `:OR` command for organize imports of the current buffer
--- command! -nargs=0 OR   :call     CocActionAsync('runCommand', 'editor.action.organizeImport')
---
--- " Add (Neo)Vim's native statusline support
--- " NOTE: Please see `:h coc-status` for integrations with external plugins that
--- " provide custom statusline: lightline.vim, vim-airline
--- set statusline^=%{coc#status()}%{get(b:,'coc_current_function','')}
---
---
--- " Mappings for CoCList
--- " Show all diagnostics
--- nnoremap <silent><nowait> <space>a  :<C-u>CocList diagnostics<cr>
--- " Manage extensions
--- nnoremap <silent><nowait> <space>e  :<C-u>CocList extensions<cr>
--- " Show commands
--- nnoremap <silent><nowait> <space>c  :<C-u>CocList commands<cr>
--- " Find symbol of current document
--- nnoremap <silent><nowait> <space>o  :<C-u>CocList outline<cr>
--- " Search workspace symbols
--- nnoremap <silent><nowait> <space>s  :<C-u>CocList -I symbols<cr>
--- " Do default action for next item
--- nnoremap <silent><nowait> <space>j  :<C-u>CocNext<CR>
--- " Do default action for previous item
--- nnoremap <silent><nowait> <space>k  :<C-u>CocPrev<CR>
--- " Resume latest coc list
--- nnoremap <silent><nowait> <space>p  :<C-u>CocListResume<CR>
---
--- " }}}
---
--- " Emmet --- {{{
--- " Toggle emmet completion using <Tab> with <Leader>em
--- let g:emmet_completion = 0
--- function ToggleEmmet()
---     if g:emmet_completion
---         echo "Emmet completion off!"
---         let g:user_emmet_expandabbr_key=','
---         iunmap <Tab>
---         let g:emmet_completion = 0
---     else
---         echo "Emmet completion on!"
---         let g:user_emmet_expandabbr_key='<Tab>'
---         imap <Expr> <Tab> emmet#expandAbbrIntelligent("\<Tab>")
---         let g:emmet_completion = 1
---     endif
--- endfunction
--- nnoremap <Leader>em :call ToggleEmmet()<CR>
--- " }}}
---
--- " Markdown --- {{{
--- " Conceal markdown text
--- set conceallevel=3
--- " }}}
---
--- " AutoPairs --- {{{
--- let g:AutoPairsFlyMode = 0
--- let g:AutoPairsShortcutBackInsert = '<M-b>' " Use <M-B> to insert the closing parentheses if it jumped ahead by mistake
--- " }}}
---
--- " CHADTree --- {{{
--- let g:chadtree_settings = {
---     \ 'theme': {
---         \ 'icon_glyph_set': 'devicons',
---         \ 'text_colour_set': 'env',
---         \ 'icon_colour_set': 'github',
---         \ "discrete_colour_map": {
---             \ "black": "#21222c",
---             \ "red": "#ff5555",
---             \ "green": "#50fa7b",
---             \ "yellow": "#f1fa8c",
---             \ "blue": "#bd93f9",
---             \ "magenta": "#ff79c6",
---             \ "cyan": "#8be9fd",
---             \ "white": "#f8f8f2",
---             \ "bright_black": "#6272a4",
---             \ "bright_red": "#ff6e6e",
---             \ "bright_green": "#69ff94",
---             \ "bright_yellow": "#ffffa5",
---             \ "bright_blue": "#d6acff",
---             \ "bright_magenta": "#ff92df",
---             \ "bright_cyan": "#a4ffff",
---             \ "bright_white": "#ffffff"
---         \ }
---     \ }
--- \ }
--- " }}}
---
--- " Commentary --- {{{
--- " function s:set_commentary_format()
--- "   echo "running command"
--- "   if &filetype =~ 'vue\|html\|svelte'
--- "     if searchpair('<\(script\|style\)', '', '</\(script\|style\)>', 'Wn')
--- "       let b:commentary_format="// %s"
--- "     else
--- "       let b:commentary_format=&commentstring
--- "     endif
--- "   endif
--- " endfunction
---
--- " xnoremap gc :call <SID>set_commentary_format()<CR><Plug>Commentary
--- " nnoremap gc :call <SID>set_commentary_format()<CR><Plug>Commentary
--- " onoremap gc :call <SID>set_commentary_format()<CR><Plug>Commentary
--- " nnoremap gcc :call <SID>set_commentary_format()<CR><Plug>Commentary
--- " nnoremap cgc :call <SID>set_commentary_format()<CR><Plug>Commentary
--- " nnoremap cgu :call <SID>set_commentary_format()<CR><Plug>Commentary<Plug>Commentary
--- " }}}
---
--- " Easymotion --- {{{
--- let g:EasyMotion_do_mapping = 0 " Disable default mappings
---
--- map <Leader> <Plug>(easymotion-prefix)
--- " Jump to anywhere you want with minimal keystrokes, with just one key binding.
--- " `s{char}{label}
--- nmap s <Plug>(easymotion-overwin-f)
---
--- " Turn on case-insensitive feature
--- let g:EasyMotion_smartcase = 1
---
--- " JK motions: Line motions
--- map <Leader>j <Plug>(easymotion-j)
--- map <Leader>k <Plug>(easymotion-k)
--- " }}}
---
--- " }}}
---
--- " PHP --- {{{
--- " function! RunPHPUnitTest()
--- "     cd %:p:h
--- "     normal! T yw
--- "     let result = system("phpunit --filter " . @" . " " . bufname("%"))
--- "     split __PHPUnit_Result__
--- "     normal! ggdG
--- "     setlocal buftype=nofile
--- "     call append(0, split(result, '\v\n'))
--- "     cd -
--- " endfunction
---
--- " nnoremap <F12> :call RunPHPUnitTest()<cr>
--- " }}}
---
--- " Moving around --- {{{
--- "Use capital H and L to move to the start and end of lines
--- nnoremap H ^
--- nnoremap L $
---
--- " }}}
---
--- " Operator mappings --- {{{
--- onoremap in( :<C-U>normal! f(vi(<CR>
--- onoremap il( :<C-U>normal! F)vi(<CR>
--- onoremap an( :<C-U>normal! f(va(<CR>
--- onoremap al( :<C-U>normal! F)va(<CR>
--- onoremap an{ :<C-U>normal! f{vi{<CR>
--- onoremap al{ :<C-U>normal! F}vi<CR>
--- " }}}
---
--- " Abbreviations --- {{{
--- iabbrev adn and
--- iabbrev waht what
--- iabbrev tehn then
--- iabbrev tihs this
--- iabbrev teh the
--- iabbrev Teh The
--- " }}}
---
 -- " Auto-Commands --- {{{
 --
--- "Automatically source the config files on save.
--- augroup autosourcing
---     autocmd!
---     autocmd BufWritePost $MYVIMRC source % "Source the vimrc file
--- augroup END
---
--- "Fold vimrc and zshrc files on open
--- augroup autofolding
---     autocmd!
---     autocmd BufReadPost $MYVIMRC :setlocal foldlevelstart=0
---     autocmd FileType vim setlocal foldmethod=marker
---     autocmd BufReadPost zsh :setlocal foldlevelstart=0
---     autocmd FileType zsh setlocal foldmethod=marker
--- augroup END
---
--- "Set commentary formats
--- function s:setcommentary()
---     if &commentstring =~ '/\*\s*%s\s*\*/'
---         let b:commentary_format="// %s"
---     endif
--- endfunction
---
--- augroup autocomment
---     autocmd!
---     autocmd FileType * call <SID>setcommentary()
--- augroup END
---
--- "Automatically save files
--- augroup autosaving
---     autocmd!
---     autocmd FocusLost * silent! wa "Save all files when moving away from the window
---     autocmd InsertLeave * silent! wa "Save all files when leaving insert mode
---     autocmd TextChanged * silent! wa "Save all files when text is changed
--- augroup END
---
 -- augroup modes
 --     autocmd!
 --     autocmd FocusLost * call feedkeys("\<Esc>") "Go to normal mode when moving away

lua/autocmd.lua

@@ -12,4 +12,100 @@ vim.api.nvim_create_autocmd('TextYankPost', {
     end,
 })
 
+local autosave_group = vim.api.nvim_create_augroup('autosaving', { clear = true })
+
+vim.api.nvim_create_autocmd('FocusLost', {
+    group = autosave_group,
+    pattern = '*',
+    command = 'silent! wa', -- Save all files when moving away from the window
+})
+
+vim.api.nvim_create_autocmd('InsertLeave', {
+    group = autosave_group,
+    pattern = '*',
+    command = 'silent! wa', -- Save all files when leaving insert mode
+})
+
+-- vim.api.nvim_create_autocmd('TextChanged', {
+--     group = autosave_group,
+--     pattern = '*',
+--     command = 'silent! wa', -- Save all files when text is changed
+-- })
+
+vim.api.nvim_create_autocmd('User', {
+    pattern = 'OilActionsPost',
+    callback = function(event)
+        if event.data.actions.type == 'move' then
+            Snacks.rename.on_rename_file(event.data.actions.src_url, event.data.actions.dest_url)
+        end
+    end,
+})
+
+local fidget_group = vim.api.nvim_create_augroup('CodeCompanionFidgetHooks', { clear = true })
+
+vim.api.nvim_create_autocmd({ 'User' }, {
+    pattern = 'CodeCompanionRequestStarted',
+    group = fidget_group,
+    callback = function(event)
+        local FidgetHelper = require 'utils.fidget_helper'
+        -- Pass event instead of request if the callback receives the full event object
+        local handle = FidgetHelper:create_progress_handle(event)
+        FidgetHelper:store_progress_handle(event.data.id, handle)
+    end,
+})
+
+vim.api.nvim_create_autocmd({ 'User' }, {
+    pattern = 'CodeCompanionRequestFinished',
+    group = fidget_group,
+    callback = function(event)
+        local FidgetHelper = require 'utils.fidget_helper'
+        local handle = FidgetHelper:pop_progress_handle(event.data.id)
+        if handle then
+            FidgetHelper:report_exit_status(handle, event)
+            handle:finish()
+        end
+    end,
+})
+
+-- vim.api.nvim_create_autocmd('BufEnter', {
+--     callback = function(event)
+--         local windows = vim.api.nvim_list_wins()
+--
+--         for _, window in ipairs(windows) do
+--             local bufnr = vim.api.nvim_win_get_buf(window)
+--             local ft = vim.api.nvim_get_option_value('filetype', { buf = bufnr })
+--             if vim.api.nvim_get_option_value('buflisted', { buf = bufnr })
+--                 or ft == 'oil'
+--                 or ft == 'snacks_dashboard' then
+--                 return
+--             end
+--         end
+--         vim.cmd 'qa'
+--     end,
+-- })
+
+local modes_group = vim.api.nvim_create_augroup('modes', { clear = true })
+vim.api.nvim_create_autocmd('FocusLost', {
+    group = modes_group,
+    pattern = '*',
+    command = 'call feedkeys("\\<Esc>")',
+})
+
+vim.api.nvim_create_autocmd('BufNewFile', {
+    group = modes_group,
+    pattern = '*',
+    command = 'call feedkeys("i")',
+})
+
+-- Reload LuaSnip snippets when saving files in the snippets directory
+local snippets_dir = vim.fn.stdpath 'config' .. '/lua/snippets'
+vim.api.nvim_create_autocmd('BufWritePost', {
+    pattern = snippets_dir .. '/*.json', -- Adjust the path to match your snippets directory
+    desc = 'Reload LuaSnip snippets on save',
+    callback = function()
+        require('luasnip.loaders.from_vscode').lazy_load { paths = { snippets_dir } }
+        vim.notify('Snippets reloaded!', vim.log.levels.INFO)
+    end,
+})
+
 require('helpers').edit_cf('a', '/lua/autocmd.lua')

lua/keymap.lua

@@ -2,8 +2,8 @@
 --  See `:help vim.keymap.set()`
 
 -- Swap : and ; around
-vim.keymap.set('n', ':', ';')
-vim.keymap.set('n', ';', ':')
+vim.keymap.set({ 'n', 'v' }, ':', ';')
+vim.keymap.set({ 'n', 'v' }, ';', ':')
 
 -- Clear highlights on search when pressing <Esc> in normal mode
 --  See `:help hlsearch`
@@ -20,12 +20,6 @@ vim.keymap.set('n', '<leader>q', vim.diagnostic.setloclist, { desc = 'Open diagn
 -- or just use <C-\><C-n> to exit terminal mode
 vim.keymap.set('t', '<Esc><Esc>', '<C-\\><C-n>', { desc = 'Exit terminal mode' })
 
--- TIP: Disable arrow keys in normal mode
--- vim.keymap.set('n', '<left>', '<cmd>echo "Use h to move!!"<CR>')
--- vim.keymap.set('n', '<right>', '<cmd>echo "Use l to move!!"<CR>')
--- vim.keymap.set('n', '<up>', '<cmd>echo "Use k to move!!"<CR>')
--- vim.keymap.set('n', '<down>', '<cmd>echo "Use j to move!!"<CR>')
-
 -- Keybinds to make split navigation easier.
 --  Use CTRL+<hjkl> to switch between windows
 --
@@ -40,4 +34,218 @@ vim.keymap.set('n', '<C-S-l>', '<C-w>L', { desc = 'Move window to the right' })
 vim.keymap.set('n', '<C-S-j>', '<C-w>J', { desc = 'Move window to the lower' })
 vim.keymap.set('n', '<C-S-k>', '<C-w>K', { desc = 'Move window to the upper' })
 
+vim.keymap.set('n', '<Leader>.', '<Cmd>tabnext<CR>', { desc = 'Next tab' })
+vim.keymap.set('n', '<Leader>,', '<Cmd>tabprevious<CR>', { desc = 'Previous tab' })
+
+-- Overriding CTRL mappings because some of them are stupid
+vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-S-B>', '<CMD>Git blame<CR>', { desc = 'Git blame' })
+vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-Q>', '<CMD>Telescope lsp_document_symbols<CR>', { desc = 'Show symbols in current document' })
+vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-S-Q>', '<CMD>Telescope lsp_workspace_symbols<CR>', { desc = 'Show symbols in workspace' })
+vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-E>', '<CMD>Telescope oldfiles<CR>', { desc = 'Show recently opened files' })
+vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-P>', function()
+    require('telescope.builtin').find_files {
+        show_untracked = true,
+        no_ignore = false,
+        hidden = true,
+    }
+end, { desc = 'Find all files' })
+vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-S-P>', function()
+    require('telescope.builtin').find_files {
+        show_untracked = true,
+        no_ignore = true,
+        hidden = true,
+    }
+end, { desc = 'Find all files' })
+vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-F>', function()
+    require('telescope.builtin').live_grep {
+        hidden = true,
+    }
+end, { desc = 'Search within the whole project' })
+vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-Y>', '<CMD>Telescope quickfix<CR>', { desc = 'Show quickfix list' })
+vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-S-Y>', '<CMD>Telescope quickfixhistory<CR>', { desc = 'Show quickfix history' })
+vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-A>', '<CMD>CodeCompanionChat Toggle<CR>', { desc = 'Open AI Actions' })
+vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-S-A>', '<CMD>CodeCompanionActions<CR>', { desc = 'Open AI Actions' })
+vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-S>', function()
+    require('snacks').scratch()
+end, { desc = 'Open scratchpad' })
+vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-S-S>', function()
+    require('snacks').scratch.select()
+end, { desc = 'Open scratchpad buffers' })
+vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-T>', function()
+    require('snacks').terminal.toggle()
+end, { desc = 'Open terminal' })
+
+-- Editing helpers
+vim.keymap.set('i', '<C-O>', '<Esc>o', { desc = 'Add line below' })
+vim.keymap.set('i', '<C-S-O>', '<Esc>O', { desc = 'Add line above' })
+local esc_keys = { 'jj', 'jk', 'kk' }
+for _, key in ipairs(esc_keys) do
+    vim.keymap.set('i', key, '<Esc>', { desc = 'Exit insert mode' })
+end
+vim.keymap.set('i', '<C-D>', '<Esc>ddi', { desc = 'Delete line' })
+vim.keymap.set('i', '<Leader>;', '<Esc>mzA;<Esc>`za', { desc = 'Append a semicolon' })
+vim.keymap.set('n', '<Leader>;', 'mzA;<Esc>`za', { desc = 'Append a semicolon' })
+vim.keymap.set('n', '<Leader>{', 'mzF[`a<CR><Esc>``%i<CR><Esc>`z', { desc = 'Indent an array' })
+vim.keymap.set('n', '<Leader>}', 'mzF[`a<CR><Esc>``%i<CR><Esc>`zvi[:s/,\\s*/,\\r/g<CR>vi[=<Esc>`z:nohlsearch<CR>', { desc = 'Indent an array some other way?' })
+
+-- Git mappings
+vim.keymap.set('n', '<Leader>gaf', '<CMD>Git add %<CR>', { desc = 'Git add current file' })
+vim.keymap.set('n', '<Leader>gaa', '<CMD>Git add --all<CR>', { desc = 'Git add all unstaged changes' })
+vim.keymap.set('n', '<Leader>gap', '<CMD>Git add --patch --all<CR>', { desc = 'Git add all unstaged changes interactively' })
+vim.keymap.set('n', '<Leader>gb', '<CMD>Git blame<CR>', { desc = 'Git blame' })
+vim.keymap.set('n', '<Leader>gcm', '<CMD>Git commit -v<CR>', { desc = 'Git commit' })
+vim.keymap.set('n', '<Leader>gp', '<CMD>Git push<CR>', { desc = 'Git push' })
+vim.keymap.set('n', '<Leader>gup', '<CMD>Git pull --rebase<CR>', { desc = 'Git pull --rebase' })
+vim.keymap.set('n', '<Leader>gsb', '<CMD>Git status<CR>', { desc = 'Git status' })
+vim.keymap.set('n', '<Leader>gd', '<CMD>Git diff<CR>', { desc = 'Git diff' })
+vim.keymap.set('n', '<Leader>gf', '<CMD>Git fetch<CR>', { desc = 'Git fetch' })
+vim.keymap.set('n', '<Leader>gdc', '<CMD>Git diff --cached<CR>', { desc = 'Git diff' })
+vim.keymap.set('n', '<Leader>gl', '<CMD>Git log<CR>', { desc = 'Git log' })
+vim.keymap.set('n', '<Leader>gun', '<CMD>Git reset -- %<CR>', { desc = 'Git unstage file' })
+vim.keymap.set('n', '<Leader>gco', '<CMD>Git checkout -- %<CR>', { desc = 'Git checkout' })
+vim.keymap.set('n', '<Leader>G', '<CMD>Git', { desc = 'Git' })
+vim.keymap.set('n', '<Leader>gsta', '<CMD>Git stash push<CR>', { desc = 'Git stash' })
+vim.keymap.set('n', '<Leader>gstA', '<CMD>Git stash apply<CR>', { desc = 'Git stash apply' })
+vim.keymap.set('n', '<Leader>gstp', '<CMD>Git stash pop<CR>', { desc = 'Git stash pop' })
+
+-- Add keymaps for diff mode
+vim.api.nvim_create_autocmd('BufEnter', {
+    callback = function()
+        if vim.wo.diff then
+            -- Keymaps for navigating hunks
+            vim.api.nvim_buf_set_keymap(0, 'n', '<Tab>', ']c', { noremap = true, silent = true, desc = 'Next hunk in diff mode' })
+            vim.api.nvim_buf_set_keymap(0, 'n', '<S-Tab>', '[c', { noremap = true, silent = true, desc = 'Previous hunk in diff mode' })
+
+            -- Keymaps for resolving conflicts
+            vim.api.nvim_buf_set_keymap(0, 'n', '<leader>dl', ':diffget LOCAL<CR>', { noremap = true, silent = true, desc = 'Get LOCAL changes' })
+            vim.api.nvim_buf_set_keymap(0, 'n', '<leader>dr', ':diffget REMOTE<CR>', { noremap = true, silent = true, desc = 'Get REMOTE changes' })
+        end
+    end,
+})
+
+-- AI mappings
+-- vim.keymap.set('v', '<Leader>ae', '<CMD>CodeCompanion<CR>', { desc = 'Edit selection with AI' })
+-- vim.keymap.set('n', '<Leader>ac', '<CMD>CodeCompanionCmd<CR>', { desc = 'Run Neovim commands with AI' })
+vim.api.nvim_create_autocmd('FileType', {
+    pattern = 'codecompanion',
+    callback = function()
+        vim.keymap.set('i', '<Enter>', function()
+            require('codecompanion').last_chat():submit()
+        end, { buffer = true, desc = 'Use enter to send the message' })
+        vim.keymap.set('i', '<S-Enter>', '<Enter>', { buffer = true, desc = 'Use shift enter to start a new line' })
+        vim.keymap.set('n', '<Enter>', 'G', { buffer = true, desc = 'Use enter in normal mode to go to the end of the chat' })
+
+        local models = { 'gpt-4.1', 'gemini-2.5-pro', 'gemini-2.0-flash-001', 'claude-3.7-sonnet-thought', 'o4-mini' }
+        -- Loop through models and create keymaps for each
+        for i, model in ipairs(models) do
+            vim.keymap.set('n', '<C-' .. i .. '>', 'mzggj0W"_C' .. model .. '<Esc>`z', { desc = 'Switch to ' .. model })
+            vim.keymap.set('i', '<C-' .. i .. '>', '<Esc>mzggj0W"_C' .. model .. '<Esc>`za', { desc = 'Switch to ' .. model })
+        end
+    end,
+})
+
+-- Search mappings
+vim.keymap.set('n', '<Leader>sGb', '<CMD>Telescope git_branches<CR>', { desc = 'Search git branches' })
+vim.keymap.set('n', '<Leader>sGc', '<CMD>Telescope git_commits<CR>', { desc = 'Search git history' })
+vim.keymap.set('n', '<Leader>sGh', '<CMD>Telescope git_bcommits<CR>', { desc = 'Search git history within current buffer/selection' })
+vim.keymap.set('n', '<Leader>sGs', '<CMD>Telescope git_status<CR>', { desc = 'Search git status' })
+vim.keymap.set('n', '<Leader>sGS', '<CMD>Telescope git_stash<CR>', { desc = 'Search git stash' })
+
+-- Misc
+vim.keymap.set('n', '<Leader>]', '<CMD>cnext<CR>', { desc = 'Next item in quickfix list' })
+vim.keymap.set('n', '<Leader>[', '<CMD>cprevious<CR>', { desc = 'Previous item in quickfix list' })
+vim.keymap.set('n', 'gd', '<CMD>Telescope lsp_definitions<CR>', { desc = 'Go to definition' })
+
+local function open_test()
+    require('neotest').summary.open()
+    require('neotest').output_panel.open()
+end
+-- Testing
+local test_maps = {
+    {
+        keys = { '<F12>', '<Leader>tn' },
+        action = function()
+            require('neotest').run.run()
+            open_test()
+        end,
+        desc = 'Run nearest test',
+    },
+    {
+        keys = { '<F9>', '<Leader>ta' },
+        action = function()
+            require('neotest').run.run { suite = true }
+            open_test()
+        end,
+        desc = 'Run all tests in the project',
+    },
+    {
+        keys = { '<F11>', '<Leader>tp' },
+        action = function()
+            require('neotest').run.run_last()
+            open_test()
+        end,
+        desc = 'Run previous test again',
+    },
+    {
+        keys = { '<F10>', '<Leader>td' },
+        action = function()
+            local dap = require 'dap'
+            if dap.session() == nil then
+                dap.continue()
+            end
+            require('dapui').open()
+            local neotest = require 'neotest'
+            local bufnr = vim.api.nvim_get_current_buf()
+            local row = vim.api.nvim_win_get_cursor(0)[1] - 1
+
+            local adapters = neotest.state.adapter_ids()
+            local found = false
+
+            for _, adapter_id in ipairs(adapters) do
+                local tree = neotest.state.positions(adapter_id, { buffer = bufnr })
+                if tree then
+                    local nearest = require('neotest.lib.positions').nearest(tree, row)
+                    if nearest and nearest:data().type ~= 'file' then
+                        neotest.run.run()
+                        found = true
+                        break
+                    end
+                end
+            end
+
+            if not found then
+                neotest.run.run_last()
+            end
+        end,
+        desc = 'Run last test with debugger',
+    },
+}
+
+for _, map_info in ipairs(test_maps) do
+    for _, key in ipairs(map_info.keys) do
+        vim.keymap.set('n', key, map_info.action, { desc = map_info.desc })
+    end
+end
+vim.keymap.set('n', '<Leader>tf', function()
+    require('neotest').run.run(vim.fn.expand '%')
+    open_test()
+end, { desc = 'Run all tests in the current file' })
+vim.keymap.set('n', '<Leader>tc', function()
+    require('neotest').summary.close()
+    require('neotest').output_panel.close()
+end, { desc = 'Close test panels' })
+
+-- Leaving this commented out, I will try the format command instead
+-- "A command to properly indent json code
+-- command! FormatJSON %!python -m json.tool
+
+-- Edit the snippet file for the current buffer filetype or the snippets
+-- directory if the file does not exist
+vim.keymap.set('n', '<Leader>es', function()
+    local ft = vim.bo.filetype
+    local snippets_dir = vim.fn.stdpath 'config' .. '/lua/snippets'
+    local snippets_file = snippets_dir .. '/' .. ft .. '.json'
+    vim.cmd('tabedit ' .. snippets_file)
+end, { desc = 'Edit snippets file' })
+
 require('helpers').edit_cf('k', '/lua/keymap.lua')

lua/opt.lua

@@ -82,4 +82,6 @@ vim.opt.autowriteall = true
 -- Add lines at 80 and 120 columns
 vim.opt.colorcolumn = '80,120'
 
+vim.opt.iskeyword:remove '$'
+
 require('helpers').edit_cf('o', '/lua/opt.lua')

lua/plugins/actually.lua

@@ -0,0 +1,3 @@
+return {
+    'mong8se/actually.nvim',
+}

lua/plugins/aider.lua

@@ -0,0 +1,54 @@
+return {
+    'GeorgesAlkhouri/nvim-aider',
+    cmd = 'Aider',
+    keys = {
+        { '<leader>a/', '<cmd>Aider toggle<cr>', desc = 'Toggle Aider' },
+        { '<leader>as', '<cmd>Aider send<cr>', desc = 'Send to Aider', mode = { 'n', 'v' } },
+        { '<leader>ac', '<cmd>Aider command<cr>', desc = 'Aider Commands' },
+        { '<leader>ab', '<cmd>Aider buffer<cr>', desc = 'Send Buffer' },
+        { '<leader>a+', '<cmd>Aider add<cr>', desc = 'Add File' },
+        { '<leader>a-', '<cmd>Aider drop<cr>', desc = 'Drop File' },
+        { '<leader>ar', '<cmd>Aider add readonly<cr>', desc = 'Add Read-Only' },
+        { '<leader>aR', '<cmd>Aider reset<cr>', desc = 'Reset Session' },
+        -- Example nvim-tree.lua integration if needed
+        { '<leader>a+', '<cmd>AiderTreeAddFile<cr>', desc = 'Add File from Tree to Aider', ft = 'NvimTree' },
+        { '<leader>a-', '<cmd>AiderTreeDropFile<cr>', desc = 'Drop File from Tree from Aider', ft = 'NvimTree' },
+    },
+    dependencies = {
+        'folke/snacks.nvim',
+        --- The below dependencies are optional
+        'catppuccin/nvim',
+        'nvim-tree/nvim-tree.lua',
+        --- Neo-tree integration
+        {
+            'nvim-neo-tree/neo-tree.nvim',
+            opts = function(_, opts)
+                -- Example mapping configuration (already set by default)
+                -- opts.window = {
+                --   mappings = {
+                --     ["+"] = { "nvim_aider_add", desc = "add to aider" },
+                --     ["-"] = { "nvim_aider_drop", desc = "drop from aider" }
+                --     ["="] = { "nvim_aider_add_read_only", desc = "add read-only to aider" }
+                --   }
+                -- }
+                require('nvim_aider.neo_tree').setup(opts)
+            end,
+        },
+    },
+    config = function()
+        require('nvim_aider').setup({
+            aider_cmd = 'aider',
+            args = {
+                '--config=$HOME/.config/aider/aider.yaml',
+                '--no-auto-commits',
+                '--copy-paste',
+            },
+            auto_reload = true,
+            win = {
+                wo = { winbar = 'Aider' },
+                style = 'nvim_aider',
+                position = 'bottom',
+            },
+        })
+    end,
+}

lua/plugins/avante.lua

@@ -1,72 +1,75 @@
-require('helpers').edit_cf('pa', '/lua/plugins/avante.lua')
-
-return {
-    'yetone/avante.nvim',
-    event = 'VeryLazy',
-    version = false, -- Never set this value to "*"! Never!
-    opts = {
-        -- add any opts here
-        -- for example
-        provider = 'aihubmix',
-        cursor_applying_provider = 'aihubmix_llama_versatile',
-        aihubmix = {
-            -- model = 'claude-3-7-sonnet-20250219',
-            model = 'DeepSeek-V3',
-        },
-        openai = {
-            endpoint = 'https://api.openai.com/v1',
-            model = 'gpt-4o', -- your desired model (or use gpt-4o, etc.)
-            timeout = 30000, -- Timeout in milliseconds, increase this for reasoning models
-            temperature = 0,
-            max_completion_tokens = 8192, -- Increase this to include reasoning tokens (for reasoning models)
-            --reasoning_effort = "medium", -- low|medium|high, only used for reasoning models
-        },
-        vendors = {
-            aihubmix_llama_versatile = {
-                __inherited_from = 'aihubmix',
-                model = 'llama-3.3-70b-versatile',
-            },
-        },
-    },
-    -- if you want to build from source then do `make BUILD_FROM_SOURCE=true`
-    build = 'make',
-    -- build = "powershell -ExecutionPolicy Bypass -File Build.ps1 -BuildFromSource false" -- for windows
-    dependencies = {
-        'nvim-treesitter/nvim-treesitter',
-        'stevearc/dressing.nvim',
-        'nvim-lua/plenary.nvim',
-        'MunifTanjim/nui.nvim',
-        --- The below dependencies are optional,
-        'echasnovski/mini.pick', -- for file_selector provider mini.pick
-        'nvim-telescope/telescope.nvim', -- for file_selector provider telescope
-        'hrsh7th/nvim-cmp', -- autocompletion for avante commands and mentions
-        'ibhagwan/fzf-lua', -- for file_selector provider fzf
-        'nvim-tree/nvim-web-devicons', -- or echasnovski/mini.icons
-        'zbirenbaum/copilot.lua', -- for providers='copilot'
-        {
-            -- support for image pasting
-            'HakonHarnes/img-clip.nvim',
-            event = 'VeryLazy',
-            opts = {
-                -- recommended settings
-                default = {
-                    embed_image_as_base64 = false,
-                    prompt_for_file_name = false,
-                    drag_and_drop = {
-                        insert_mode = true,
-                    },
-                    -- required for Windows users
-                    use_absolute_path = true,
-                },
-            },
-        },
-        {
-            -- Make sure to set this up properly if you have lazy=true
-            'MeanderingProgrammer/render-markdown.nvim',
-            opts = {
-                file_types = { 'markdown', 'Avante' },
-            },
-            ft = { 'markdown', 'Avante' },
-        },
-    },
-}
+return {}
+-- require('helpers').edit_cf('pa', '/lua/plugins/avante.lua')
+--
+-- return {
+--     'yetone/avante.nvim',
+--     event = 'VeryLazy',
+--     version = false, -- Never set this value to "*"! Never!
+--     opts = {
+--         -- add any opts here
+--         -- for example
+--         provider = 'aihubmix',
+--         -- cursor_applying_provider = 'aihubmix_llama_versatile',
+--         aihubmix = {
+--             -- model = 'claude-3-7-sonnet-20250219',
+--             model = 'DeepSeek-V3',
+--         },
+--         openai = {
+--             endpoint = 'https://api.openai.com/v1',
+--             model = 'gpt-4o', -- your desired model (or use gpt-4o, etc.)
+--             timeout = 30000, -- Timeout in milliseconds, increase this for reasoning models
+--             temperature = 0,
+--             max_completion_tokens = 8192, -- Increase this to include reasoning tokens (for reasoning models)
+--             --reasoning_effort = "medium", -- low|medium|high, only used for reasoning models
+--         },
+--         vendors = {
+--             aihubmix_llama_versatile = {
+--                 __inherited_from = 'openai',
+--                 api_key_name = 'AIHUBMIX_API_KEY',
+--                 endpoint = 'https://aihubmix.com/v1',
+--                 model = 'llama-3.3-70b-versatile',
+--             },
+--         },
+--     },
+--     -- if you want to build from source then do `make BUILD_FROM_SOURCE=true`
+--     build = 'make',
+--     -- build = "powershell -ExecutionPolicy Bypass -File Build.ps1 -BuildFromSource false" -- for windows
+--     dependencies = {
+--         'nvim-treesitter/nvim-treesitter',
+--         'stevearc/dressing.nvim',
+--         'nvim-lua/plenary.nvim',
+--         'MunifTanjim/nui.nvim',
+--         --- The below dependencies are optional,
+--         'echasnovski/mini.pick', -- for file_selector provider mini.pick
+--         'nvim-telescope/telescope.nvim', -- for file_selector provider telescope
+--         'hrsh7th/nvim-cmp', -- autocompletion for avante commands and mentions
+--         'ibhagwan/fzf-lua', -- for file_selector provider fzf
+--         'nvim-tree/nvim-web-devicons', -- or echasnovski/mini.icons
+--         'zbirenbaum/copilot.lua', -- for providers='copilot'
+--         {
+--             -- support for image pasting
+--             'HakonHarnes/img-clip.nvim',
+--             event = 'VeryLazy',
+--             opts = {
+--                 -- recommended settings
+--                 default = {
+--                     embed_image_as_base64 = false,
+--                     prompt_for_file_name = false,
+--                     drag_and_drop = {
+--                         insert_mode = true,
+--                     },
+--                     -- required for Windows users
+--                     use_absolute_path = true,
+--                 },
+--             },
+--         },
+--         {
+--             -- Make sure to set this up properly if you have lazy=true
+--             'MeanderingProgrammer/render-markdown.nvim',
+--             opts = {
+--                 file_types = { 'markdown', 'Avante' },
+--             },
+--             ft = { 'markdown', 'Avante' },
+--         },
+--     },
+-- }

lua/plugins/blink.lua

@@ -5,33 +5,9 @@ return {
     version = '1.*',
     dependencies = {
         -- Compatibility for Avante with Blink (it typically only works with cmp)
-        'Kaiser-Yang/blink-cmp-avante',
+        -- 'Kaiser-Yang/blink-cmp-avante',
         -- Snippet Engine
-        {
-            'L3MON4D3/LuaSnip',
-            version = '2.*',
-            build = (function()
-                -- Build Step is needed for regex support in snippets.
-                -- This step is not supported in many windows environments.
-                -- Remove the below condition to re-enable on windows.
-                if vim.fn.has 'win32' == 1 or vim.fn.executable 'make' == 0 then
-                    return
-                end
-                return 'make install_jsregexp'
-            end)(),
-            dependencies = {
-                -- `friendly-snippets` contains a variety of premade snippets.
-                --    See the README about individual language/framework/plugin snippets:
-                --    https://github.com/rafamadriz/friendly-snippets
-                {
-                    'rafamadriz/friendly-snippets',
-                    config = function()
-                        require('luasnip.loaders.from_vscode').lazy_load()
-                    end,
-                },
-            },
-            opts = {},
-        },
+        'L3MON4D3/LuaSnip',
         'folke/lazydev.nvim',
     },
     --- @module 'blink.cmp'
@@ -59,7 +35,7 @@ return {
             -- <c-k>: Toggle signature help
             --
             -- See :h blink-cmp-config-keymap for defining your own keymap
-            preset = 'default',
+            preset = 'enter',
 
             -- For more advanced Luasnip keymaps (e.g. selecting choice nodes, expansion) see:
             --    https://github.com/L3MON4D3/LuaSnip?tab=readme-ov-file#keymaps
@@ -68,20 +44,23 @@ return {
         appearance = {
             -- 'mono' (default) for 'Nerd Font Mono' or 'normal' for 'Nerd Font'
             -- Adjusts spacing to ensure icons are aligned
-            nerd_font_variant = 'mono',
+            nerd_font_variant = 'normal',
         },
 
         completion = {
             -- By default, you may press `<c-space>` to show the documentation.
             -- Optionally, set `auto_show = true` to show the documentation after a delay.
-            documentation = { auto_show = false, auto_show_delay_ms = 500 },
+            documentation = { auto_show = true, auto_show_delay_ms = 200 },
         },
 
         sources = {
-            default = { 'avante', 'lsp', 'path', 'snippets', 'lazydev' },
+            default = { 'codecompanion', 'lsp', 'path', 'snippets', 'lazydev' },
             providers = {
                 lazydev = { module = 'lazydev.integrations.blink', score_offset = 100 },
-                avante = { module = 'blink-cmp-avante', name = 'Avante', opts = {} },
+                -- avante = { module = 'blink-cmp-avante', name = 'Avante', opts = {} },
+            },
+            per_filetype = {
+                codecompanion = { 'codecompanion' },
             },
         },
 

lua/plugins/codecompanion.lua

@@ -0,0 +1,263 @@
+require('helpers').edit_cf('pa', '/lua/plugins/codecompanion.lua')
+
+vim.cmd [[cab cc CodeCompanion]]
+
+return {
+    'olimorris/codecompanion.nvim',
+    opts = function(_, opts)
+        opts.adapters = {
+            gpt = function()
+                return require('codecompanion.adapters').extend('copilot', {
+                    schema = {
+                        model = {
+                            default = 'gpt-4.1',
+                        },
+                        max_tokens = {
+                            default = 1000000,
+                        },
+                    },
+                })
+            end,
+            flash = function()
+                return require('codecompanion.adapters').extend('copilot', {
+                    schema = {
+                        model = {
+                            default = 'gemini-2.0-flash',
+                        },
+                        max_tokens = {
+                            default = 1000000,
+                        },
+                    },
+                })
+            end,
+            gemini = function()
+                return require('codecompanion.adapters').extend('copilot', {
+                    schema = {
+                        model = {
+                            default = 'gemini-2.5-pro',
+                        },
+                        max_tokens = {
+                            default = 1000000,
+                        },
+                    },
+                })
+            end,
+            sonnet = function()
+                return require('codecompanion.adapters').extend('copilot', {
+                    schema = {
+                        model = {
+                            default = 'claude-3.7-sonnet',
+                        },
+                        max_tokens = {
+                            default = 1000000,
+                        },
+                    },
+                })
+            end,
+        }
+
+        opts.display = {
+            chat = {
+                show_settings = true,
+                start_in_insert_mode = false,
+            },
+        }
+
+        opts.strategies = {
+            chat = {
+                adapter = 'gpt',
+                slash_commands = {
+                    codebase = require('vectorcode.integrations').codecompanion.chat.make_slash_command(),
+                },
+                tools = {
+                    vectorcode = {
+                        description = 'Run VectorCode to retrieve the project context.',
+                        callback = require('vectorcode.integrations').codecompanion.chat.make_tool(),
+                    },
+                    ['cmd_runner'] = {
+                        opts = {
+                            requires_approval = false,
+                        },
+                    },
+                },
+                roles = {
+                    ---@type string|fun(adapter: CodeCompanion.Adapter): string
+                    llm = function(adapter)
+                        return 'CodeCompanion (' .. adapter.formatted_name .. ': ' .. adapter.parameters.model .. ')'
+                    end,
+                },
+                keymaps = {
+                    send = {
+                        modes = { n = '<C-s>', i = '<C-s>' },
+                    },
+                    close = {
+                        modes = { n = '<C-c>', i = '<C-c>' },
+                    },
+                },
+            },
+            inline = {
+                adapter = 'flash',
+            },
+        }
+
+        opts.extensions = {
+            mcphub = {
+                callback = 'mcphub.extensions.codecompanion',
+                opts = {
+                    show_result_in_chat = true,
+                    make_vars = true,
+                    make_slash_commands = true,
+                },
+            },
+        }
+
+        opts.system_prompt = function(opts)
+            local language = opts.language or 'English'
+            return string.format(
+                [[You are an AI programming assistant named "CodeCompanion". You are currently plugged into the Neovim text editor on a user's machine.
+
+Your core tasks include:
+- Answering general programming questions.
+- Explaining how the code in a Neovim buffer works.
+- Reviewing the selected code from a Neovim buffer.
+- Generating unit tests for the selected code.
+- Proposing fixes for problems in the selected code.
+- Scaffolding code for a new workspace.
+- Finding relevant code to the user's query.
+- Proposing fixes for test failures.
+- Answering questions about Neovim.
+- Running tools.
+
+You must:
+- Follow the user's requirements carefully and to the letter.
+- Keep your answers short and impersonal, especially if the user's context is outside your core tasks.
+- Minimize additional prose unless clarification is needed.
+- Use Markdown formatting in your answers.
+- Include the programming language name at the start of each Markdown code block.
+- Avoid including line numbers in code blocks.
+- Avoid wrapping the whole response in triple backticks.
+- Only return code that's directly relevant to the task at hand. You may omit code that isn’t necessary for the solution.
+- Avoid using H1, H2 or H3 headers in your responses as these are reserved for the user.
+- Use actual line breaks in your responses; only use "\n" when you want a literal backslash followed by 'n'.
+- All non-code text responses must be written in the %s language indicated.
+- Multiple, different tools can be called as part of the same response.
+
+When given a task:
+1. Think step-by-step and, unless the user requests otherwise or the task is very simple, describe your plan in detailed pseudocode.
+2. Output the final code in a single code block, ensuring that only relevant code is included.
+3. End your response with a short suggestion for the next user turn that directly supports continuing the conversation.
+4. Provide exactly one complete reply per conversation turn.
+5. If necessary, execute multiple tools in a single turn.]],
+                language
+            )
+        end
+
+        opts.prompt_library = {
+            ['Code Expert'] = {
+                strategy = 'chat',
+                description = 'Get some special adcvice from an LLM.',
+                opts = {
+                    mapping = '<Leader>ce',
+                    modes = { 'v' },
+                    short_name = 'expert',
+                    auto_submit = true,
+                    stop_context_insertion = true,
+                    user_prompt = true,
+                },
+                prompts = {
+                    {
+                        role = 'system',
+                        content = function(context)
+                            return 'I want you to act as a senior'
+                                .. context.filetype
+                                .. 'developer I will ask you specific questions and I want you to return concise explanations and codeblock examples.'
+                        end,
+                    },
+                    {
+                        role = 'user',
+                        content = function(context)
+                            local text = require('codecompanion.helpers.actions').get_code(context.start_line, context.end_line)
+
+                            return 'I have the following code:\n\n```' .. context.filetype .. '\n' .. text .. '\n```\n\n'
+                        end,
+                        opts = {
+                            contains_code = true,
+                        },
+                    },
+                },
+            },
+            ['Games Master'] = {
+                strategy = 'chat',
+                description = 'A personal Games Master Assistant.',
+                opts = {
+                    mapping = '<Leader>cd',
+                    modes = { 'n' },
+                    short_name = 'gm',
+                    auto_submit = false,
+                    stop_context_insertion = false,
+                    user_prompt = false,
+                    is_default = true,
+                    adapter = {
+                        temperature = 1,
+                    },
+                },
+                prompts = {
+                    {
+                        role = 'system',
+                        content = function(context)
+                            return [[
+You are a personal Games Master Assistant. You are currently plugged in to the Neovim text editor on a user's machine.
+
+Your core tasks include:
+- Crafting engaging role playing sessions
+- Building immersive and authentic worlds
+- Creating compelling characters for the players to interact with and drive the story
+- Reviewing session summaries and building on them
+- Providing advice on how to bring sessions to life
+- Create exciting encounters to challenge the players
+    - Encounters can be combat, social, or exploration based
+    - There should always be a story reason for the encounter
+- Combine player character backgrounds and motivations into the world
+- Build tension and drama into the game
+- Ensure each session provides opportunities for the players to engage with and drive the story
+
+You must:
+- Follow the user's requirements carefully and to the letter.
+- Keep answers focused on the task at hand.
+- Provide original ideas and suggestions.
+- Use Markdown formatting in your answers.
+- Use actual line breaks instead of '\n' in your response to begin new lines.
+- Use '\n' only when you want a literal backslash followed by a character 'n'.
+- All responses must be written in English.
+- Multiple, different tools can be called as part of the same response.
+- Help sessions be fast paced and fun.
+- Ensure there are multiple soltuions to each problem.
+- Avoid railroading the players.
+
+When given a task:
+1. Consider the existing world and characters. Use tools to gather information that may be relevant.
+2. Provide exactly one complete reply per conversation turn.
+3. If necessary, execute multiple tools in a single turn.
+]]
+                        end,
+                    },
+                    {
+                        role = 'user',
+                        content = function(context)
+                            return ''
+                        end,
+                        opts = {
+                            contains_code = false,
+                        },
+                    },
+                },
+            },
+        }
+    end,
+    dependencies = {
+        'nvim-lua/plenary.nvim',
+        'nvim-treesitter/nvim-treesitter',
+        'Davidyz/VectorCode',
+        'ravitemer/mcphub.nvim',
+    },
+}

lua/plugins/copilot.lua

@@ -0,0 +1,3 @@
+return {
+    'github/copilot.vim',
+}

lua/plugins/debug.lua

@@ -1,3 +1,4 @@
+require('helpers').edit_cf('pd', '/lua/plugins/debug.lua')
 -- debug.lua
 --
 -- Shows how to use the DAP plugin to debug your code.
@@ -25,42 +26,42 @@ return {
     keys = {
         -- Basic debugging keymaps, feel free to change to your liking!
         {
-            '<F5>',
+            '<Leader>dc',
             function()
                 require('dap').continue()
             end,
             desc = 'Debug: Start/Continue',
         },
         {
-            '<F1>',
+            '<Leader>di',
             function()
                 require('dap').step_into()
             end,
             desc = 'Debug: Step Into',
         },
         {
-            '<F2>',
+            '<Leader>do',
             function()
                 require('dap').step_over()
             end,
             desc = 'Debug: Step Over',
         },
         {
-            '<F3>',
+            '<Leader>du',
             function()
                 require('dap').step_out()
             end,
             desc = 'Debug: Step Out',
         },
         {
-            '<leader>b',
+            '<leader>db',
             function()
                 require('dap').toggle_breakpoint()
             end,
             desc = 'Debug: Toggle Breakpoint',
         },
         {
-            '<leader>B',
+            '<leader>dB',
             function()
                 require('dap').set_breakpoint(vim.fn.input 'Breakpoint condition: ')
             end,
@@ -68,11 +69,11 @@ return {
         },
         -- Toggle to see last session result. Without this, you can't see session output in case of unhandled exception.
         {
-            '<F7>',
+            '<Leader>ds',
             function()
                 require('dapui').toggle()
             end,
-            desc = 'Debug: See last session result.',
+            desc = 'Debug: Toggle UI',
         },
     },
     config = function()
@@ -86,7 +87,28 @@ return {
 
             -- You can provide additional configuration to the handlers,
             -- see mason-nvim-dap README for more information
-            handlers = {},
+            handlers = {
+                function(config)
+                    require('mason-nvim-dap').default_setup(config)
+                end,
+                php = function(config)
+                    config.configurations = {
+                        {
+                            type = 'php',
+                            request = 'launch',
+                            name = 'Listen for XDebug',
+                            port = 9003,
+                            log = true,
+                            -- pathMappings = {
+                            --     ['/var/www/html/'] = vim.fn.getcwd() .. '/',
+                            -- },
+                            hostname = '0.0.0.0',
+                        },
+                    }
+
+                    require('mason-nvim-dap').default_setup(config)
+                end,
+            },
 
             -- You'll need to check that you have the required things installed
             -- online, please don't ask me how to install them :)
@@ -96,6 +118,26 @@ return {
             },
         }
 
+        dap.adapters.php = {
+            type = 'executable',
+            command = 'node',
+            args = { '/Users/chris/.local/src/vscode-php-debug/out/phpDebug.js' },
+        }
+
+        dap.configurations.php = {
+            {
+                type = 'php',
+                request = 'launch',
+                name = 'Listen for XDebug',
+                port = 9003,
+                log = true,
+                -- pathMappings = {
+                --     ['/var/www/html/'] = vim.fn.getcwd() .. '/',
+                -- },
+                hostname = '0.0.0.0',
+            },
+        }
+
         -- Dap UI setup
         -- For more information, see |:help nvim-dap-ui|
         dapui.setup {
@@ -105,29 +147,67 @@ return {
             icons = { expanded = '▾', collapsed = '▸', current_frame = '*' },
             controls = {
                 icons = {
-                    pause = '⏸',
-                    play = '▶',
-                    step_into = '⏎',
-                    step_over = '⏭',
-                    step_out = '⏮',
-                    step_back = 'b',
-                    run_last = '▶▶',
-                    terminate = '⏹',
-                    disconnect = '⏏',
+                    pause = '',
+                    play = '',
+                    step_into = '󰆹',
+                    step_over = '󰆷',
+                    step_out = '󰆸',
+                    step_back = '',
+                    run_last = '',
+                    terminate = '',
+                    disconnect = '',
                 },
             },
         }
 
         -- Change breakpoint icons
-        -- vim.api.nvim_set_hl(0, 'DapBreak', { fg = '#e51400' })
-        -- vim.api.nvim_set_hl(0, 'DapStop', { fg = '#ffcc00' })
-        -- local breakpoint_icons = vim.g.have_nerd_font
-        --     and { Breakpoint = '', BreakpointCondition = '', BreakpointRejected = '', LogPoint = '', Stopped = '' }
-        --   or { Breakpoint = '●', BreakpointCondition = '⊜', BreakpointRejected = '⊘', LogPoint = '◆', Stopped = '⭔' }
-        -- for type, icon in pairs(breakpoint_icons) do
-        --   local tp = 'Dap' .. type
-        --   local hl = (type == 'Stopped') and 'DapStop' or 'DapBreak'
-        --   vim.fn.sign_define(tp, { text = icon, texthl = hl, numhl = hl })
+        vim.api.nvim_set_hl(0, 'DapBreak', { fg = '#e51400' })
+        vim.api.nvim_set_hl(0, 'DapStop', { fg = '#ffcc00' })
+        local breakpoint_icons = vim.g.have_nerd_font
+                and { Breakpoint = '', BreakpointCondition = '', BreakpointRejected = '', LogPoint = '', Stopped = '' }
+            or { Breakpoint = '●', BreakpointCondition = '⊜', BreakpointRejected = '⊘', LogPoint = '◆', Stopped = '⭔' }
+        for type, icon in pairs(breakpoint_icons) do
+            local tp = 'Dap' .. type
+            local hl = (type == 'Stopped') and 'DapStop' or 'DapBreak'
+            vim.fn.sign_define(tp, { text = icon, texthl = hl, numhl = hl })
+        end
+
+        local function get_php_ini_dir()
+            local handle = io.popen 'php --ini 2>/dev/null'
+            if not handle then
+                return nil
+            end
+            local result = handle:read '*a'
+            handle:close()
+            local dir = result:match 'Scan for additional .ini files in:%s+([^\n]+)'
+            if dir and dir:find '%(none%)' == nil then
+                return vim.trim(dir)
+            end
+            return nil
+        end
+
+        local function enable_xdebug()
+            local ini_dir = get_php_ini_dir()
+            if not ini_dir then
+                return
+            end
+            os.execute(string.format('mv "%s/20-xdebug.ini.disabled" "%s/20-xdebug.ini" 2>/dev/null', ini_dir, ini_dir))
+        end
+
+        local function disable_xdebug()
+            local ini_dir = get_php_ini_dir()
+            if not ini_dir then
+                return
+            end
+            os.execute(string.format('mv "%s/20-xdebug.ini" "%s/20-xdebug.ini.disabled" 2>/dev/null', ini_dir, ini_dir))
+        end
+
+        dap.listeners.after.event_initialized['xdebug_enable'] = enable_xdebug
+        dap.listeners.before.event_terminated['xdebug_disable'] = disable_xdebug
+        dap.listeners.before.event_exited['xdebug_disable'] = disable_xdebug
+
+        -- dap.listeners.after.event_output['neotest_display'] = function(_, body)
+        --     require('neotest').output.open { enter = true, last = true }
         -- end
 
         dap.listeners.after.event_initialized['dapui_config'] = dapui.open

lua/plugins/dotenv.lua

@@ -0,0 +1,3 @@
+return {
+    'ellisonleao/dotenv.nvim',
+}

lua/plugins/edgy.lua

@@ -0,0 +1,101 @@
+return {
+    "folke/edgy.nvim",
+    event = "VeryLazy",
+    init = function()
+        vim.opt.laststatus = 3
+        vim.opt.splitkeep = "screen"
+    end,
+    opts = {
+        bottom = {
+            -- toggleterm / lazyterm at the bottom with a height of 40% of the screen
+            {
+                ft = "toggleterm",
+                size = { height = 0.4 },
+                -- exclude floating windows
+                filter = function(buf, win)
+                    return vim.api.nvim_win_get_config(win).relative == ""
+                end,
+            },
+            {
+                ft = "lazyterm",
+                title = "LazyTerm",
+                size = { height = 0.4 },
+                filter = function(buf)
+                    return not vim.b[buf].lazyterm_cmd
+                end,
+            },
+            {
+                ft = "snack_terminal",
+                size = { height = 0.4 },
+                title = "%{b:snacks_terminal.id}: %{b:term_title}",
+                filter = function(_buf, win)
+                    return vim.w[win].snacks_win
+                        and vim.w[win].snacks_win.position == pos
+                        and vim.w[win].snacks_win.relative == "editor"
+                        and not vim.w[win].trouble_preview
+                end,
+            },
+            "Trouble",
+            { ft = "qf", title = "QuickFix" },
+            {
+                ft = "help",
+                size = { height = 20 },
+                -- only show help buffers
+                filter = function(buf)
+                    return vim.bo[buf].buftype == "help"
+                end,
+            },
+            { ft = "spectre_panel", size = { height = 0.4 } },
+        },
+        left = {
+            -- Neo-tree filesystem always takes half the screen height
+            {
+                title = "Neo-Tree",
+                ft = "neo-tree",
+                filter = function(buf)
+                    return vim.b[buf].neo_tree_source == "filesystem"
+                end,
+                size = { height = 0.5 },
+            },
+            {
+                title = "Neo-Tree Git",
+                ft = "neo-tree",
+                filter = function(buf)
+                    return vim.b[buf].neo_tree_source == "git_status"
+                end,
+                pinned = true,
+                collapsed = true, -- show window as closed/collapsed on start
+                open = "Neotree position=right git_status",
+            },
+            {
+                title = "Neo-Tree Buffers",
+                ft = "neo-tree",
+                filter = function(buf)
+                    return vim.b[buf].neo_tree_source == "buffers"
+                end,
+                pinned = true,
+                collapsed = true, -- show window as closed/collapsed on start
+                open = "Neotree position=top buffers",
+            },
+            {
+                title = function()
+                    local buf_name = vim.api.nvim_buf_get_name(0) or "[No Name]"
+                    return vim.fn.fnamemodify(buf_name, ":t")
+                end,
+                ft = "Outline",
+                pinned = true,
+                open = "SymbolsOutlineOpen",
+
+            },
+            -- any other neo-tree windows
+            "neo-tree",
+        },
+        right = {
+            {
+                title = 'Code Companion',
+                ft = 'codecompanion',
+                size = { width = 0.3 },
+            }
+        }
+    },
+}

lua/plugins/fidget.lua

@@ -0,0 +1,3 @@
+return {
+    'j-hui/fidget.nvim',
+}

lua/plugins/git_blame.lua

@@ -0,0 +1,10 @@
+return {
+    'f-person/git-blame.nvim',
+    event = 'VeryLazy',
+    opts = {
+        enabled = true, -- if you want to enable the plugin
+        message_template = ' <summary> • <date> • <author> • <<sha>>', -- template for the blame message, check the Message template section for more options
+        date_format = '%m-%d-%Y %H:%M:%S', -- template for the date, check Date format section for more options
+        virtual_text_column = 1, -- virtual text start column, check Start virtual text at column section for more options
+    },
+}

lua/plugins/gitsigns.lua

@@ -1,3 +1,4 @@
+require('helpers').edit_cf('pg', '/lua/plugins/gitsigns.lua')
 -- Adds git related signs to the gutter, as well as utilities for managing changes
 -- See `:help gitsigns`
 return {

lua/plugins/lint.lua

@@ -7,6 +7,9 @@ return {
         lint.linters_by_ft = {
             markdown = { 'markdownlint' },
         }
+        lint.linters_by_ft['javascript'] = nil
+        lint.linters_by_ft['vue'] = nil
+        lint.linters_by_ft['html'] = nil
 
         -- To allow other plugins to add linters to require('lint').linters_by_ft,
         -- instead set linters_by_ft like this:

lua/plugins/lsp.lua

@@ -1,4 +1,6 @@
 -- Main LSP Configuration
+require('helpers').edit_cf('pl', '/lua/plugins/lsp.lua')
+
 return {
     'neovim/nvim-lspconfig',
     dependencies = {
@@ -194,6 +196,9 @@ return {
         --  - capabilities (table): Override fields in capabilities. Can be used to disable certain LSP features.
         --  - settings (table): Override the default settings passed when initializing the server.
         --        For example, to see the options for `lua_ls`, you could go to: https://luals.github.io/wiki/settings/
+
+        local mason_registry = require 'mason-registry'
+        local vue_language_server_path = mason_registry.get_package('vue-language-server'):get_install_path() .. '/node_modules/@vue/language-server'
         local servers = {
             -- clangd = {},
             -- gopls = {},
@@ -222,6 +227,48 @@ return {
                     },
                 },
             },
+            ts_ls = {
+                init_options = {
+                    plugins = {
+                        {
+                            name = '@vue/typescript-plugin',
+                            location = vue_language_server_path,
+                            languages = { 'vue' },
+                        },
+                    },
+                    preferences = {
+                        importModuleSpecifierEnding = 'js',
+                        importModuleSpecifierPreference = 'project-relative',
+                    },
+                },
+                filetypes = { 'typescript', 'javascript', 'javascriptreact', 'typescriptreact', 'vue' },
+                capabilities = {
+                    documentFormattingProvider = true,
+                    documentRangeFormattingProvider = true,
+                },
+            },
+
+            volar = {
+                on_attach = function(client, bufnr)
+                    client.server_capabilities.documentFormattingProvider = false
+                end,
+                capabilities = {
+                    documentFormattingProvider = true,
+                    documentRangeFormattingProvider = true,
+                },
+            },
+
+            phpactor = {
+                on_attach = function(client, bufnr)
+                    client.server_capabilities.documentFormattingProvider = false
+                end,
+                init_options = {
+                    ['language_server_phpstan.enabled'] = false,
+                    ['language_server_psalm.enabled'] = false,
+                    ['language_server_php_cs_fixer.enabled'] = true,
+                    ['language_server_php_cs_fixer.bin'] = '~/.composer/vendor/bin/php-cs-fixer',
+                },
+            },
         }
 
         -- Ensure the servers and tools above are installed

lua/plugins/mcp.lua

@@ -0,0 +1,16 @@
+return {
+    'ravitemer/mcphub.nvim',
+    dependencies = {
+        'nvim-lua/plenary.nvim', -- Required for Job and HTTP requests
+    },
+    -- uncomment the following line to load hub lazily
+    cmd = 'MCPHub', -- lazy load
+    build = 'npm install -g mcp-hub@latest', -- Installs required mcp-hub npm module
+    -- uncomment this if you don't want mcp-hub to be available globally or can't use -g
+    -- build = "bundled_build.lua",  -- Use this and set use_bundled_binary = true in opts  (see Advanced configuration)
+    config = function()
+        require('mcphub').setup({
+            auto_approve = true,
+        })
+    end,
+}

lua/plugins/mini.lua

@@ -1,38 +1,54 @@
 -- Collection of various small independent plugins/modules
 return {
-	"echasnovski/mini.nvim",
-	config = function()
-		-- Better Around/Inside textobjects
-		--
-		-- Examples:
-		--  - va)  - [V]isually select [A]round [)]paren
-		--  - yinq - [Y]ank [I]nside [N]ext [Q]uote
-		--  - ci'  - [C]hange [I]nside [']quote
-		require("mini.ai").setup({ n_lines = 500 })
+    'echasnovski/mini.nvim',
+    config = function()
+        -- Better Around/Inside textobjects
+        --
+        -- Examples:
+        --  - va)  - [V]isually select [A]round [)]paren
+        --  - yinq - [Y]ank [I]nside [N]ext [Q]uote
+        --  - ci'  - [C]hange [I]nside [']quote
+        require('mini.ai').setup { n_lines = 500 }
 
-		-- Add/delete/replace surroundings (brackets, quotes, etc.)
-		--
-		-- - saiw) - [S]urround [A]dd [I]nner [W]ord [)]Paren
-		-- - sd'   - [S]urround [D]elete [']quotes
-		-- - sr)'  - [S]urround [R]eplace [)] [']
-		require("mini.surround").setup()
+        -- Add/delete/replace surroundings (brackets, quotes, etc.)
+        --
+        -- - saiw) - [S]urround [A]dd [I]nner [W]ord [)]Paren
+        -- - sd'   - [S]urround [D]elete [']quotes
+        -- - sr)'  - [S]urround [R]eplace [)] [']
+        require('mini.surround').setup {
+            mappings = {
+                add = 'ys',
+                delete = 'ds',
+                replace = 'cs',
+            },
+        }
 
-		-- Simple and easy statusline.
-		--  You could remove this setup call if you don't like it,
-		--  and try some other statusline plugin
-		local statusline = require("mini.statusline")
-		-- set use_icons to true if you have a Nerd Font
-		statusline.setup({ use_icons = vim.g.have_nerd_font })
+        require('mini.pairs').setup()
 
-		-- You can configure sections in the statusline by overriding their
-		-- default behavior. For example, here we set the section for
-		-- cursor location to LINE:COLUMN
-		---@diagnostic disable-next-line: duplicate-set-field
-		statusline.section_location = function()
-			return "%2l:%-2v"
-		end
+        -- require('mini.jump').setup()
 
-		-- ... and there is more!
-		--  Check out: https://github.com/echasnovski/mini.nvim
-	end,
+        require('mini.jump2d').setup()
+
+        require('mini.splitjoin').setup()
+
+        require('mini.map').setup()
+
+        -- Simple and easy statusline.
+        --  You could remove this setup call if you don't like it,
+        --  and try some other statusline plugin
+        local statusline = require 'mini.statusline'
+        -- set use_icons to true if you have a Nerd Font
+        statusline.setup { use_icons = vim.g.have_nerd_font }
+
+        -- You can configure sections in the statusline by overriding their
+        -- default behavior. For example, here we set the section for
+        -- cursor location to LINE:COLUMN
+        ---@diagnostic disable-next-line: duplicate-set-field
+        statusline.section_location = function()
+            return '%2l:%-2v'
+        end
+
+        -- ... and there is more!
+        --  Check out: https://github.com/echasnovski/mini.nvim
+    end,
 }

lua/plugins/neo-tree.lua

@@ -13,8 +13,19 @@ return {
     keys = {
         { '\\', ':Neotree reveal<CR>', desc = 'NeoTree reveal', silent = true },
     },
-    opts = {
-        filesystem = {
+
+    opts = function(_, opts)
+        local function on_move(data)
+            Snacks.rename.on_rename_file(data.source, data.destination)
+        end
+        local events = require("neo-tree.events")
+        opts.event_handlers = opts.event_handlers or {}
+        vim.list_extend(opts.event_handlers, {
+            { event = events.FILE_MOVED, handler = on_move },
+            { event = events.FILE_RENAMED, handler = on_move },
+        })
+
+        opts.filesystem = {
             window = {
                 mappings = {
                     ['\\'] = 'close_window',
@@ -23,6 +34,6 @@ return {
             filtered_items = {
                 hide_dotfiles = false,
             },
-        },
-    },
+        }
+    end,
 }

lua/plugins/neotest.lua

@@ -0,0 +1,27 @@
+require('helpers').edit_cf('pt', '/lua/plugins/neotest.lua')
+return {
+    'nvim-neotest/neotest',
+    lazy = true,
+    dependencies = {
+        'nvim-neotest/nvim-nio',
+        'nvim-lua/plenary.nvim',
+        'antoinemadec/FixCursorHold.nvim',
+        'nvim-treesitter/nvim-treesitter',
+        -- Adapters
+        'V13Axel/neotest-pest',
+        -- "olimorris/neotest-phpunit",
+    },
+    config = function()
+        require('neotest').setup {
+            adapters = {
+                require 'neotest-pest' {
+                    sail_enabled = function()
+                        return false
+                    end,
+                    parallel = 10,
+                },
+                -- require('neotest-phpunit'),
+            },
+        }
+    end,
+}

lua/plugins/oil.lua

@@ -0,0 +1,23 @@
+-- Filesystem manager
+require('helpers').edit_cf('po', '/lua/plugins/oil.lua')
+
+vim.keymap.set('n', '-', '<CMD>Oil<CR>', { desc = 'Open parent directory' })
+
+return {
+    'stevearc/oil.nvim',
+    ---@module 'oil'
+    ---@type oil.SetupOpts
+    opts = {
+        view_options = {
+            show_hidden = true,
+        },
+        keymaps = {
+            ['<C-p>'] = false,
+        },
+    },
+    -- Optional dependencies
+    dependencies = { { 'echasnovski/mini.icons', opts = {} } },
+    -- dependencies = { "nvim-tree/nvim-web-devicons" }, -- use if you prefer nvim-web-devicons
+    -- Lazy loading is not recommended because it is very tricky to make it work correctly in all situations.
+    lazy = false,
+}

lua/plugins/refactor.lua

@@ -0,0 +1,9 @@
+return   {
+    "ThePrimeagen/refactoring.nvim",
+    dependencies = {
+        "nvim-lua/plenary.nvim",
+        "nvim-treesitter/nvim-treesitter",
+    },
+    lazy = false,
+    opts = {},
+}

lua/plugins/render_markdown.lua

@@ -0,0 +1,10 @@
+return {
+    'MeanderingProgrammer/render-markdown.nvim',
+    dependencies = { 'nvim-treesitter/nvim-treesitter', 'echasnovski/mini.nvim' }, -- if you use the mini.nvim suite
+    -- dependencies = { 'nvim-treesitter/nvim-treesitter', 'echasnovski/mini.icons' }, -- if you use standalone mini plugins
+    -- dependencies = { 'nvim-treesitter/nvim-treesitter', 'nvim-tree/nvim-web-devicons' }, -- if you prefer nvim-web-devicons
+    ---@module 'render-markdown'
+    ---@type render.md.UserConfig
+    opts = {},
+    ft = { 'markdown', 'codecompanion' },
+}

lua/plugins/snacks.lua

@@ -0,0 +1,24 @@
+return {
+    'folke/snacks.nvim',
+    priority = 1000,
+    lazy = false,
+    ---@type snacks.Config
+    opts = {
+        -- your configuration comes here
+        -- or leave it empty to use the default settings
+        -- refer to the configuration section below
+        bigfile = { enabled = true },
+        dashboard = { enabled = true },
+        indent = { enabled = true },
+        input = { enabled = true },
+        notifier = { enabled = true },
+        quickfile = { enabled = true },
+        scope = { enabled = true },
+        -- scroll = { enabled = true },
+        statuscolumn = { enabled = true },
+        words = { enabled = true },
+        terminal = { enabled = true },
+        scratch = { enabled = true },
+        rename = { enabled = true },
+    },
+}

lua/plugins/snippets.lua

@@ -0,0 +1,31 @@
+return {
+    'L3MON4D3/LuaSnip',
+    version = '2.*',
+    build = (function()
+        -- Build Step is needed for regex support in snippets.
+        -- This step is not supported in many windows environments.
+        -- Remove the below condition to re-enable on windows.
+        if vim.fn.has 'win32' == 1 or vim.fn.executable 'make' == 0 then
+            return
+        end
+        return 'make install_jsregexp'
+    end)(),
+    config = function()
+        local snippets_dir = vim.fn.stdpath 'config' .. '/lua/snippets'
+        require('luasnip.loaders.from_vscode').lazy_load {
+            paths = { snippets_dir },
+        }
+    end,
+    dependencies = {
+        -- `friendly-snippets` contains a variety of premade snippets.
+        --    See the README about individual language/framework/plugin snippets:
+        --    https://github.com/rafamadriz/friendly-snippets
+        {
+            'rafamadriz/friendly-snippets',
+            config = function()
+                require('luasnip.loaders.from_vscode').lazy_load()
+            end,
+        },
+    },
+    opts = {},
+}

lua/plugins/telescope.lua

@@ -1,105 +1,122 @@
 -- Fuzzy Finder (files, lsp, etc)
 -- See :help telescope
 return {
-	"nvim-telescope/telescope.nvim",
-	event = "VimEnter",
-	dependencies = {
-		"nvim-lua/plenary.nvim",
-		{ -- If encountering errors, see telescope-fzf-native README for installation instructions
-			"nvim-telescope/telescope-fzf-native.nvim",
+    'nvim-telescope/telescope.nvim',
+    event = 'VimEnter',
+    dependencies = {
+        'nvim-lua/plenary.nvim',
+        { -- If encountering errors, see telescope-fzf-native README for installation instructions
+            'nvim-telescope/telescope-fzf-native.nvim',
 
-			-- `build` is used to run some command when the plugin is installed/updated.
-			-- This is only run then, not every time Neovim starts up.
-			build = "make",
+            -- `build` is used to run some command when the plugin is installed/updated.
+            -- This is only run then, not every time Neovim starts up.
+            build = 'make',
 
-			-- `cond` is a condition used to determine whether this plugin should be
-			-- installed and loaded.
-			cond = function()
-				return vim.fn.executable("make") == 1
-			end,
-		},
-		{ "nvim-telescope/telescope-ui-select.nvim" },
+            -- `cond` is a condition used to determine whether this plugin should be
+            -- installed and loaded.
+            cond = function()
+                return vim.fn.executable 'make' == 1
+            end,
+        },
+        { 'nvim-telescope/telescope-ui-select.nvim' },
 
-		-- Useful for getting pretty icons, but requires a Nerd Font.
-		{ "nvim-tree/nvim-web-devicons", enabled = vim.g.have_nerd_font },
-	},
-	config = function()
-		-- Telescope is a fuzzy finder that comes with a lot of different things that
-		-- it can fuzzy find! It's more than just a "file finder", it can search
-		-- many different aspects of Neovim, your workspace, LSP, and more!
-		--
-		-- The easiest way to use Telescope, is to start by doing something like:
-		--  :Telescope help_tags
-		--
-		-- After running this command, a window will open up and you're able to
-		-- type in the prompt window. You'll see a list of `help_tags` options and
-		-- a corresponding preview of the help.
-		--
-		-- Two important keymaps to use while in Telescope are:
-		--  - Insert mode: <c-/>
-		--  - Normal mode: ?
-		--
-		-- This opens a window that shows you all of the keymaps for the current
-		-- Telescope picker. This is really useful to discover what Telescope can
-		-- do as well as how to actually do it!
+        -- Useful for getting pretty icons, but requires a Nerd Font.
+        { 'nvim-tree/nvim-web-devicons', enabled = vim.g.have_nerd_font },
+    },
+    config = function()
+        -- Telescope is a fuzzy finder that comes with a lot of different things that
+        -- it can fuzzy find! It's more than just a "file finder", it can search
+        -- many different aspects of Neovim, your workspace, LSP, and more!
+        --
+        -- The easiest way to use Telescope, is to start by doing something like:
+        --  :Telescope help_tags
+        --
+        -- After running this command, a window will open up and you're able to
+        -- type in the prompt window. You'll see a list of `help_tags` options and
+        -- a corresponding preview of the help.
+        --
+        -- Two important keymaps to use while in Telescope are:
+        --  - Insert mode: <c-/>
+        --  - Normal mode: ?
+        --
+        -- This opens a window that shows you all of the keymaps for the current
+        -- Telescope picker. This is really useful to discover what Telescope can
+        -- do as well as how to actually do it!
 
-		-- [[ Configure Telescope ]]
-		-- See `:help telescope` and `:help telescope.setup()`
-		require("telescope").setup({
-			-- You can put your default mappings / updates / etc. in here
-			--  All the info you're looking for is in `:help telescope.setup()`
-			--
-			-- defaults = {
-			--   mappings = {
-			--     i = { ['<c-enter>'] = 'to_fuzzy_refine' },
-			--   },
-			-- },
-			-- pickers = {}
-			extensions = {
-				["ui-select"] = {
-					require("telescope.themes").get_dropdown(),
-				},
-			},
-		})
+        -- [[ Configure Telescope ]]
+        -- See `:help telescope` and `:help telescope.setup()`
+        require('telescope').setup {
+            -- You can put your default mappings / updates / etc. in here
+            --  All the info you're looking for is in `:help telescope.setup()`
+            --
+            -- defaults = {
+            --   mappings = {
+            --     i = { ['<c-enter>'] = 'to_fuzzy_refine' },
+            --   },
+            -- },
+            -- pickers = {}
+            extensions = {
+                ['ui-select'] = {
+                    require('telescope.themes').get_dropdown(),
+                },
+            },
+            defaults = {
+                mappings = {
+                    i = {
+                        -- Insert mode mappings for Telescope
+                        ['<C-j>'] = 'move_selection_next',
+                        ['<C-k>'] = 'move_selection_previous',
+                    },
+                    n = {
+                        -- Normal mode mappings for Telescope
+                        ['<C-j>'] = 'move_selection_next',
+                        ['<C-k>'] = 'move_selection_previous',
+                    },
+                },
+                file_ignore_patterns = {
+                    '.obsidian',
+                },
+            },
+        }
 
-		-- Enable Telescope extensions if they are installed
-		pcall(require("telescope").load_extension, "fzf")
-		pcall(require("telescope").load_extension, "ui-select")
+        -- Enable Telescope extensions if they are installed
+        pcall(require('telescope').load_extension, 'fzf')
+        pcall(require('telescope').load_extension, 'ui-select')
 
-		-- See `:help telescope.builtin`
-		local builtin = require("telescope.builtin")
-		vim.keymap.set("n", "<leader>sh", builtin.help_tags, { desc = "[S]earch [H]elp" })
-		vim.keymap.set("n", "<leader>sk", builtin.keymaps, { desc = "[S]earch [K]eymaps" })
-		vim.keymap.set("n", "<leader>sf", builtin.find_files, { desc = "[S]earch [F]iles" })
-		vim.keymap.set("n", "<leader>ss", builtin.builtin, { desc = "[S]earch [S]elect Telescope" })
-		vim.keymap.set("n", "<leader>sw", builtin.grep_string, { desc = "[S]earch current [W]ord" })
-		vim.keymap.set("n", "<leader>sg", builtin.live_grep, { desc = "[S]earch by [G]rep" })
-		vim.keymap.set("n", "<leader>sd", builtin.diagnostics, { desc = "[S]earch [D]iagnostics" })
-		vim.keymap.set("n", "<leader>sr", builtin.resume, { desc = "[S]earch [R]esume" })
-		vim.keymap.set("n", "<leader>s.", builtin.oldfiles, { desc = '[S]earch Recent Files ("." for repeat)' })
-		vim.keymap.set("n", "<leader><leader>", builtin.buffers, { desc = "[ ] Find existing buffers" })
+        -- See `:help telescope.builtin`
+        local builtin = require 'telescope.builtin'
+        vim.keymap.set('n', '<leader>sh', builtin.help_tags, { desc = '[S]earch [H]elp' })
+        vim.keymap.set('n', '<leader>sk', builtin.keymaps, { desc = '[S]earch [K]eymaps' })
+        vim.keymap.set('n', '<leader>sf', builtin.find_files, { desc = '[S]earch [F]iles' })
+        vim.keymap.set('n', '<leader>ss', builtin.builtin, { desc = '[S]earch [S]elect Telescope' })
+        vim.keymap.set('n', '<leader>sw', builtin.grep_string, { desc = '[S]earch current [W]ord' })
+        vim.keymap.set('n', '<leader>sg', builtin.live_grep, { desc = '[S]earch by [G]rep' })
+        vim.keymap.set('n', '<leader>sd', builtin.diagnostics, { desc = '[S]earch [D]iagnostics' })
+        vim.keymap.set('n', '<leader>sr', builtin.resume, { desc = '[S]earch [R]esume' })
+        vim.keymap.set('n', '<leader>s.', builtin.oldfiles, { desc = '[S]earch Recent Files ("." for repeat)' })
+        vim.keymap.set('n', '<leader><leader>', builtin.buffers, { desc = '[ ] Find existing buffers' })
 
-		-- Slightly advanced example of overriding default behavior and theme
-		vim.keymap.set("n", "<leader>/", function()
-			-- You can pass additional configuration to Telescope to change the theme, layout, etc.
-			builtin.current_buffer_fuzzy_find(require("telescope.themes").get_dropdown({
-				winblend = 10,
-				previewer = false,
-			}))
-		end, { desc = "[/] Fuzzily search in current buffer" })
+        -- Slightly advanced example of overriding default behavior and theme
+        vim.keymap.set('n', '<leader>/', function()
+            -- You can pass additional configuration to Telescope to change the theme, layout, etc.
+            builtin.current_buffer_fuzzy_find(require('telescope.themes').get_dropdown {
+                winblend = 10,
+                previewer = false,
+            })
+        end, { desc = '[/] Fuzzily search in current buffer' })
 
-		-- It's also possible to pass additional configuration options.
-		--  See `:help telescope.builtin.live_grep()` for information about particular keys
-		vim.keymap.set("n", "<leader>s/", function()
-			builtin.live_grep({
-				grep_open_files = true,
-				prompt_title = "Live Grep in Open Files",
-			})
-		end, { desc = "[S]earch [/] in Open Files" })
+        -- It's also possible to pass additional configuration options.
+        --  See `:help telescope.builtin.live_grep()` for information about particular keys
+        vim.keymap.set('n', '<leader>s/', function()
+            builtin.live_grep {
+                grep_open_files = true,
+                prompt_title = 'Live Grep in Open Files',
+            }
+        end, { desc = '[S]earch [/] in Open Files' })
 
-		-- Shortcut for searching your Neovim configuration files
-		vim.keymap.set("n", "<leader>sn", function()
-			builtin.find_files({ cwd = vim.fn.stdpath("config") })
-		end, { desc = "[S]earch [N]eovim files" })
-	end,
+        -- Shortcut for searching your Neovim configuration files
+        vim.keymap.set('n', '<leader>sn', function()
+            builtin.find_files { cwd = vim.fn.stdpath 'config' }
+        end, { desc = '[S]earch [N]eovim files' })
+    end,
 }

lua/plugins/vectorcode.lua

@@ -0,0 +1,11 @@
+require('helpers').edit_cf('pv', '/lua/plugins/vectorcode.lua')
+return {
+    'Davidyz/VectorCode',
+    version = '*', -- optional, depending on whether you're on nightly or release
+    dependencies = { 'nvim-lua/plenary.nvim' },
+    build = 'pipx upgrade vectorcode',
+    cmd = 'VectorCode', -- if you're lazy-loading VectorCode
+    opts = {
+        async_backend = 'lsp',
+    },
+}

lua/plugins/wakatime.lua

@@ -0,0 +1,8 @@
+if vim.loop.os_uname().sysname == 'Darwin' then
+    return {
+        'wakatime/vim-wakatime',
+        lazy = false,
+    }
+else
+    return {}
+end

lua/plugins/yanky.lua

@@ -0,0 +1,9 @@
+-- For when I'm ready
+return {
+    -- "gbprod/yanky.nvim",
+    -- opts = {
+    --     -- your configuration comes here
+    --     -- or leave it empty to use the default settings
+    --     -- refer to the configuration section below
+    -- },
+}

lua/snippets/all.json

@@ -0,0 +1 @@
+{}

lua/snippets/javascript-vue.json

@@ -0,0 +1,9 @@
+{
+    "Log function": {
+        "prefix": "du",
+        "body": [
+            "console.log($0);"
+        ],
+        "description": "Log variable"
+    }
+}

lua/snippets/package.json

@@ -0,0 +1,26 @@
+{
+    "name": "example-snippets",
+    "contributes": {
+        "snippets": [
+            {
+                "language": [
+                    "all"
+                ],
+                "path": "./snippets/all.json"
+            },
+            {
+                "language": [
+                    "php"
+                ],
+                "path": "./php.json"
+            },
+            {
+                "language": [
+                    "javascript",
+                    "vue"
+                ],
+                "path": "./javascript-vue.json"
+            }
+        ]
+    }
+}

lua/snippets/php.json

@@ -0,0 +1,78 @@
+{
+    "Dump function": {
+        "prefix": "du",
+        "body": [
+            "dump($0);"
+        ],
+        "description": "Dump variable"
+    },
+    "Type dump function": {
+        "prefix": "dt",
+        "body": [
+            "\\PhpStan\\dumpType($0);"
+        ],
+        "description": "Dump PHPStan type"
+    },
+    "Test case": {
+        "prefix": "test",
+        "body": [
+            "test($1, function () {",
+            "    $0",
+            "});"
+        ],
+        "description": "Test case"
+    },
+    "Create doc block": {
+        "prefix": "/**",
+        "body": [
+            "/**",
+            " * $0",
+            " */"
+        ]
+    },
+    "DocBlock property": {
+        "prefix": "@p",
+        "body": "@property $1 $$0",
+        "description": "DocBlock property"
+    },
+    "DocBlock boolean property": {
+        "prefix": "@pb",
+        "body": "@property bool $$0",
+        "description": "DocBlock boolean property"
+    },
+    "DocBlock string property": {
+        "prefix": "@ps",
+        "body": "@property string $$0",
+        "description": "DocBlock string property"
+    },
+    "DocBlock int property": {
+        "prefix": "@pi",
+        "body": "@property int $$0",
+        "description": "DocBlock int property"
+    },
+    "DocBlock Collection property": {
+        "prefix": "@pc",
+        "body": "@property \\Illuminate\\Support\\Collection<int, $1> $$0",
+        "description": "DocBlock int property"
+    },
+    "DocBlock date property": {
+        "prefix": "@pd",
+        "body": "@property \\Illuminate\\Support\\Carbon $$0",
+        "description": "DocBlock date property"
+    },
+    "DocBlock model properties": {
+        "prefix": "@pp",
+        "body": [
+            "/**",
+            " * @property int $$id",
+            " * $1",
+            " * @property \\Illuminate\\Support\\Carbon $$created_at",
+            " * @property \\Illuminate\\Support\\Carbon $$updated_at",
+            " *",
+            " * Relationships",
+            " * $2",
+            " */"
+        ],
+        "description": "DocBlock model properties"
+    }
+}

lua/utils/fidget_helper.lua

@@ -0,0 +1,53 @@
+local progress = require 'fidget.progress'
+local M = {}
+
+M.handles = {}
+
+function M:store_progress_handle(id, handle)
+    M.handles[id] = handle
+end
+
+function M:pop_progress_handle(id)
+    local handle = M.handles[id]
+    M.handles[id] = nil
+    return handle
+end
+
+function M:create_progress_handle(request)
+    -- Ensure request.data and request.data.adapter exist before accessing them
+    local strategy = request.data and request.data.strategy or 'unknown'
+    local adapter_info = request.data and request.data.adapter or {}
+
+    return progress.handle.create {
+        title = ' Requesting assistance (' .. strategy .. ')',
+        message = 'In progress...',
+        lsp_client = {
+            name = M:llm_role_title(adapter_info),
+        },
+    }
+end
+
+function M:llm_role_title(adapter)
+    local parts = {}
+    -- Use adapter.formatted_name if available, otherwise default
+    local name = adapter.formatted_name or 'LLM'
+    table.insert(parts, name)
+    if adapter.model and adapter.model ~= '' then
+        table.insert(parts, '(' .. adapter.model .. ')')
+    end
+    return table.concat(parts, ' ')
+end
+
+function M:report_exit_status(handle, request)
+    -- Ensure request.data exists before accessing status
+    local status = request.data and request.data.status or 'unknown'
+    if status == 'success' then
+        handle.message = 'Completed'
+    elseif status == 'error' then
+        handle.message = ' Error'
+    else -- Includes "cancelled" or any other status
+        handle.message = '󰜺 Cancelled/Other'
+    end
+end
+
+return M