avante and cc for render markdown

This reverts commit bf17d5d108fb8078f7d1340cb089d4c87af6f45e.

.clang-tidy

@@ -0,0 +1,115 @@
+Checks: 'readability-*,
+ bsl-*,
+ cppcoreguidelines-*,
+ cppcoreguidelines-prefer-member-initializer,
+ clang-analyzer-core.*,
+ clang-analyzer-core.StackAddressEscape,
+ bugprone-assert-side-effect,
+ bugprone-assignment-in-if-condition,
+ bugprone-branch-clone,
+ bugprone-copy-constructor-init,
+ bugprone-exception-escape,
+ bugprone-forward-declaration-namespace,
+ bugprone-incorrect-roundings,
+ bugprone-infinite-loop,
+ bugprone-integer-division,
+ bugprone-macro-parentheses,
+ bugprone-multiple-statement-macro,
+ bugprone-parent-virtual-call,
+ bugprone-redundant-branch-condition,
+ bugprone-reserved-identifier,
+ bugprone-sizeof-container,
+ bugprone-sizeof-expression,
+ bugprone-string-constructor,
+ bugprone-string-integer-assignment,
+ bugprone-suspicious-enum-usage,
+ bugprone-suspicious-include,
+ bugprone-suspicious-missing-comma,
+ bugprone-suspicious-semicolon,
+ bugprone-swapped-arguments,
+ bugprone-terminating-continue,
+ bugprone-too-small-loop-variable,
+ bugprone-use-after-move,
+ misc-redundant-expression,
+ misc-unused-parameters,
+ misc-const-correctness,
+ misc-confusable-identifiers,
+ misc-definitions-in-headers,
+ misc-header-include-cycle,
+ misc-include-cleaner,
+ misc-misplaced-const,
+ misc-static-assert,
+ modernize-use-default-member-init,
+ modernize-loop-convert,
+ modernize-min-max-use-initializer-list,
+ modernize-pass-by-value,
+ modernize-return-braced-init-list,
+ modernize-use-default-member-init,
+ modernize-use-designated-initializers,
+ modernize-use-equals-default,
+ modernize-use-equals-delete,
+ modernize-use-nullptr,
+ modernize-use-override,
+ modernize-use-starts-ends-with,
+ modernize-use-using,
+ readability-identifier-naming,
+ readability-duplicate-include,
+ readability-braces-around-statements,
+ readability-implicit-bool-conversion,
+ readability-inconsistent-declaration-parameter-name,
+ readability-make-member-function-const,
+ readability-misleading-indentation,
+ readability-redundant-declaration,
+ readability-redundant-preprocessor,
+ readability-redundant-member-init,
+ readability-simplify-boolean-expr,
+ readability-static-accessed-through-instance,
+ readability-uppercase-literal-suffix,
+ readability-identifier-naming,
+ readability-duplicate-include,
+ readability-braces-around-statements,
+ readability-implicit-bool-conversion,
+ readability-inconsistent-declaration-parameter-name,
+ readability-make-member-function-const,
+ readability-const-return-type,
+ readability-non-const-parameter,
+ hicpp-signed-bitwise,
+ -readability-avoid-const-params-in-decls,
+ -readability-function-cognitive-complexity,
+ -readability-magic-numbers,
+ -readability-identifier-length,
+ -cppcoreguidelines-explicit-virtual-functions,
+ -cppcoreguidelines-init-variables,
+ -cppcoreguidelines-non-private-member-variables-in-classes,
+ -cppcoreguidelines-avoid-magic-numbers,
+ -cppcoreguidelines-owning-memory,
+ -cppcoreguidelines-pro-bounds-constant-array-index,
+ -cppcoreguidelines-special-member-functions,
+ -cppcoreguidelines-avoid-c-arrays,
+ -cppcoreguidelines-pro-type-reinterpret-cast,
+ -cppcoreguidelines-avoid-non-const-global-variables,
+ -cppcoreguidelines-pro-bounds-pointer-arithmetic'
+CheckOptions:
+  - key: readability-identifier-naming.NamespaceCase
+    value: lower_case
+  - key: readability-identifier-naming.ClassCase
+    value: CamelCase
+  - key: readability-identifier-naming.PrivateMemberPrefix
+    value: m_
+  - key: readability-identifier-naming.StructCase
+    value: CamelCase
+  - key: readability-identifier-naming.FunctionCase
+    value: camelBack
+  - key: readability-identifier-naming.VariableCase
+    value: camelBack
+  - key: readability-identifier-naming.GlobalConstantCase
+    value: UPPER_CASE
+  - key: readability-identifier-naming.EnumConstant
+    value: UPPER_CASE
+  - key: bugprone-argument-comment.StrictMode
+    value: 1
+  - key: bugprone-exception-escape.FunctionsThatShouldNotThrow
+    value: WinMain,SDL_main
+  - key: misc-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic
+    value: 1
+

.gitignore

@@ -8,3 +8,4 @@ plugin/packer_compiled.lua
 venv_debugpy
 .luarc.json
 .luarc.json
+Session.vim

.pre-commit-config.yaml

@@ -0,0 +1,5 @@
+repos:
+  - repo: https://github.com/JohnnyMorganz/stylua
+    rev: v2.0.2
+    hooks:
+      - id: stylua-system

after/lsp/basedpyright.lua

@@ -0,0 +1,7 @@
+return {
+  settings = {
+    basedpyright = {
+      typeCheckingMode = 'standard',
+    },
+  },
+}

after/lsp/clangd.lua

@@ -0,0 +1,21 @@
+return {
+  cmd = {
+    'clangd',
+    '--compile-commands-dir=build_nvim',
+    '--query-driver',
+    '/opt/cortex-a78-2022.08-gcc12.1-linux5.15/bin/aarch64-linux-gnu-g*',
+    '--clang-tidy',
+    '--background-index',
+    '--use-dirty-headers',
+    '--completion-style=detailed',
+  },
+  root_markers = {
+    '.clangd',
+    '.clang-tidy',
+    '.clang-format',
+    'compile_flags.txt',
+    'configure.ac',
+    '.git',
+    'build_nvim',
+  },
+}

after/lsp/lua_ls.lua

@@ -0,0 +1,22 @@
+return {
+  settings = {
+    Lua = {
+      workspace = {
+        checkThirdParty = false,
+      },
+      completion = {
+        callSnippet = 'Replace',
+      },
+      -- Do not send telemetry data containing a randomized but unique identifier
+      telemetry = {
+        enable = false,
+      },
+      diagnostics = {
+        disable = { 'missing-fields' },
+      },
+      format = {
+        enable = false,
+      },
+    },
+  },
+}

after/lsp/yamlls.lua

@@ -0,0 +1,7 @@
+return {
+  settings = {
+    yaml = {
+      validate = true,
+    },
+  },
+}

after/syntax/norg.lua

@@ -0,0 +1 @@
+vim.opt_local.conceallevel = 3

ftplugin/markdown.lua

@@ -0,0 +1,4 @@
+local opts = { noremap = true, silent = false }
+vim.keymap.set('n', '<CR>', vim.lsp.buf.definition, opts)
+
+vim.opt_local.conceallevel = 0

init.lua

@@ -1,4 +1,5 @@
 vim.g.mapleader = ','
+vim.g.maplocalleader = ','
 if not vim.g.vscode then
   require('config.lazy')
   require('my_keymappings')

lazy-lock.json

@@ -1,73 +1,82 @@
 {
-  "Comment.nvim": { "branch": "master", "commit": "e1fe53117aab24c378d5e6deaad786789c360123" },
+  "Comment.nvim": { "branch": "master", "commit": "e51f2b142d88bb666dcaa77d93a07f4b419aca70" },
   "FixCursorHold.nvim": { "branch": "master", "commit": "1900f89dc17c603eec29960f57c00bd9ae696495" },
-  "LuaSnip": { "branch": "master", "commit": "b4bc24c4925aeb05fd47d2ee9b24b7f73f5d7e32" },
-  "advanced-git-search.nvim": { "branch": "main", "commit": "5637d80861e253a8621450eb58621009e1307deb" },
-  "aerial.nvim": { "branch": "master", "commit": "d8f2699f7ae0e5eb62424d7b2ad80ce30179ee92" },
-  "clangd_extensions.nvim": { "branch": "main", "commit": "798e377ec859087132b81d2f347b5080580bd6b1" },
-  "cmake-tools.nvim": { "branch": "master", "commit": "b279bfb861666563399de3599c24040b53a42fd2" },
-  "cmp-buffer": { "branch": "main", "commit": "3022dbc9166796b644a841a02de8dd1cc1d311fa" },
-  "cmp-calc": { "branch": "main", "commit": "50792f34a628ea6eb31d2c90e8df174671e4e7a0" },
-  "cmp-cmdline": { "branch": "main", "commit": "5af1bb7d722ef8a96658f01d6eb219c4cf746b32" },
+  "LuaSnip": { "branch": "master", "commit": "458560534a73f7f8d7a11a146c801db00b081df0" },
+  "astrotheme": { "branch": "main", "commit": "f12dcf64b1f9a05839c3ac2146f550f43bae9dab" },
+  "avante.nvim": { "branch": "main", "commit": "adae032f5fbc611d59545792d3c5bb1c9ddc3fdb" },
+  "bamboo.nvim": { "branch": "master", "commit": "97124a0b81f886abc0d666ebec512b92425d67b6" },
+  "blink.cmp": { "branch": "main", "commit": "49f211fe5d729df53df4c042d7c3464cf47d199e" },
+  "cmake-tools.nvim": { "branch": "master", "commit": "1ee065c33ca777c0e03cd7c358010202ee70bb88" },
+  "cmp-buffer": { "branch": "main", "commit": "b74fab3656eea9de20a9b8116afa3cfc4ec09657" },
+  "cmp-cmdline": { "branch": "main", "commit": "d250c63aa13ead745e3a40f61fdd3470efde3923" },
   "cmp-cmdline-history": { "branch": "master", "commit": "003573b72d4635ce636234a826fa8c4ba2895ffe" },
-  "cmp-dap": { "branch": "master", "commit": "d16f14a210cd28988b97ca8339d504533b7e09a4" },
-  "cmp-emoji": { "branch": "main", "commit": "19075c36d5820253d32e2478b6aaf3734aeaafa0" },
-  "cmp-look": { "branch": "master", "commit": "b39c50bcdf6199dddda56adc466c2bd9c951a960" },
-  "cmp-nvim-lsp": { "branch": "main", "commit": "0e6b2ed705ddcff9738ec4ea838141654f12eeef" },
-  "cmp-nvim-lsp-signature-help": { "branch": "main", "commit": "3d8912ebeb56e5ae08ef0906e3a54de1c66b92f1" },
-  "cmp-nvim-lua": { "branch": "main", "commit": "f12408bdb54c39c23e67cab726264c10db33ada8" },
-  "cmp-path": { "branch": "main", "commit": "91ff86cd9c29299a64f968ebb45846c485725f23" },
-  "cmp-spell": { "branch": "master", "commit": "60584cb75e5e8bba5a0c9e4c3ab0791e0698bffa" },
-  "cmp-treesitter": { "branch": "master", "commit": "389eadd48c27aa6dc0e6b992644704f026802a2e" },
-  "cmp_luasnip": { "branch": "master", "commit": "18095520391186d634a0045dacaa346291096566" },
-  "diffview.nvim": { "branch": "main", "commit": "1d6ea6ced1c3ec0f6464761a138bb35afd79ef63" },
-  "dressing.nvim": { "branch": "master", "commit": "66e4990240f92e31b0d5e4df6deb6bb0160ae832" },
-  "friendly-snippets": { "branch": "main", "commit": "1d0dac346de7c6895ac72528df3276386c6b149b" },
-  "gitsigns.nvim": { "branch": "main", "commit": "814158f6c4b1724c039fcefe79b0be72c9131c2d" },
-  "gruvbox.nvim": { "branch": "main", "commit": "df149bccb19a02c5c2b9fa6ec0716f0c0487feb0" },
-  "indent-blankline.nvim": { "branch": "master", "commit": "018bd04d80c9a73d399c1061fa0c3b14a7614399" },
-  "lazy.nvim": { "branch": "main", "commit": "aba872ec78ffe7f7367764ab0fff6f0170421fde" },
-  "lazygit.nvim": { "branch": "main", "commit": "32bffdebe273e571588f25c8a708ca7297928617" },
-  "leap.nvim": { "branch": "main", "commit": "6f2912755c9c4ae790abd829f0cf1b07c037b2a4" },
-  "lsp_lines.nvim": { "branch": "main", "commit": "f53af96d4789eef39a082dbcce078d2bfc384ece" },
-  "lsp_signature.nvim": { "branch": "master", "commit": "7a26ebaa7e36aa2aefa6c1994b2b866c96de32e6" },
-  "lspkind-nvim": { "branch": "master", "commit": "57610d5ab560c073c465d6faf0c19f200cb67e6e" },
-  "lualine.nvim": { "branch": "master", "commit": "05d78e9fd0cdfb4545974a5aa14b1be95a86e9c9" },
-  "mason-lspconfig.nvim": { "branch": "main", "commit": "90a8bbf106b85b76951a34c542058ffa807de2b1" },
-  "mason.nvim": { "branch": "main", "commit": "e634134312bb936f472468a401c9cae6485ab54b" },
-  "neo-tree.nvim": { "branch": "v2.x", "commit": "e5594d53986b34e584e8afe2ea6ad99d6f6d2105" },
-  "neodev.nvim": { "branch": "main", "commit": "5e7e613950df5e2be27534ab5c55fd21af1b2ad3" },
-  "neogen": { "branch": "main", "commit": "c0fd3dc9e7cc91181ea5a345c4b01c865626c81e" },
-  "neotest": { "branch": "master", "commit": "42cf226457c61abe6fca081e959d69e2325cf08f" },
-  "neotest-python": { "branch": "master", "commit": "6c06041cfb45f45e276068020baa06c06fe20d5c" },
-  "nui.nvim": { "branch": "main", "commit": "698e75814cd7c56b0dd8af4936bcef2d13807f3c" },
-  "null-ls.nvim": { "branch": "main", "commit": "08bb00c7c2cd58c72e02cf54e4b9cbfe14b03e09" },
-  "nvim-autopairs": { "branch": "master", "commit": "7747bbae60074acf0b9e3a4c13950be7a2dff444" },
-  "nvim-cmp": { "branch": "main", "commit": "d153771162bd9795d9f7142df5c674b61066a585" },
-  "nvim-colorizer.lua": { "branch": "master", "commit": "dde3084106a70b9a79d48f426f6d6fec6fd203f7" },
-  "nvim-dap": { "branch": "master", "commit": "6cedcb527e264c8f25e86afa8dae74c6692dee51" },
-  "nvim-dap-python": { "branch": "master", "commit": "51ecb08dbff57fca8add396b93dc765aba262e0a" },
-  "nvim-dap-ui": { "branch": "master", "commit": "4ce7b97dd8f50b4f672948a34bf8f3a56214fdb8" },
-  "nvim-dap-virtual-text": { "branch": "master", "commit": "ab988dbb7d20cdaebf9b3ef7554a89f6895de042" },
-  "nvim-lspconfig": { "branch": "master", "commit": "df58d91c9351a9dc5be6cf8d54f49ab0d9a64e73" },
-  "nvim-neoclip.lua": { "branch": "main", "commit": "8094648c54ff3b233ccfe5928f77b6824f77339c" },
-  "nvim-rooter.lua": { "branch": "main", "commit": "99832f243426a28c1cc0b83ee4cdf915bf0b2c2b" },
-  "nvim-surround": { "branch": "main", "commit": "e6047128e57c1aff1566fb9f627521d2887fc77a" },
-  "nvim-treesitter": { "branch": "master", "commit": "f2778bd1a28b74adf5b1aa51aa57da85adfa3d16" },
-  "nvim-ts-rainbow": { "branch": "master", "commit": "ef95c15a935f97c65a80e48e12fe72d49aacf9b9" },
-  "nvim-web-devicons": { "branch": "master", "commit": "e283ab937e0197b37ec5d8013e49495193407324" },
-  "octo.nvim": { "branch": "master", "commit": "1c9a79412a1d92dd3c5a601e2261c158ebb4d4bd" },
-  "oil.nvim": { "branch": "master", "commit": "d27bfa1f370e8caddf65890364989b76f9794afb" },
-  "overseer.nvim": { "branch": "master", "commit": "9e7cc435c1c85d37aa5471d7429501690f4d64d6" },
-  "plenary.nvim": { "branch": "master", "commit": "9ac3e9541bbabd9d73663d757e4fe48a675bb054" },
-  "sqlite.lua": { "branch": "master", "commit": "b7e28c8463254c46a8e61c52d27d6a2040492fc3" },
-  "telescope-dap.nvim": { "branch": "master", "commit": "313d2ea12ae59a1ca51b62bf01fc941a983d9c9c" },
-  "telescope-fzf-native.nvim": { "branch": "main", "commit": "580b6c48651cabb63455e97d7e131ed557b8c7e2" },
-  "telescope-menufacture": { "branch": "main", "commit": "284eae0c6430a67ad5d24676e791749d31bd6bdf" },
-  "telescope-ui-select.nvim": { "branch": "master", "commit": "62ea5e58c7bbe191297b983a9e7e89420f581369" },
-  "telescope.nvim": { "branch": "master", "commit": "ebf93395e79e5d026e3867d9e5e158b2bbe1499c" },
-  "toggleterm.nvim": { "branch": "main", "commit": "68fdf851c2b7901a7065ff129b77d3483419ddce" },
-  "vim-fugitive": { "branch": "master", "commit": "5f0d280b517cacb16f59316659966c7ca5e2bea2" },
-  "vim-repeat": { "branch": "master", "commit": "24afe922e6a05891756ecf331f39a1f6743d3d5a" },
-  "which-key.nvim": { "branch": "main", "commit": "5a6c954a5a46023c19acc03a8b6d7c3e57964fc5" }
-}
+  "cmp-nvim-lsp": { "branch": "main", "commit": "a8912b88ce488f411177fc8aed358b04dc246d7b" },
+  "cmp-nvim-lsp-signature-help": { "branch": "main", "commit": "031e6ba70b0ad5eee49fd2120ff7a2e325b17fa7" },
+  "cmp-path": { "branch": "main", "commit": "c6635aae33a50d6010bf1aa756ac2398a2d54c32" },
+  "cmp_luasnip": { "branch": "master", "commit": "98d9cb5c2c38532bd9bdb481067b20fea8f32e90" },
+  "codecompanion.nvim": { "branch": "main", "commit": "d19670a44c35e9ba0674cc7a25ff3b8f22bbf062" },
+  "codeium.nvim": { "branch": "main", "commit": "821b570b526dbb05b57aa4ded578b709a704a38a" },
+  "conform.nvim": { "branch": "master", "commit": "374aaf384e2e841607b8e2fe63fa3ad01d111c91" },
+  "copilot-cmp": { "branch": "master", "commit": "15fc12af3d0109fa76b60b5cffa1373697e261d1" },
+  "copilot.lua": { "branch": "master", "commit": "2fe34db04570f6c47db0b752ca421a49b7357c03" },
+  "dial.nvim": { "branch": "master", "commit": "2c7e2750372918f072a20f3cf754d845e143d7c9" },
+  "diffview.nvim": { "branch": "main", "commit": "4516612fe98ff56ae0415a259ff6361a89419b0a" },
+  "dressing.nvim": { "branch": "master", "commit": "2d7c2db2507fa3c4956142ee607431ddb2828639" },
+  "everforest-nvim": { "branch": "main", "commit": "2eb7c348f880ba93de4d98cae049c9441f5d4d49" },
+  "flash.nvim": { "branch": "main", "commit": "3c942666f115e2811e959eabbdd361a025db8b63" },
+  "friendly-snippets": { "branch": "main", "commit": "572f5660cf05f8cd8834e096d7b4c921ba18e175" },
+  "fzf-lua": { "branch": "main", "commit": "b45881a2043d96506ba628f3bc65a4594b179c4e" },
+  "gitsigns.nvim": { "branch": "main", "commit": "43b0c856ae5f32a195d83f4a27fe21d63e6c966c" },
+  "grug-far.nvim": { "branch": "main", "commit": "78c8d27c6f3300bfa92bb535236732d8e9bcb614" },
+  "gruvbox-baby": { "branch": "main", "commit": "bd52e62d8134647090108189e69c8b3cd18bdbbf" },
+  "gruvbox-flat.nvim": { "branch": "master", "commit": "1dc35c81da30d297f82d438ff362cf1b01d36782" },
+  "gruvbox.nvim": { "branch": "main", "commit": "cc202a7c5e5ffca06f92a04073275dec371cbfe3" },
+  "img-clip.nvim": { "branch": "main", "commit": "08a02e14c8c0d42fa7a92c30a98fd04d6993b35d" },
+  "iron.nvim": { "branch": "master", "commit": "c005b01b779f1b6c038e11248db403bb3df6a7f3" },
+  "kanagawa.nvim": { "branch": "master", "commit": "4de88d695634a8776c687af8e7436cfa074aa0c0" },
+  "lazy.nvim": { "branch": "main", "commit": "6c3bda4aca61a13a9c63f1c1d1b16b9d3be90d7a" },
+  "lazydev.nvim": { "branch": "main", "commit": "2367a6c0a01eb9edb0464731cc0fb61ed9ab9d2c" },
+  "lspkind.nvim": { "branch": "master", "commit": "d79a1c3299ad0ef94e255d045bed9fa26025dab6" },
+  "lualine-diagnostic-message": { "branch": "master", "commit": "e8244c4d1f088e21bb05021f164ed903093b168b" },
+  "lualine.nvim": { "branch": "master", "commit": "15884cee63a8c205334ab13ab1c891cd4d27101a" },
+  "luvit-meta": { "branch": "main", "commit": "1df30b60b1b4aecfebc785aa98943db6c6989716" },
+  "markdown-preview.nvim": { "branch": "master", "commit": "a923f5fc5ba36a3b17e289dc35dc17f66d0548ee" },
+  "mason-lspconfig.nvim": { "branch": "main", "commit": "d39a75bbce4b8aad5d627191ea915179c77c100f" },
+  "mason-tool-installer.nvim": { "branch": "main", "commit": "62f821a14e20f3f2ee358cd44d0b3d299a508e72" },
+  "mason.nvim": { "branch": "main", "commit": "7c7318e8bae7e3536ef6b9e86b9e38e74f2e125e" },
+  "material.nvim": { "branch": "main", "commit": "c8ff153d2c2b22f8b2c9bcce0d741ab55c00cfed" },
+  "mini.ai": { "branch": "main", "commit": "e139eb1101beb0250fea322f8c07a42f0f175688" },
+  "mini.sessions": { "branch": "main", "commit": "71c9ae596664ac110560d27eb928fc24e22bc53d" },
+  "mini.surround": { "branch": "main", "commit": "aa5e245829dd12d8ff0c96ef11da28681d6049aa" },
+  "monokai-pro.nvim": { "branch": "master", "commit": "31bad737610ec211de086d373c73025f39de93cb" },
+  "neogen": { "branch": "main", "commit": "d7f9461727751fb07f82011051338a9aba07581d" },
+  "neogit": { "branch": "master", "commit": "a58ab1befb5608b8ff36a2286360df8263791c1c" },
+  "neotest": { "branch": "master", "commit": "2d9011396c43fa1d40221e6b6c3be5eb001427a9" },
+  "neotest-python": { "branch": "master", "commit": "a2861ab3c9a0bf75a56b11835c2bfc8270f5be7e" },
+  "nui.nvim": { "branch": "main", "commit": "f535005e6ad1016383f24e39559833759453564e" },
+  "nvim-cmp": { "branch": "main", "commit": "b5311ab3ed9c846b585c0c15b7559be131ec4be9" },
+  "nvim-dap": { "branch": "master", "commit": "8df427aeba0a06c6577dc3ab82de3076964e3b8d" },
+  "nvim-dap-python": { "branch": "master", "commit": "34282820bb713b9a5fdb120ae8dd85c2b3f49b51" },
+  "nvim-dap-repl-highlights": { "branch": "master", "commit": "a7512fc0a0de0c0be8d58983939856dda6f72451" },
+  "nvim-dap-ui": { "branch": "master", "commit": "73a26abf4941aa27da59820fd6b028ebcdbcf932" },
+  "nvim-highlight-colors": { "branch": "main", "commit": "b42a5ccec7457b44e89f7ed3b3afb1b375bb2093" },
+  "nvim-lint": { "branch": "master", "commit": "9dfb77ef6c5092a19502883c02dc5a02ec648729" },
+  "nvim-lspconfig": { "branch": "master", "commit": "61e5109c8cf24807e4ae29813a3a82b31821dd45" },
+  "nvim-navic": { "branch": "master", "commit": "f887d794a0f4594882814d7780980a949200a238" },
+  "nvim-nio": { "branch": "master", "commit": "21f5324bfac14e22ba26553caf69ec76ae8a7662" },
+  "nvim-rooter.lua": { "branch": "main", "commit": "7689d05e8ab95acb4b24785253d913c0aae18be9" },
+  "nvim-treesitter": { "branch": "master", "commit": "28d480e0624b259095e56f353ec911f9f2a0f404" },
+  "nvim-web-devicons": { "branch": "master", "commit": "f1420728f59843eb2ef084406b3d0201a0a0932d" },
+  "oil.nvim": { "branch": "master", "commit": "685cdb4ffa74473d75a1b97451f8654ceeab0f4a" },
+  "overseer.nvim": { "branch": "master", "commit": "72c68aab0358c92f451168b704c411c4a3e3410e" },
+  "plenary.nvim": { "branch": "master", "commit": "857c5ac632080dba10aae49dba902ce3abf91b35" },
+  "rainbow-delimiters.nvim": { "branch": "master", "commit": "55ad4fb76ab68460f700599b7449385f0c4e858e" },
+  "render-markdown.nvim": { "branch": "main", "commit": "935c2c70c296d87ed1bcce9ce667c239c9c982b5" },
+  "rustaceanvim": { "branch": "master", "commit": "cb532f57c1ed2463c66df683468eb3994e554002" },
+  "snacks.nvim": { "branch": "main", "commit": "bc0630e43be5699bb94dadc302c0d21615421d93" },
+  "todo-comments.nvim": { "branch": "main", "commit": "304a8d204ee787d2544d8bc23cd38d2f929e7cc5" },
+  "toggleterm.nvim": { "branch": "main", "commit": "9a88eae817ef395952e08650b3283726786fb5fb" },
+  "trouble.nvim": { "branch": "main", "commit": "85bedb7eb7fa331a2ccbecb9202d8abba64d37b3" },
+  "which-key.nvim": { "branch": "main", "commit": "fcbf4eea17cb299c02557d576f0d568878e354a4" },
+  "yanky.nvim": { "branch": "main", "commit": "04775cc6e10ef038c397c407bc17f00a2f52b378" }
+}

lua/config/lazy.lua

@@ -1,14 +1,27 @@
-local lazypath = vim.fn.stdpath('data') .. '/lazy/lazy.nvim'
-if not vim.loop.fs_stat(lazypath) then
-  vim.fn.system({
-    'git',
-    'clone',
-    '--filter=blob:none',
-    '--single-branch',
-    'https://github.com/folke/lazy.nvim.git',
-    lazypath,
-  })
-end
-vim.opt.runtimepath:prepend(lazypath)
-
-require('lazy').setup('plugins', {})
+local lazypath = vim.fn.stdpath('data') .. '/lazy/lazy.nvim'
+if not vim.loop.fs_stat(lazypath) then
+  vim.fn.system({
+    'git',
+    'clone',
+    '--filter=blob:none',
+    'https://github.com/folke/lazy.nvim.git',
+    '--branch=stable', -- latest stable release
+    lazypath,
+  })
+end
+vim.opt.rtp:prepend(lazypath)
+
+require('lazy').setup({
+  defaults = {
+    version = false,
+  },
+  spec = {
+    { import = 'plugins' },
+    { import = 'themes' },
+  },
+  change_detection = {
+    -- automatically check for config file changes and reload the ui
+    enabled = true,
+    notify = false, -- get a notification when changes are found
+  },
+})

lua/config/options.lua

@@ -6,6 +6,11 @@ local indent = 2
 opt.termguicolors = true -- Enable colors in terminal
 opt.hlsearch = true --Set highlight on search
 opt.number = true --Make line numbers default
+opt.listchars:append('eol:↴')
+-- opt.listchars:append("space: ")
+-- opt.listchars:append 'space:⋅'
+opt.listchars:append('trail: ')
+opt.listchars:append('tab:→ ')
 opt.relativenumber = false --Make relative number default
 opt.mouse = 'a' --Enable mouse mode
 opt.breakindent = true --Enable break indent
@@ -23,12 +28,14 @@ opt.showmatch = true -- Show matching braces
 opt.wrap = true -- When on, lines longer than the width of the window will wrap and displaying continues on the next line
 opt.list = true
 opt.hidden = true
+opt.winborder = 'none'
 opt.scrolloff = 4
 opt.shiftround = true
 opt.relativenumber = false
 opt.splitbelow = true
 opt.splitright = true
 opt.wildmode = 'longest:full,full'
+opt.pumheight = 15
 opt.splitbelow = true
 opt.splitright = true
 opt.shiftwidth = indent
@@ -46,22 +53,53 @@ if vim.fn.has('wsl') == 1 then
     },
     cache_enabled = 0,
   }
-  opt.guifont = 'JetBrainsMonoNL NF:h9' -- https://github.com/ryanoasis/nerd-fonts/blob/master/patched-fonts/JetBrainsMono/NoLigatures/Regular/complete/JetBrains%20Mono%20NL%20Regular%20Nerd%20Font%20Complete%20Mono%20Windows%20Compatible.ttf
-
+  -- opt.guifont = 'Hack Nerd Font Mono:h10'
+  opt.guifont = 'RobotoMono Nerd Font:h10'
 elseif vim.loop.os_uname().sysname == 'Linux' then
-  opt.guifont = 'JetBrainsMono Nerd Font Mono:h7'
+  opt.guifont = 'Iosevka NFM:h11'
+  if vim.env.SSH_TTY or vim.env.SSH_CLIENT or vim.env.SSH_CONNECTION then
+    function no_paste(reg)
+      return function(lines)
+        -- Do nothing! We can't paste with OSC52
+      end
+    end
+
+    vim.g.clipboard = {
+      name = 'OSC 52',
+      copy = {
+        ['+'] = require('vim.ui.clipboard.osc52').copy('+'),
+        ['*'] = require('vim.ui.clipboard.osc52').copy('*'),
+      },
+      paste = {
+        -- ['+'] = require('vim.ui.clipboard.osc52').paste('+'),
+        -- ['*'] = require('vim.ui.clipboard.osc52').paste('*'),
+        ['+'] = no_paste('+'), -- Pasting disabled
+        ['*'] = no_paste('*'), -- Pasting disabled
+      },
+    }
+  end
 else
-  opt.guifont = 'Hack Nerd Font Mono:h10'
+  -- opt.guifont = 'Hack Nerd Font:h10'
+  -- opt.guifont = 'JetBrainsMono Nerd Font:h10'
+  -- opt.guifont = 'FiraCode Nerd Font:h10'
+  -- opt.guifont = 'RobotoMono Nerd Font:h10'
+  opt.guifont = 'IosevkaTerm Nerd Font Mono:h11'
+  -- opt.guifont = 'Cousine Nerd Font Mono:h10'
+  -- opt.guifont = 'DroidSansM Nerd Font Propo:h10'
+  -- opt.guifont = 'AnonymicePro Nerd Font:h11'
+  -- opt.guifont = 'SauceCodePro Nerd Font:h10'
+  -- opt.guifont = 'Monoid Nerd Font Propo:h10'
 end
 opt.swapfile = false
 opt.backup = false
-opt.spelllang = 'en,de'
+opt.spelllang = 'en'
 opt.completeopt = 'menu,menuone,noselect'
 opt.expandtab = true
 opt.smartindent = true
 opt.title = true
-opt.titlestring='%(%{fnamemodify(getcwd(),\":t\")}%) Neovim'
+opt.titlestring = '%(%{fnamemodify(getcwd(),":t")}%) Neovim'
 opt.laststatus = 3 -- for lualine
+opt.background = 'dark'
 
 -- go to previous/next line with h,l,left arrow and right arrow
 -- when cursor reaches end/beginning of line
@@ -76,5 +114,36 @@ opt.foldmethod = 'expr'
 opt.foldexpr = 'nvim_treesitter#foldexpr()'
 opt.foldexpr = 'nvim_treesitter#foldexpr()'
 
--- Window border for floating windows
-require('lspconfig.ui.windows').default_options.border = 'rounded'
+vim.diagnostic.config({
+  signs = {
+    text = {
+      [vim.diagnostic.severity.ERROR] = '', -- Nerd Font Error Icon
+      [vim.diagnostic.severity.WARN] = '', -- Nerd Font Warning Icon
+      [vim.diagnostic.severity.INFO] = '', -- Nerd Font Info Icon
+      [vim.diagnostic.severity.HINT] = '', -- Nerd Font Hint Icon (example)
+    },
+    -- Define the highlight group to use for the sign text for each severity
+    texthl = {
+      [vim.diagnostic.severity.ERROR] = 'DiagnosticSignError',
+      [vim.diagnostic.severity.WARN] = 'DiagnosticSignWarn',
+      [vim.diagnostic.severity.INFO] = 'DiagnosticSignInfo',
+      [vim.diagnostic.severity.HINT] = 'DiagnosticSignHint',
+    },
+    -- Optional: Highlight the line number column
+    numhl = {
+      [vim.diagnostic.severity.ERROR] = 'DiagnosticLineNrError',
+      -- Add others for WARN, INFO, HINT if desired
+    },
+    -- Optional: Highlight the whole line
+    linehl = {
+      -- Define highlight groups like 'DiagnosticLineError', 'DiagnosticLineWarn', etc.
+      [vim.diagnostic.severity.ERROR] = 'DiagnosticLineError',
+    },
+  },
+  -- Other diagnostic configurations (optional examples)
+  virtual_text = false,
+  virtual_lines = false,
+  underline = true, -- Enable underlining diagnostics
+  update_in_insert = false, -- Don't update diagnostics in insert mode
+  severity_sort = true, -- Sort diagnostics by severity
+})

lua/my_autocommands.lua

@@ -7,49 +7,22 @@ api.nvim_create_autocmd('TextYankPost', {
   group = yankGrp,
 })
 
--- Filetypes
-local fileGrp = api.nvim_create_augroup('file_type', { clear = true })
-api.nvim_create_autocmd({ 'BufRead', 'BufNewFile' }, {
-  pattern = { '*.simvis', '*.manifest' },
-  callback = function()
-    vim.bo.filetype = 'xml'
-  end,
-  group = fileGrp,
-})
-api.nvim_create_autocmd({ 'BufRead', 'BufNewFile' }, {
-  pattern = { '*.simcfg', '*.simcon', '*.simudex' },
-  callback = function()
-    vim.bo.filetype = 'xml'
-  end,
-  group = fileGrp,
-})
-api.nvim_create_autocmd({ 'BufRead', 'BufNewFile' }, {
-  pattern = { 'JenkinsFile*' },
-  callback = function()
-    vim.bo.filetype = 'groovy'
-  end,
-  group = fileGrp,
-})
-api.nvim_create_autocmd({ 'BufRead', 'BufNewFile' }, {
-  pattern = { 'SConstruct', 'SConscript' },
-  callback = function()
-    vim.bo.filetype = 'python'
-  end,
-  group = fileGrp,
-})
-api.nvim_create_autocmd({ 'BufRead', 'BufNewFile' }, {
-  pattern = { 'doskey' },
-  callback = function()
-    vim.bo.filetype = 'dosini'
-  end,
-  group = fileGrp,
-})
-api.nvim_create_autocmd({ 'BufRead', 'BufNewFile' }, {
-  pattern = { '.clangd', '.clang-tidy' },
-  callback = function()
-    vim.bo.filetype = 'yaml'
-  end,
-  group = fileGrp,
+vim.filetype.add({
+  extension = {
+    simvis = 'xml',
+    manifest = 'xml',
+    simcfg = 'xml',
+    simcon = 'xml',
+    simudex = 'xml'
+  },
+  filename = {
+    ['JenkinsFile'] = 'groovy',
+    ['SConstruct'] = 'python',
+    ['SConscript'] = 'python',
+    ['doskey'] = 'dosini',
+    ['.clangd'] = 'yaml',
+    ['.clang-tidy'] = 'yaml',
+  },
 })
 
 -- Read and write shada file
@@ -61,15 +34,28 @@ api.nvim_create_autocmd({ 'FocusLost' }, { command = [[wshada]] })
 --   { command = [[if line("'\"") > 1 && line("'\"") <= line("$") | execute "normal! g`\"" | endif]] }
 -- )
 
+-- When editing a file, always jump to the last known cursor position.
+-- Don't do it when the position is invalid, when inside an event handler
+-- (happens when dropping a file on gvim) and for a commit message (it's
+-- likely a different one than last time).
+local userGrp = api.nvim_create_augroup('UserGroup', { clear = true })
+vim.api.nvim_create_autocmd('BufReadPost', {
+  group = userGrp,
+  callback = function(args)
+    local valid_line = vim.fn.line([['"]]) >= 1 and vim.fn.line([['"]]) < vim.fn.line('$')
+    local not_commit = vim.b[args.buf].filetype ~= 'commit'
+
+    if valid_line and not_commit then
+      vim.cmd([[normal! g`"]])
+    end
+  end,
+})
+
 -- Check if we need to reload the file when it changed
-api.nvim_create_autocmd({ 'FocusGained', 'BufEnter' },
-  { command = [[if !bufexists("[Command Line]") | checktime | endif]] })
+api.nvim_create_autocmd({ 'FocusGained', 'BufEnter' }, { command = [[if !bufexists("[Command Line]") | checktime | endif]] })
 
 -- windows to close with "q"
-api.nvim_create_autocmd(
-  'FileType',
-  { pattern = { 'help', 'startuptime', 'qf', 'lspinfo' }, command = [[nnoremap <buffer><silent> q :close<CR>]] }
-)
+api.nvim_create_autocmd('FileType', { pattern = { 'help', 'startuptime', 'qf', 'lspinfo' }, command = [[nnoremap <buffer><silent> q :close<CR>]] })
 api.nvim_create_autocmd('FileType', { pattern = 'man', command = [[nnoremap <buffer><silent> q :quit<CR>]] })
 
 -- don't auto comment new line

lua/my_keymappings.lua

@@ -3,11 +3,17 @@ local opts = { noremap = true, silent = true }
 -- Tabs
 vim.keymap.set('n', '<S-Right>', ':tabnext<CR>', opts)
 vim.keymap.set('n', '<S-Left>', ':tabprevious<CR>', opts)
+vim.keymap.set('n', '<S-l>', ':tabnext<CR>', opts)
+vim.keymap.set('n', '<S-h>', ':tabprevious<CR>', opts)
 -- Split movement
 vim.keymap.set('n', '<A-Up>', ':wincmd k<CR>', opts)
 vim.keymap.set('n', '<A-Down>', ':wincmd j<CR>', opts)
 vim.keymap.set('n', '<A-Left>', ':wincmd h<CR>', opts)
 vim.keymap.set('n', '<A-Right>', ':wincmd l<CR>', opts)
+vim.keymap.set('n', '<A-k>', ':wincmd k<CR>', opts)
+vim.keymap.set('n', '<A-j>', ':wincmd j<CR>', opts)
+vim.keymap.set('n', '<A-h>', ':wincmd h<CR>', opts)
+vim.keymap.set('n', '<A-l>', ':wincmd l<CR>', opts)
 
 vim.keymap.set('n', '<C-S>', ':wa | wshada<CR>')
 
@@ -20,6 +26,14 @@ vim.keymap.set({ 'n', 'x' }, '<Up>', 'gk', opts)
 vim.keymap.set({ 'n', 'x' }, '<Down>', 'gj', opts)
 vim.keymap.set({ 'n', 'x' }, '<Home>', 'g<Home>', opts)
 vim.keymap.set({ 'n', 'x' }, '<End>', 'g<End>', opts)
+vim.keymap.set({ 'i' }, '<C-k>', '<C-o>gk', opts)
+vim.keymap.set({ 'i' }, '<C-h>', '<Left>', opts)
+vim.keymap.set({ 'i' }, '<C-l>', '<Right>', opts)
+vim.keymap.set({ 'i' }, '<C-j>', '<C-o>gj', opts)
+-- vim.keymap.set({'n', 'x', 'i'}, '<Up>', '')
+-- vim.keymap.set({'n', 'x', 'i'}, '<Down>', '')
+-- vim.keymap.set({'n', 'x', 'i'}, '<Left>', '')
+-- vim.keymap.set({'n', 'x', 'i'}, '<Right>', '')
 
 vim.keymap.set('x', '<', '<gv')
 vim.keymap.set('x', '>', '>gv')
@@ -35,16 +49,24 @@ vim.keymap.set('n', "'", hlWord, { noremap = true, silent = true, desc = 'Higlig
 vim.keymap.set('x', "'", 'y/\\V<C-R>"<CR>N', { noremap = true, silent = true, desc = 'Highlight visual' })
 
 -- Close Buffer
-vim.keymap.set('n', '<C-w>', ':bd<CR>', { desc = 'Close buffer' })
+-- vim.keymap.set('n', '<C-w>', ':bd<CR>', { desc = 'Close buffer' })
 
 vim.keymap.set('n', '<space>x', 'za', { desc = 'Toggle fold' })
 
-
 vim.keymap.set({ 'n', 'x' }, '<leader>y', '"+y', { desc = 'Copy from system clipboard' })
 vim.keymap.set({ 'n', 'x' }, '<leader>Y', '"+yg_', { desc = 'Copy from system clipboard' })
 vim.keymap.set({ 'n', 'x' }, '<leader>p', '"+p', { desc = 'Paste from system clipboard' })
 vim.keymap.set({ 'n', 'x' }, '<leader>P', '"+P', { desc = 'Paste from system clipboard' })
 
+vim.keymap.set('v', 'v', function()
+  local mode = vim.fn.mode()
+  if mode == 'v' then
+    vim.api.nvim_feedkeys('V', 'n', true) -- Switch to Visual Line mode
+  elseif mode == 'V' then
+    vim.api.nvim_feedkeys('v', 'n', true) -- Switch to regular Visual mode
+  end
+end, { noremap = true, silent = true })
+
 vim.api.nvim_create_user_command('WinFont', 'set guifont=JetBrainsMonoNL\\ NF:h9', {})
 vim.api.nvim_create_user_command('LinuxFont', 'set guifont=JetBrainsMono\\ Nerd\\ Font\\ Mono:h7', {})
 

lua/overseer/template/user/clang/clang-tidy.lua

@@ -0,0 +1,24 @@
+return {
+  name = 'clang-tidy',
+  builder = function()
+    -- Full path to current file (see :help expand())
+    local dir = vim.loop.cwd()
+    local file = vim.fn.expand('%:p')
+    return {
+      cmd = { 'clang-tidy' },
+      -- cmd = { 'c:/Users/uid40528/scoop/apps/llvm/current/bin/clang-tidy.exe' },
+      args = { file, '-p', 'build_nvim', '--quiet', '--config-file', dir .. '/.clang-tidy' },
+      cwd = dir,
+      components = {
+        { 'on_result_diagnostics_quickfix', open = false },
+        { 'on_output_parse', problem_matcher = '$gcc' },
+        { 'on_result_diagnostics', remove_on_restart = true },
+        { 'restart_on_save' },
+        'default',
+      },
+    }
+  end,
+  condition = {
+    filetype = { 'cpp' },
+  },
+}

lua/overseer/template/user/cmake/build.lua

@@ -1,26 +1,26 @@
-
 return {
   name = 'CMake Build for nvim',
   builder = function()
     return {
       cmd = { 'cmake' },
-      args = { '--build', '.',
-        '--', '-j8' },
+      args = { '--build', '.', '--', '-j8' },
       cwd = 'build_nvim',
       -- components = {"on_output_parse", problem_matcher = "$gcc"}
       -- components = {'on_output_quickfix', set_diagnostics = true, open = true}
-      components = { { "on_output_quickfix", open = true, open_on_match = true },
+      components = {
+        { 'on_output_quickfix', open = true, open_on_match = true },
         { 'on_output_parse', problem_matcher = '$gcc' },
-        'default' },
+        'default',
+      },
     }
   end,
   condition = {
     callback = function(opts)
-      if vim.fn.executable("cmake") == 0 then
+      if vim.fn.executable('cmake') == 0 then
         return false, 'Command "cmake" not found'
       end
-      if vim.fn.findfile("CMakeLists.txt", opts.dir .. ";") == "" then
-        return false, "No CMakeLists.txt found"
+      if vim.fn.findfile('CMakeLists.txt', opts.dir .. ';') == '' then
+        return false, 'No CMakeLists.txt found'
       end
       return true
     end,

lua/overseer/template/user/cmake/clean.lua

@@ -1,21 +1,19 @@
-
 return {
   name = 'CMake Clean for nvim',
   builder = function()
     return {
       cmd = { 'cmake' },
-      args = { '--build', '.',
-        '-t', 'clean' },
+      args = { '--build', '.', '-t', 'clean' },
       cwd = 'build_nvim',
     }
   end,
   condition = {
     callback = function(opts)
-      if vim.fn.executable("cmake") == 0 then
+      if vim.fn.executable('cmake') == 0 then
         return false, 'Command "cmake" not found'
       end
-      if vim.fn.findfile("CMakeLists.txt", opts.dir .. ";") == "" then
-        return false, "No CMakeLists.txt found"
+      if vim.fn.findfile('CMakeLists.txt', opts.dir .. ';') == '' then
+        return false, 'No CMakeLists.txt found'
       end
       return true
     end,

lua/overseer/template/user/cmake/cmake.lua

@@ -1,6 +1,7 @@
 return {
-'builtin',
-'user.cmake.configure',
-'user.cmake.build',
-'user.cmake.clean'}
+  'builtin',
+  'user.cmake.configure',
+  'user.cmake.build',
+  'user.cmake.clean',
+}
 -- https://gitlab.com/ranjithshegde/dotbare/-/tree/master/.config/nvim/lua/overseer

lua/overseer/template/user/cmake/configure.lua

@@ -4,19 +4,17 @@ return {
     local cwd = vim.fn.getcwd()
     return {
       cmd = { 'cmake' },
-      args = { '-B', 'build_nvim',
-        '-S', cwd,
-        '-G', 'Ninja' },
+      args = { '-B', 'build_nvim', '-S', cwd, '-G', 'Ninja' },
       cwd = build_nvim,
     }
   end,
   condition = {
     callback = function(opts)
-      if vim.fn.executable("cmake") == 0 then
+      if vim.fn.executable('cmake') == 0 then
         return false, 'Command "cmake" not found'
       end
-      if vim.fn.findfile("CMakeLists.txt", opts.dir .. ";") == "" then
-        return false, "No CMakeLists.txt found"
+      if vim.fn.findfile('CMakeLists.txt', opts.dir .. ';') == '' then
+        return false, 'No CMakeLists.txt found'
       end
       return true
     end,

lua/plugins/advanced-git-search.lua

@@ -1,67 +0,0 @@
-return {
-  'aaronhallaert/advanced-git-search.nvim',
-  config = function()
-    require('telescope').load_extension('advanced_git_search')
-    vim.api.nvim_create_user_command(
-      'DiffCommitLine',
-      'lua require("telescope").extensions.advanced_git_search.diff_commit_line()',
-      { range = true }
-    )
-  end,
-  dependencies = {
-    'nvim-telescope/telescope.nvim',
-    -- to show diff splits and open commits in browser
-    'tpope/vim-fugitive',
-  },
-  keys = {
-    {
-      '<leader>hb',
-      function()
-        require('telescope').extensions.advanced_git_search.diff_branch_file()
-      end,
-      desc = 'Diff file against branch'
-    },
-    {
-      '<leader>hl',
-      ':DiffCommitLine<cr>gv',
-      desc = 'Diff current line againt previous commits',
-      mode = { 'x', 'n' },
-      noremap = true
-    },
-    {
-      '<leader>hf',
-      function()
-        require('telescope').extensions.advanced_git_search.diff_commit_file()
-      end,
-      desc = 'Diff current file against previous commits'
-    },
-    {
-      '<leader>ha',
-      function()
-        require('telescope').extensions.advanced_git_search.search_log_content()
-      end,
-      desc = 'Search git log'
-    },
-    {
-      '<leader>hs',
-      function()
-        require('telescope').extensions.advanced_git_search.search_log_content_file()
-      end,
-      desc = 'Search git log that changed current file'
-    },
-    {
-      '<leader>hr',
-      function()
-        require('telescope').extensions.advanced_git_search.checkout_reflog()
-      end,
-      desc = 'Search all reflog entries'
-    },
-    {
-      '<leader>hh',
-      function()
-        require('telescope').extensions.advanced_git_search.show_custom_functions()
-      end,
-      desc = 'Shwo all git telecope functions'
-    }
-  }
-}

lua/plugins/aerial.lua

@@ -1,27 +0,0 @@
-return {
-  'stevearc/aerial.nvim',
-  dependencies = {
-    'nvim-telescope/telescope.nvim'
-  },
-  config = function()
-    require('aerial').setup({
-      backends = { 'lsp', 'treesitter', 'markdown' },
-      layout = {
-        default_direction = 'prefer_left'
-      },
-      filter_kind = false,
-      show_guides = true,
-    })
-    require('telescope').load_extension('aerial')
-  end,
-  cmd = 'AerialToggle',
-  keys = {
-    {
-      '<leader>s',
-      function()
-        require('aerial').toggle()
-      end,
-      desc = 'Symbols outline',
-    }
-  }
-}

lua/plugins/aider.lua

@@ -0,0 +1,32 @@
+return {
+  'GeorgesAlkhouri/nvim-aider',
+  cmd = {
+    'AiderTerminalToggle',
+    'AiderHealth',
+  },
+  keys = {
+    { '<leader>a/', '<cmd>AiderTerminalToggle<cr>', desc = 'Open Aider' },
+    { '<leader>as', '<cmd>AiderTerminalSend<cr>', desc = 'Send to Aider', mode = { 'n', 'v' } },
+    { '<leader>ac', '<cmd>AiderQuickSendCommand<cr>', desc = 'Send Command To Aider' },
+    { '<leader>ab', '<cmd>AiderQuickSendBuffer<cr>', desc = 'Send Buffer To Aider' },
+    { '<leader>a+', '<cmd>AiderQuickAddFile<cr>', desc = 'Add File to Aider' },
+    { '<leader>a-', '<cmd>AiderQuickDropFile<cr>', desc = 'Drop File from Aider' },
+    { '<leader>ar', '<cmd>AiderQuickReadOnlyFile<cr>', desc = 'Add File as Read-Only' },
+    -- 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',
+  },
+  opts = {
+    args = {
+      '--model gemini-2.5-pro',
+      '--no-auto-commits',
+      '--pretty',
+      '--stream',
+    },
+  },
+  config = true,
+  enabled = false,
+}

lua/plugins/avante.lua

@@ -0,0 +1,58 @@
+return {
+  'yetone/avante.nvim',
+  version = false, -- Set this to "*" to always pull the latest release version, or set it to false to update to the latest code changes.
+  opts = {
+    debug = false,
+    provider = 'gemini',
+    auto_suggestions_provider = 'openai', -- Since auto-suggestions are a high-frequency operation and therefore expensive, it is recommended to specify an inexpensive provider or even a free provider: copilot
+    openai = {
+      endpoint = 'https://api.openai.com/v1',
+      -- model = 'o3-mini',
+      timeout = 30000, -- Timeout in milliseconds
+      temperature = 0,
+      max_tokens = 4096,
+    },
+    gemini = {
+      api_key_name = 'GEMINI_API_KEY',
+      model = 'gemini-2.5-flash-preview-04-17',
+    },
+  },
+  -- 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 = {
+    'stevearc/dressing.nvim',
+    'nvim-lua/plenary.nvim',
+    'MunifTanjim/nui.nvim',
+    'nvim-tree/nvim-web-devicons', -- or echasnovski/mini.icons
+    'zbirenbaum/copilot.lua', -- for providers='copilot'
+    {
+      'MeanderingProgrammer/render-markdown.nvim',
+    },
+  },
+  cmd = {
+    'AvanteAsk',
+    'AvanteBuild',
+    'AvanteChat',
+    'AvanteChatNew',
+    'AvanteHistory',
+    'AvanteClear',
+    'AvanteEdit',
+    'AvanteFocus',
+    'AvanteRefresh',
+    'AvanteStop',
+    'AvanteSwitchProvider',
+    'AvanteShowRepoMap',
+    'AvanteToggle',
+    'AvanteModels',
+    'AvanteSwitchSelectorProvider',
+  },
+  keys = {
+    {
+      '<leader>aa',
+      '<cmd>AvanteAsk<CR>',
+      desc = 'Avante Ask',
+    },
+  },
+  enabled = false,
+}

lua/plugins/blink.lua

@@ -0,0 +1,235 @@
+return {
+  'saghen/blink.cmp',
+  lazy = false, -- lazy loading handled internally
+  -- optional: provides snippets for the snippet source
+  dependencies = {
+    'rafamadriz/friendly-snippets',
+    'giuxtaposition/blink-cmp-copilot',
+    {
+      'fang2hou/blink-copilot',
+      opts = {
+        max_completions = 1, -- Global default for max completions
+        max_attempts = 2, -- Global default for max attempts
+        -- `kind` is not set, so the default value is "Copilot"
+      },
+    },
+    'dmitmel/cmp-cmdline-history',
+    'onsails/lspkind.nvim',
+    'folke/lazydev.nvim',
+    'L3MON4D3/LuaSnip',
+    {
+      'saghen/blink.compat',
+      -- use the latest release, via version = '*', if you also use the latest release for blink.cmp
+      version = '*',
+      -- lazy.nvim will automatically load the plugin when it's required by blink.cmp
+      lazy = true,
+      -- make sure to set opts so that lazy.nvim calls blink.compat's setup
+      opts = {},
+    },
+    'rcarriga/cmp-dap',
+  },
+
+  -- use a release tag to download pre-built binaries
+  version = '*',
+  -- OR build from source, requires nightly: https://rust-lang.github.io/rustup/concepts/channels.html#working-with-nightly-rust
+  -- build = 'cargo build --release',
+  -- If you use nix, you can build from source using latest nightly rust with:
+  -- build = 'nix run .#build-plugin',
+
+  opts = {
+    -- 'default' for mappings similar to built-in completion
+    -- 'super-tab' for mappings similar to vscode (tab to accept, arrow keys to navigate)
+    -- 'enter' for mappings similar to 'super-tab' but with 'enter' to accept
+    -- see the "default configuration" section below for full documentation on how to define
+    -- your own keymap.
+    keymap = { preset = 'enter' },
+
+    appearance = {
+      -- Sets the fallback highlight groups to nvim-cmp's highlight groups
+      -- Useful for when your theme doesn't support blink.cmp
+      -- will be removed in a future release
+      use_nvim_cmp_as_default = true,
+      -- Set to 'mono' for 'Nerd Font Mono' or 'normal' for 'Nerd Font'
+      -- Adjusts spacing to ensure icons are aligned
+      nerd_font_variant = 'mono',
+    },
+
+    enabled = function() return (vim.bo.buftype ~= 'prompt' and vim.b.completion ~= false) or require('cmp_dap').is_dap_buffer() end,
+    -- default list of enabled providers defined so that you can extend it
+    -- elsewhere in your config, without redefining it, via `opts_extend`
+    sources = {
+      default = { 'copilot', 'lazydev', 'lsp', 'path', 'snippets', 'buffer', 'codeium' },
+
+      per_filetype = {
+        ['dap-repl'] = {
+          'copilot',
+          'dap',
+          'snippets',
+          'path',
+          'buffer',
+        },
+      },
+
+      providers = {
+        copilot = {
+          name = 'copilot',
+          module = 'blink-copilot',
+          score_offset = 100,
+          async = true,
+          opts = {
+            -- Local options override global ones
+            -- Final settings: max_completions = 3, max_attempts = 2, kind = "Copilot"
+            max_completions = 3, -- Override global max_completions
+          },
+        },
+        lazydev = {
+          name = 'LazyDev',
+          module = 'lazydev.integrations.blink',
+          -- make lazydev completions top priority (see `:h blink.cmp`)
+          score_offset = 100,
+        },
+        codeium = { -- TODO: Replace with https://github.com/Exafunction/codeium.nvim/pull/264
+          name = 'codeium', -- IMPORTANT: use the same name as you would for nvim-cmp
+          module = 'blink.compat.source',
+          async = true,
+        },
+        cmdline_history = {
+          name = 'cmdline_history',
+          module = 'blink.compat.source',
+          score_offset = -50,
+        },
+        dap = {
+          name = 'dap',
+          module = 'blink.compat.source',
+          async = false,
+          enabled = function() return require('cmp_dap').is_dap_buffer() end,
+        },
+        buffer = {
+          name = 'Buffer',
+          module = 'blink.cmp.sources.buffer',
+          opts = {
+            -- default to all visible buffers
+            get_bufnrs = function()
+              return vim
+                .iter(vim.api.nvim_list_wins())
+                :map(function(win) return vim.api.nvim_win_get_buf(win) end)
+                :filter(function(buf) return vim.bo[buf].buftype ~= 'nofile' end)
+                :totable()
+            end,
+          },
+        },
+      },
+    },
+
+    cmdline = {
+      sources = function()
+        local type = vim.fn.getcmdtype()
+        -- Search forward and backward
+        if type == '/' or type == '?' then
+          return { 'buffer' }
+        end
+        -- Commands
+        if type == ':' or type == '@' then
+          return { 'cmdline', 'buffer', 'cmdline_history' }
+        end
+        return {}
+      end,
+      completion = {
+        trigger = {
+          show_on_blocked_trigger_characters = {},
+          show_on_x_blocked_trigger_characters = nil, -- Inherits from top level `completion.trigger.show_on_blocked_trigger_characters` config when not set
+        },
+        list = {
+          selection = {
+            auto_insert = false,
+            preselect = false,
+          },
+        },
+        menu = {
+          auto_show = true, -- Inherits from top level `completion.menu.auto_show` config when not set
+        },
+      },
+      keymap = {
+        ['<down>'] = { 'select_next', 'fallback' },
+        ['<up>'] = { 'select_prev', 'fallback' },
+        ['<CR>'] = { 'accept', 'fallback' },
+        ['<C-e>'] = { 'cancel' },
+      },
+    },
+
+    completion = {
+      list = {
+        selection = {
+          auto_insert = false,
+          preselect = false,
+        },
+      },
+      accept = {
+        dot_repeat = false,
+      },
+      menu = {
+        max_height = 25,
+        draw = {
+          padding = 1,
+          gap = 1,
+          -- treesitter = { 'lsp' },
+          components = {
+            kind_icon = {
+              ellipsis = false,
+              text = function(ctx)
+                local lspkind = require('lspkind')
+                local icon = ctx.kind_icon
+                if ctx.source_name == 'cmdline_history' then
+                  icon = require('nvim-web-devicons').get_icon('log')
+                elseif vim.tbl_contains({ 'Path' }, ctx.source_name) then
+                  local dev_icon, _ = require('nvim-web-devicons').get_icon(ctx.label)
+                  if dev_icon then
+                    icon = dev_icon
+                  end
+                else
+                  icon = lspkind.symbolic(ctx.kind, {
+                    mode = 'symbol',
+                  })
+                end
+
+                return icon .. ctx.icon_gap
+              end,
+
+              -- Optionally, use the highlight groups from nvim-web-devicons
+              -- You can also add the same function for `kind.highlight` if you want to
+              -- keep the highlight groups in sync with the icons.
+              highlight = function(ctx)
+                local hl = ctx.kind_hl
+                if ctx.source_name == 'cmdline_history' then
+                  _, hl = require('nvim-web-devicons').get_icon('log')
+                elseif ctx.source_name == 'cmdline' then
+                  _, hl = require('nvim-web-devicons').get_icon('cc')
+                elseif vim.tbl_contains({ 'Path' }, ctx.source_name) then
+                  local dev_icon, dev_hl = require('nvim-web-devicons').get_icon(ctx.label)
+                  if dev_icon then
+                    hl = dev_hl
+                  end
+                end
+                return hl
+              end,
+            },
+          },
+        },
+      },
+      documentation = {
+        auto_show = true,
+        auto_show_delay_ms = 500,
+        treesitter_highlighting = true,
+      },
+    },
+
+    -- experimental signature help support
+    signature = { enabled = true },
+    snippets = {
+      preset = 'luasnip',
+    },
+  },
+  -- allows extending the providers array elsewhere in your config
+  -- without having to redefine it
+  enabled = false,
+}

lua/plugins/cmake-tools.lua

@@ -1,37 +1,35 @@
-return {
-  'Civitasv/cmake-tools.nvim',
-  opts = {
-    cmake_command = 'cmake',
-    cmake_generate_options = { '-D', 'CMAKE_EXPORT_COMPILE_COMMANDS=1', '-G', 'Ninja' },
-    cmake_show_console = 'always',
-    cmake_build_directory = 'build_nvim',
-    cmake_dap_configuration = { name = 'cpp', type = 'codelldb', request = 'launch' }, -- dap configuration, optional
-  },
-  cmd = {
-    'CMakeGenerate',
-    'CMakeBuild',
-    'CMakeRun',
-    'CMakeDebug',
-    'CMakeSelectBuildType',
-    'CMakeSelectBuildTarget',
-    'CMakeSelectLaunchTarget',
-    'CMakeSelectKit',
-    'CMakeSelectConfigurePreset',
-    'CMakeSelectBuildPreset',
-    'CMakeSelectLaunchTarget',
-    'CMakeOpen',
-    'CMakeClose',
-    'CMakeInstall',
-    'CMakeClean',
-    'CMakeStop',
-  },
-  keys = {
-    {
-      '<S-F6>',
-      function()
-        require('cmake-tools').debug({})
-      end,
-      desc = 'Run and debug target from cmake'
-    }
-  }
-}
+return {
+  'Civitasv/cmake-tools.nvim',
+  opts = {
+    cmake_command = 'cmake',
+    cmake_generate_options = { '-D', 'CMAKE_EXPORT_COMPILE_COMMANDS=1', '-G', 'Ninja' },
+    cmake_show_console = 'always',
+    cmake_build_directory = 'build_nvim',
+    cmake_dap_configuration = { name = 'cpp', type = 'codelldb', request = 'launch' }, -- dap configuration, optional
+  },
+  cmd = {
+    'CMakeGenerate',
+    'CMakeBuild',
+    'CMakeRun',
+    'CMakeDebug',
+    'CMakeSelectBuildType',
+    'CMakeSelectBuildTarget',
+    'CMakeSelectLaunchTarget',
+    'CMakeSelectKit',
+    'CMakeSelectConfigurePreset',
+    'CMakeSelectBuildPreset',
+    'CMakeSelectLaunchTarget',
+    'CMakeOpen',
+    'CMakeClose',
+    'CMakeInstall',
+    'CMakeClean',
+    'CMakeStop',
+  },
+  keys = {
+    {
+      '<S-F6>',
+      function() require('cmake-tools').debug({}) end,
+      desc = 'Run and debug target from cmake',
+    },
+  },
+}

lua/plugins/cmp.lua

@@ -1,46 +1,46 @@
 return {
   'hrsh7th/nvim-cmp',
+  branch = 'main',
+  lazy = false,
   dependencies = {
-    { 'onsails/lspkind-nvim' },
-    { 'hrsh7th/cmp-buffer' },
-    { 'hrsh7th/cmp-nvim-lsp' },
-    { 'L3MON4D3/LuaSnip' },
-    { 'saadparwaiz1/cmp_luasnip' },
-    { 'hrsh7th/cmp-nvim-lua' },
-    { 'octaltree/cmp-look' },
-    { 'hrsh7th/cmp-path' },
-    { 'hrsh7th/cmp-calc' },
-    { 'f3fora/cmp-spell' },
-    { 'hrsh7th/cmp-emoji' },
-    { 'hrsh7th/cmp-cmdline' },
-    { 'dmitmel/cmp-cmdline-history' },
-    { 'ray-x/cmp-treesitter' },
-    { 'hrsh7th/cmp-nvim-lsp-signature-help' },
-    { 'p00f/clangd_extensions.nvim' },
-    {
-      'windwp/nvim-autopairs',
-      config = true,
-    },
+    'neovim/nvim-lspconfig',
+    'hrsh7th/cmp-nvim-lsp',
+    'hrsh7th/cmp-buffer',
+    'hrsh7th/cmp-path',
+    'hrsh7th/cmp-cmdline',
+    'L3MON4D3/LuaSnip',
+    'saadparwaiz1/cmp_luasnip',
+    'onsails/lspkind.nvim',
+    'zbirenbaum/copilot-cmp',
+    'hrsh7th/cmp-path',
+    'dmitmel/cmp-cmdline-history',
+    'hrsh7th/cmp-nvim-lsp-signature-help',
   },
   config = function()
-    local cmp = require('cmp')
-    local luasnip = require('luasnip')
+    local t = function(str) return vim.api.nvim_replace_termcodes(str, true, true, true) end
 
-    local t = function(str)
-      return vim.api.nvim_replace_termcodes(str, true, true, true)
-    end
+    local cmp = require('cmp')
+    local lspkind = require('lspkind')
+    local luasnip = require('luasnip')
+    lspkind.init({
+      symbol_map = {
+        Copilot = '',
+      },
+    })
+    require('copilot_cmp').setup()
 
     cmp.setup({
-      formatting = {
-        format = require('lspkind').cmp_format({
-          mode = 'symbol_text',  -- show only symbol annotations
-          maxwidth = 80,         -- prevent the popup from showing more than provided characters (e.g 50 will not show more than 50 characters)
-          ellipsis_char = '...', -- when popup menu exceed maxwidth, the truncated part would show ellipsis_char instead (must define maxwidth first)
-        })
+      preselect = cmp.PreselectMode.None,
+      snippet = {
+        expand = function(args)
+          require('luasnip').lsp_expand(args.body) -- For `luasnip` users.
+        end,
       },
       mapping = {
         ['<Up>'] = cmp.mapping(cmp.mapping.select_prev_item(), { 'i', 'c', 's' }),
         ['<Down>'] = cmp.mapping(cmp.mapping.select_next_item(), { 'i', 'c', 's' }),
+        ['<C-p>'] = cmp.mapping(cmp.mapping.select_prev_item(), { 'i', 'c', 's' }),
+        ['<C-n>'] = cmp.mapping(cmp.mapping.select_next_item(), { 'i', 'c', 's' }),
         ['<C-d>'] = cmp.mapping.scroll_docs(-4),
         ['<C-f>'] = cmp.mapping.scroll_docs(4),
         ['<C-Space>'] = cmp.mapping(cmp.mapping.complete(), { 'i', 'c', 's' }),
@@ -72,107 +72,80 @@ return {
           else
             fallback()
           end
-        end, { 'i', 's', }),
-        ['<c-x>'] = cmp.mapping(cmp.mapping.complete(
-          {
+        end, { 'i', 's' }),
+        ['<c-x>'] = cmp.mapping(
+          cmp.mapping.complete({
             config = {
               sources = {
                 {
-                  name = 'cmdline_history'
-                }
-              }
-            }
-          }
-        ), { 'c' }),
+                  name = 'cmdline_history',
+                },
+              },
+            },
+          }),
+          { 'c' }
+        ),
       },
-      snippet = {
-        expand = function(args)
-          require('luasnip').lsp_expand(args.body)
-        end,
-      },
-      sources = {
-        { name = 'luasnip',                 priority = 8 },
-        { name = 'nvim_lsp',                priority = 7 },
-        { name = 'nvim_lsp_signature_help', priority = 7 },
-        { name = 'treesitter',              priority = 6 },
+      sources = cmp.config.sources({
+        { name = 'copilot' },
+        { name = 'nvim_lsp' },
+        { name = 'nvim_lsp_signature_help' },
+        { name = 'luasnip' },
         {
           name = 'buffer',
-          priority = 5,
           option = {
-            get_bufnrs = function()
-              local bufs = {}
-              for _, win in ipairs(vim.api.nvim_list_wins()) do
-                bufs[vim.api.nvim_win_get_buf(win)] = true
-              end
-              return vim.tbl_keys(bufs)
-            end
-          }
+            get_bufnrs = function() return vim.api.nvim_list_bufs() end,
+          },
         },
-        -- { name = 'nvim_lua' },
-        -- { name = 'look' },
-        -- { name = 'path' },
-        -- { name = 'cmp_tabnine' },
-        -- { name = 'calc' },
-        -- { name = 'spell' },
-        -- { name = 'emoji' },
-      },
-      enabled = function()
-        return vim.api.nvim_buf_get_option(0, 'buftype') ~= 'prompt'
-            or vim.api.nvim_buf_get_option(0, 'filetype') == 'dap-repl'
-            or vim.api.nvim_buf_get_option(0, 'filetype') == 'dapui_watches'
-            or vim.api.nvim_buf_get_option(0, 'filetype') == 'dapui_hover'
-      end,
-      completion = { completeopt = 'menu,menuone,noinsert, noselect' },
+        { name = 'path' },
+      }),
+
       window = {
-        -- completion = cmp.config.window.bordered(),
-        -- documentation = cmp.config.window.bordered(),
-      },
-      sorting = {
-        comparators = {
-          cmp.config.compare.offset,
-          cmp.config.compare.exact,
-          cmp.config.compare.recently_used,
-          require('clangd_extensions.cmp_scores'),
-          cmp.config.compare.kind,
-          cmp.config.compare.sort_text,
-          cmp.config.compare.length,
-          cmp.config.compare.order,
+        documentation = {
+          winhighlight = 'Normal:CmpDocumentation',
+        },
+        completion = {
+          winhighlight = 'Normal:Pmenu,FloatBorder:Pmenu,Search:None',
+          col_offset = -3,
+          side_padding = 0,
         },
       },
-      -- experimental = { native_menu = true }
+      formatting = {
+        fields = { 'kind', 'abbr', 'menu' },
+        expandable_indicator = false,
+        format = function(entry, vim_item)
+          local kind = require('lspkind').cmp_format({ mode = 'symbol_text', maxwidth = 50, show_labelDetails = true })(entry, vim_item)
+          local strings = vim.split(kind.kind, '%s', { trimempty = true })
+          kind.kind = ' ' .. (strings[1] or '') .. ' '
+          kind.menu = '    (' .. (strings[2] or '') .. ')'
+
+          return kind
+        end,
+      },
     })
 
-    -- Use buffer source for `/` (if you enabled `native_menu`, this won't work anymore).
-    cmp.setup.cmdline('/', {
+    -- Use buffer source for `/` and `?` (if you enabled `native_menu`, this won't work anymore).
+    cmp.setup.cmdline({ '/', '?' }, {
+      mapping = cmp.mapping.preset.cmdline(),
       sources = {
         { name = 'buffer' },
+        { name = 'cmdline_history' },
+        { name = 'path' },
+        { name = 'buffer' },
       },
     })
 
     -- Use cmdline & path source for ':' (if you enabled `native_menu`, this won't work anymore).
     cmp.setup.cmdline(':', {
+      mapping = cmp.mapping.preset.cmdline(),
       sources = {
-        { name = 'cmdline' },
-        -- { name = 'cmdline_history' },
-        { name = 'path' },
-        { name = 'buffer' },
+        { name = 'cmdline', priority = 200 },
+        { name = 'path', priority = 3 },
+        { name = 'cmdline_history', priority = 3 },
+        { name = 'buffer', priority = 3 },
       },
+      matching = { disallow_symbol_nonprefix_matching = false },
     })
-
-    require('cmp').setup.filetype({ 'dap-repl', 'dapui_watches', 'dapui_hover' }, {
-      sources = {
-        { name = 'dap' },
-      },
-    })
-
-    -- Autopairs
-    --require("nvim-autopairs.completion.cmp").setup({
-    --    map_cr = true,
-    --    map_complete = true,
-    --    auto_select = true
-    --})
-    local cmp_autopairs = require('nvim-autopairs.completion.cmp')
-    cmp.event:on('confirm_done', cmp_autopairs.on_confirm_done({ map_char = { tex = '' } }))
   end,
-  event = { 'InsertEnter', 'CmdLineEnter' },
+  enabled = true,
 }

lua/plugins/codecompanion.lua

@@ -0,0 +1,35 @@
+return {
+  'olimorris/codecompanion.nvim',
+  dependencies = {
+    'nvim-lua/plenary.nvim',
+    'nvim-treesitter/nvim-treesitter',
+  },
+  branch = 'main',
+  config = function()
+    require('codecompanion').setup({
+      strategies = {
+        chat = {
+          adapter = 'copilot',
+        },
+        inline = {
+          adapter = 'copilot',
+        },
+      },
+      -- adapters = {
+      --   anthropic = function()
+      --     return require('codecompanion.adapters').extend('copilot', {
+      --       env = {
+      --         api_key = 'ghu_8hbMItSdtNIrzMI4svd94dem3ZCsk23VG446',
+      --       },
+      --     })
+      --   end,
+      -- },
+    })
+  end,
+  cmd = {
+    'CodeCompanion',
+    'CodeCompanionChat',
+    'CodeCompanionCmd',
+    'CodeCompanionActions ',
+  },
+}

lua/plugins/comment.lua

@@ -1,20 +1,11 @@
-return {
-  'numToStr/Comment.nvim',
-  opts = {
-    mappings = false,
-  },
-  keys = {
-    {
-      '<c-c>',
-      '<Plug>(comment_toggle_linewise_current)',
-      desc = 'Toggle comment'
-    },
-
-    {
-      '<c-c>',
-      '<Plug>(comment_toggle_linewise_visual)gv',
-      mode = 'v',
-      desc = 'Toggle comment'
-    }
-  }
-}
+return {
+  'numToStr/Comment.nvim',
+  version = '*',
+  opts = {
+    mappings = false,
+  },
+  keys = {
+    { '<c-c>', '<Plug>(comment_toggle_linewise_current)', desc = 'Toggle comment' },
+    { '<c-c>', '<Plug>(comment_toggle_linewise_visual)gv', mode = 'v', desc = 'Toggle comment' },
+  },
+}

lua/plugins/conform.lua

@@ -0,0 +1,27 @@
+return {
+  'stevearc/conform.nvim',
+  cmd = { 'ConformInfo' },
+  opts = {
+    default_format_opts = {
+      lsp_format = 'fallback',
+    },
+    log_level = vim.log.levels.ERROR,
+    formatters_by_ft = {
+      lua = { 'stylua' },
+      python = { 'ruff_format' },
+      yaml = { 'prettier', timeout_ms = 5000 },
+      cmake = { 'gersemi' },
+      markdown = { 'prettier' },
+      json = { 'fixjson' },
+      toml = { 'taplo' },
+    },
+  },
+  keys = {
+    {
+      '<space>f',
+      mode = { 'n', 'x', 'v' },
+      function() require('conform').format() end,
+      desc = 'Format with Conform',
+    },
+  },
+}

lua/plugins/copilot.lua

@@ -0,0 +1,24 @@
+return {
+  'zbirenbaum/copilot.lua',
+  cmd = 'Copilot',
+  event = 'InsertEnter',
+  config = function()
+    require('copilot').setup({
+      filetypes = {
+        yaml = false,
+        markdown = false,
+        python = true,
+        help = false,
+        gitcommit = false,
+        gitrebase = false,
+        hgcommit = false,
+        svn = false,
+        cvs = false,
+        cpp = true,
+        ['.'] = false,
+      },
+      suggestion = { enabled = false, auto_trigger = false },
+      panel = { enabled = false },
+    })
+  end,
+}

lua/plugins/dap.lua

@@ -1,226 +1,142 @@
-return {
-  'mfussenegger/nvim-dap',
-  dependencies = {
-    'mfussenegger/nvim-dap-python',
-    'theHamsta/nvim-dap-virtual-text',
-    {
-      'nvim-telescope/telescope-dap.nvim',
-      dependencies = 'telescope.nvim',
-    },
-    'rcarriga/nvim-dap-ui',
-    'rcarriga/cmp-dap',
-  },
-  keys = {
-    {
-      '<F5>',
-      function()
-        require('dap').continue()
-      end,
-      desc = 'DAP start or continue'
-    },
-    {
-      '<S-F5>',
-      function()
-        require('dap').run_last()
-      end,
-      desc = 'DAP run last'
-    },
-    {
-      '<F6>',
-      function()
-        loadConfigs()
-      end,
-      desc = 'DAP configs'
-    },
-    {
-      '<F7>',
-      function()
-        require('dap').goto_()
-      end,
-      desc = 'DAP goto'
-    },
-    {
-      '<F8>',
-      function()
-        require('dap.ui.widgets').hover()
-      end,
-      desc = 'DAP Hover'
-    },
-    {
-      '<F9>',
-      function()
-        require('dap').toggle_breakpoint()
-      end,
-      desc = 'DAP breakpoint'
-    },
-    {
-      '<F10>',
-      function()
-        require('dap').step_over()
-      end,
-      desc = 'DAP step_over'
-    },
-    {
-      '<F11>',
-      function()
-        require('dap').step_into()
-      end,
-      desc = 'DAP step_into'
-    },
-    {
-      '<S-F11>',
-      function()
-        require('dap').step_out()
-      end,
-      desc = 'DAP step_out'
-    },
-  },
-  config = function()
-    local dap = require('dap')
-    vim.fn.sign_define('DapBreakpoint', { text = '🛑', texthl = '', linehl = '', numhl = '' })
-    require('cmp_dap').is_dap_buffer()
-
-
-    -- make sure we can exit the terminal with esc
-    vim.api.nvim_create_autocmd({ 'TermOpen' }, {
-      pattern = { '*dap-terminal*' },
-      callback = function()
-        local opts = { noremap = true }
-        vim.api.nvim_buf_set_keymap(0, 't', '<esc>', [[<C-\><C-n>]], opts)
-      end
-    })
-
-    local pythonVenv = require('utils.python_venv')
-
-    function loadConfigs()
-      require('dap.ext.vscode').load_launchjs()
-      -- Make sure we use the correct python env even for the configs from launch.json
-      for _, config in pairs(dap.configurations.python) do
-        config.pythonPath = pythonVenv.getPythonEnv()
-        config.cwd = vim.fn.getcwd()
-      end
-      require 'telescope'.extensions.dap.configurations {}
-    end
-
-    local masonpath = vim.fn.stdpath('data') .. '/mason'
-
-    -- PYTHON
-    dap.adapters.python = {
-      type = 'executable',
-      command = masonpath .. '/packages/debugpy/venv/' .. pythonVenv.getVenvSuffix(),
-      args = { '-m', 'debugpy.adapter' },
-      options = {
-        detached = true,
-      },
-    }
-
-    local dapui = require('dapui')
-    dapui.setup()
-    dap.listeners.after.event_initialized['dapui_config'] = function()
-      dapui.open({})
-    end
-    dap.listeners.before.event_terminated['dapui_config'] = function()
-      dapui.close({})
-    end
-    dap.listeners.before.event_exited['dapui_config'] = function()
-      dapui.close({})
-    end
-
-    dap.configurations.python = {
-      {
-        type = 'python',
-        request = 'launch',
-        name = 'Launch file with venv',
-        justMyCode = false,
-        program = '${file}',
-        cwd = vim.fn.getcwd(),
-        pythonPath = pythonVenv.getPythonEnv
-      },
-    }
-
-    -- require('dap-python').setup('C:\\Users\\oli\\AppData\\Local\\nvim\\venv_debugpy\\Scripts\\python')
-    -- table.insert(require('dap').configurations.python, {
-    --   -- type = 'python',
-    --   -- request = 'launch',
-    --   -- name = 'My custom launch configuration',
-    --   -- program = '${file}',
-    --   justMyCode = false
-    --   -- ... more options, see https://github.com/microsoft/debugpy/wiki/Debug-configuration-settings
-    -- })
-    -- require('dap-python').setup('C:/Users/oli/AppData/Local/nvim-data/mason/packages/debugpy/venv/Scripts/python.exe')
-
-    -- CPP
-    dap.adapters.codelldb = {
-      type = 'server',
-      port = '${port}',
-      executable = {
-        -- CHANGE THIS to your path!
-        command = masonpath .. '/bin/codelldb.cmd',
-        args = { '--port', '${port}' },
-
-        -- On windows you may have to uncomment this:
-        detached = false,
-      }
-    }
-
-    dap.adapters.cppdbg = {
-      id = 'cppdbg',
-      type = 'executable',
-      command = masonpath .. '/bin/OpenDebugAD7',
-    }
-
-    dap.adapters.lldb = {
-      type = 'executable',
-      command = function()
-        if vim.loop.os_uname().sysname == 'Linux' then
-          return 'lldb-vscode'
-        else
-          return os.getenv('SCOOP') .. '/apps/llvm/current/bin/lldb-vscode.exe'
-        end
-      end,
-      name = 'lldb'
-    }
-
-    dap.configurations.cpp = {
-      {
-        name = 'Launch codelldb',
-        type = 'codelldb',
-        request = 'launch',
-        program = function()
-          return vim.fn.input('Path to executable: ', vim.fn.getcwd() .. '/build_nvim/', 'file')
-        end,
-        cwd = '${workspaceFolder}',
-        stopOnEntry = false,
-      },
-      {
-        name = 'Launch lldb',
-        type = 'lldb',
-        request = 'launch',
-        program = function()
-          return vim.fn.input('Path to executable: ', vim.fn.getcwd() .. '/build_nvim', 'file')
-        end,
-        cwd = '${workspaceFolder}',
-        stopOnEntry = false,
-        args = {},
-
-        -- 💀
-        -- if you change `runInTerminal` to true, you might need to change the yama/ptrace_scope setting:
-        --
-        --    echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope
-        --
-        -- Otherwise you might get the following error:
-        --
-        --    Error on launch: Failed to attach to the target process
-        --
-        -- But you should be aware of the implications:
-        -- https://www.kernel.org/doc/html/latest/admin-guide/LSM/Yama.html
-        -- runInTerminal = false,
-      },
-    }
-
-    -- EXTENSIONS
-
-    require('nvim-dap-virtual-text').setup({})
-    require('telescope').load_extension('dap')
-  end,
-}
+return {
+  'mfussenegger/nvim-dap',
+  version = false,
+  dependencies = {
+    {
+      'mfussenegger/nvim-dap-python',
+      version = false,
+    },
+    -- 'theHamsta/nvim-dap-virtual-text',
+    {
+      'rcarriga/nvim-dap-ui',
+      version = false,
+      dependencies = {
+        'nvim-neotest/nvim-nio',
+      },
+    },
+    {
+      'LiadOz/nvim-dap-repl-highlights',
+      version = false,
+    },
+  },
+  keys = {
+    { '<F5>', function() require('dap').continue() end, desc = 'DAP start or continue' },
+    { '<S-F5>', function() require('dap').run_last() end, desc = 'DAP run last' },
+    { '<F6>', function() require('dap').run_last() end, desc = 'Run last' },
+    { '<F7>', function() require('dap').goto_() end, desc = 'DAP goto' },
+    { '<F8>', function() require('dap.ui.widgets').hover() end, desc = 'DAP Hover' },
+    { '<F9>', function() require('dap').toggle_breakpoint() end, desc = 'DAP breakpoint' },
+    { '<F10>', function() require('dap').step_over() end, desc = 'DAP step_over' },
+    { '<F11>', function() require('dap').step_into() end, desc = 'DAP step_into' },
+    { '<S-F11>', function() require('dap').step_out() end, desc = 'DAP step_out' },
+  },
+  config = function()
+    local dap = require('dap')
+    vim.fn.sign_define('DapBreakpoint', { text = '🛑', texthl = '', linehl = '', numhl = '' })
+
+    -- make sure we can exit the terminal with esc
+    vim.api.nvim_create_autocmd({ 'TermOpen' }, {
+      pattern = { '*dap-terminal*' },
+      callback = function()
+        local opts = { noremap = true }
+        vim.api.nvim_buf_set_keymap(0, 't', '<esc>', [[<C-\><C-n>]], opts)
+      end,
+    })
+
+    require('dap.ext.vscode').json_decode = require('utils.json_workaround').decode_json
+
+    local masonpath = vim.fn.stdpath('data') .. '/mason'
+
+    vim.keymap.set('x', '<leader>k', function()
+      local lines = vim.fn.getregion(vim.fn.getpos('.'), vim.fn.getpos('v'), { type = vim.fn.mode() })
+      dap.repl.execute(table.concat(lines, '\n'))
+    end, { desc = 'Dapl execute selection' })
+    vim.keymap.set('n', '<leader>k', function()
+      local line = vim.api.nvim_get_current_line()
+      dap.repl.execute(line)
+    end, { desc = 'DAP execute' })
+
+    local dapui = require('dapui')
+    dapui.setup()
+    dap.listeners.before.attach.dapui_config = function() dapui.open() end
+    dap.listeners.before.launch.dapui_config = function() dapui.open() end
+    dap.listeners.before.event_terminated.dapui_config = function() dapui.close() end
+    dap.listeners.before.event_exited.dapui_config = function() dapui.close() end
+
+    local path = require('mason-registry').get_package('debugpy'):get_install_path()
+    if vim.loop.os_uname().sysname:find('Windows') then
+      require('dap-python').setup(path .. 'dap-python' .. 'python')
+    else
+      require('dap-python').setup(path .. '/venv/bin/python')
+    end
+
+    -- CPP
+    dap.adapters.codelldb = {
+      type = 'server',
+      port = '${port}',
+      executable = {
+        command = require('mason-core.path').bin_prefix('codelldb'),
+        args = { '--port', '${port}' },
+
+        -- On windows you may have to uncomment this:
+        detached = false,
+      },
+    }
+
+    dap.adapters.cppdbg = {
+      id = 'cppdbg',
+      type = 'executable',
+      command = masonpath .. '/bin/OpenDebugAD7',
+    }
+
+    dap.adapters.lldb = {
+      type = 'executable',
+      command = function()
+        if vim.loop.os_uname().sysname == 'Linux' then
+          return 'lldb-vscode'
+        else
+          return os.getenv('SCOOP') .. '/apps/llvm/current/bin/lldb-vscode.exe'
+        end
+      end,
+      name = 'lldb',
+    }
+
+    dap.configurations.cpp = {
+      {
+        name = 'Launch codelldb',
+        type = 'codelldb',
+        request = 'launch',
+        program = function() return vim.fn.input({ 'Path to executable: ', vim.fn.getcwd() .. '/build_nvim/', 'file' }) end,
+        cwd = '${workspaceFolder}',
+        stopOnEntry = false,
+      },
+      {
+        name = 'Launch lldb',
+        type = 'lldb',
+        request = 'launch',
+        program = function() return vim.fn.input({ 'Path to executable: ', vim.fn.getcwd() .. '/build_nvim', 'file' }) end,
+        cwd = '${workspaceFolder}',
+        stopOnEntry = false,
+        args = {},
+
+        -- 💀
+        -- if you change `runInTerminal` to true, you might need to change the yama/ptrace_scope setting:
+        --
+        --    echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope
+        --
+        -- Otherwise you might get the following error:
+        --
+        --    Error on launch: Failed to attach to the target process
+        --
+        -- But you should be aware of the implications:
+        -- https://www.kernel.org/doc/html/latest/admin-guide/LSM/Yama.html
+        -- runInTerminal = false,
+      },
+    }
+
+    -- EXTENSIONS
+
+    require('nvim-dap-repl-highlights').setup()
+    -- require('nvim-dap-virtual-text').setup({})
+  end,
+}

lua/plugins/dial.lua

@@ -0,0 +1,23 @@
+return {
+  'monaqa/dial.nvim',
+  keys = {
+    { '<C-a>', function() return require('dial.map').inc_normal() end, expr = true, desc = 'Increment' },
+    { '<C-x>', function() return require('dial.map').dec_normal() end, expr = true, desc = 'Decrement' },
+    { '<C-a>', function() return require('dial.map').inc_visual() end, mode = 'v', expr = true, desc = 'Increment' },
+    { '<C-x>', function() return require('dial.map').dec_visual() end, mode = 'v', expr = true, desc = 'Decrement' },
+  },
+  config = function()
+    local augends = require('dial.augend')
+    require('dial.config').augends:register_group({
+      -- default augends used when no group name is specified
+      default = {
+        augends.integer.alias.decimal, -- nonnegative decimal number (0, 1, 2, 3, ...)
+        augends.integer.alias.hex, -- nonnegative hex number (0x0, 0x1, 0x2, ...)
+        augends.date.alias['%Y/%m/%d'], -- date (2027/04/15, etc.)
+        augends.constant.alias.bool, -- boolean value (true <-> false)
+        augends.constant.new({ elements = { 'True', 'False' } }),
+        augends.constant.new({ elements = { 'TRUE', 'FALSE' } }),
+      },
+    })
+  end,
+}

lua/plugins/diffview.lua

@@ -1,16 +1,25 @@
 return {
   'sindrets/diffview.nvim',
   dependencies = {
-    'nvim-lua/plenary.nvim'
+    'nvim-lua/plenary.nvim',
+  },
+  opts = {
+    keymaps = {
+      view = {
+        ['<leader>b'] = false,
+      },
+      file_panel = {
+        ['<leader>b'] = false,
+      },
+      file_history_panel = {
+        ['<leader>b'] = false,
+      },
+    },
   },
-  config = true,
   cmd = 'DiffviewOpen',
   keys = {
-    {
-      '<space>b',
-      '<cmd>DiffviewOpen origin/develop...<cr>',
-      desc = 'Diffview vs develop',
-    },
-
-  }
+    { '<space>bb', '<cmd>DiffviewOpen<cr>', desc = 'Diffview local' },
+    { '<space>bd', '<cmd>DiffviewOpen origin/develop...<cr>', desc = 'Diffview vs develop' },
+    { '<space>bm', '<cmd>DiffviewOpen origin/master...<cr>', desc = 'Diffview vs master' },
+  },
 }

lua/plugins/dressing.lua

@@ -1,3 +1,3 @@
-return {
-  'stevearc/dressing.nvim'
-}
+return {
+  'stevearc/dressing.nvim',
+}

lua/plugins/flash.lua

@@ -0,0 +1,33 @@
+return {
+  'folke/flash.nvim',
+  opts = {
+    modes = {
+      search = {
+        enabled = false,
+      },
+      char = {
+        keys = { 'f', 'F', 't', 'T', ';' },
+      },
+    },
+  },
+  keys = {
+    {
+      's',
+      mode = { 'n', 'x', 'o' },
+      function()
+        -- default options: exact mode, multi window, all directions, with a backdrop
+        require('flash').jump()
+      end,
+      desc = 'Flash jump',
+    },
+    {
+      'S',
+      mode = { 'n', 'o', 'x' },
+      function()
+        require('flash').treesitter()
+        vim.api.nvim_feedkeys('V', 'n', true)
+      end,
+      desc = 'Flash treesitter',
+    },
+  },
+}

lua/plugins/gitsigns.lua

@@ -1,12 +1,65 @@
 return {
   'lewis6991/gitsigns.nvim',
-  opts = {
-    current_line_blame = false,
-    current_line_blame_opts = {
-      virt_text = true,
-      virt_text_pos = 'eol', -- 'eol' | 'overlay' | 'right_align'
-      delay = 1000,
-      ignore_whitespace = false,
-    },
-  }
+  branch = 'main',
+  config = function()
+    require('gitsigns').setup({
+      current_line_blame = false,
+      current_line_blame_opts = {
+        virt_text = true,
+        virt_text_pos = 'eol', -- 'eol' | 'overlay' | 'right_align'
+        delay = 1000,
+        ignore_whitespace = false,
+      },
+      on_attach = function(bufnr)
+        local gitsigns = require('gitsigns')
+
+        -- Navigation
+        vim.keymap.set('n', ']c', function()
+          if vim.wo.diff then
+            vim.cmd.normal({ ']c', bang = true })
+          else
+            gitsigns.nav_hunk('next')
+          end
+        end, { desc = 'Next hunk' })
+
+        vim.keymap.set('n', '[c', function()
+          if vim.wo.diff then
+            vim.cmd.normal({ '[c', bang = true })
+          else
+            gitsigns.nav_hunk('prev')
+          end
+        end, { desc = 'Previous hunk' })
+
+        -- Actions
+        vim.keymap.set('n', '<leader>hs', gitsigns.stage_hunk, { desc = 'Stage hunk' })
+        vim.keymap.set('n', '<leader>hr', gitsigns.reset_hunk, { desc = 'Reset hunk' })
+
+        vim.keymap.set('v', '<leader>hs', function() gitsigns.stage_hunk({ vim.fn.line('.'), vim.fn.line('v') }) end, { desc = 'Stage hunk' })
+
+        vim.keymap.set('v', '<leader>hr', function() gitsigns.reset_hunk({ vim.fn.line('.'), vim.fn.line('v') }) end, { desc = 'Reset hunk' })
+
+        vim.keymap.set('n', '<leader>hS', gitsigns.stage_buffer, { desc = 'Stage buffer' })
+        vim.keymap.set('n', '<leader>hR', gitsigns.reset_buffer, { desc = 'Reset buffer' })
+        vim.keymap.set('n', '<leader>hp', gitsigns.preview_hunk, { desc = 'Preview hunk' })
+        vim.keymap.set('n', '<leader>hi', gitsigns.preview_hunk_inline, { desc = 'Preview hunk inline' })
+
+        vim.keymap.set('n', '<leader>hb', function() gitsigns.blame_line({ full = true }) end, { desc = 'Blame line' })
+
+        vim.keymap.set('n', '<leader>hd', gitsigns.diffthis, { desc = 'Diff this' })
+
+        vim.keymap.set('n', '<leader>hD', function() gitsigns.diffthis('~') end, { desc = 'Diff this (cached)' })
+
+        vim.keymap.set('n', '<leader>hQ', function() gitsigns.setqflist('all') end, { desc = 'Set quickfix list all' })
+        vim.keymap.set('n', '<leader>hq', gitsigns.setqflist, { desc = 'Set quickfix list' })
+
+        -- Toggles
+        vim.keymap.set('n', '<leader>tb', gitsigns.toggle_current_line_blame, { desc = 'Toggle blame' })
+        vim.keymap.set('n', '<leader>td', gitsigns.toggle_deleted, { desc = 'Toggle deleted' })
+        vim.keymap.set('n', '<leader>tw', gitsigns.toggle_word_diff, { desc = 'Toggle word diff' })
+
+        -- Text object
+        vim.keymap.set({ 'o', 'x' }, 'ih', ':<C-U>Gitsigns select_hunk<CR>')
+      end,
+    })
+  end,
 }

lua/plugins/goose.lua

@@ -0,0 +1,37 @@
+return {
+  'azorng/goose.nvim',
+  config = function()
+    require('goose').setup({
+      keymap = {
+        global = {
+          toggle = '<leader>xg', -- Open goose. Close if opened
+          open_input = '<leader>xx', -- Opens and focuses on input window on insert mode
+          open_input_new_session = '<leader>xX', -- Opens and focuses on input window on insert mode. Creates a new session
+          open_output = '<leader>xo', -- Opens and focuses on output window
+          toggle_focus = '<leader>xt', -- Toggle focus between goose and last window
+          close = '<leader>xq', -- Close UI windows
+          toggle_fullscreen = '<leader>xf', -- Toggle between normal and fullscreen mode
+          select_session = '<leader>xs', -- Select and load a goose session
+          goose_mode_chat = '<leader>xmc', -- Set goose mode to `chat`. (Tool calling disabled. No editor context besides selections)
+          goose_mode_auto = '<leader>xma', -- Set goose mode to `auto`. (Default mode with full agent capabilities)
+          configure_provider = '<leader>xp', -- Quick provider and model switch from predefined list
+          diff_open = '<leader>xd', -- Opens a diff tab of a modified file since the last goose prompt
+          diff_next = '<leader>x]', -- Navigate to next file diff
+          diff_prev = '<leader>x[', -- Navigate to previous file diff
+          diff_close = '<leader>xc', -- Close diff view tab and return to normal editing
+          diff_revert_all = '<leader>xra', -- Revert all file changes since the last goose prompt
+          diff_revert_this = '<leader>xrt', -- Revert current file changes since the last goose prompt
+        },
+        window = {
+          submit = '<C-s>',
+        },
+      },
+    })
+  end,
+  dependencies = {
+    'nvim-lua/plenary.nvim',
+    {
+      'MeanderingProgrammer/render-markdown.nvim',
+    },
+  },
+}

lua/plugins/grug-far.lua

@@ -0,0 +1,12 @@
+return {
+  'MagicDuck/grug-far.nvim',
+  config = function() require('grug-far').setup({}) end,
+  keys = {
+    {
+      '<C-f>',
+      function() require('grug-far').open() end,
+      desc = 'GrugFar',
+      mode = { 'n', 'v' },
+    },
+  },
+}

lua/plugins/incline.lua

@@ -0,0 +1,30 @@
+return {
+  'b0o/incline.nvim',
+  config = function()
+    local helpers = require('incline.helpers')
+    local devicons = require('nvim-web-devicons')
+    require('incline').setup({
+      window = {
+        padding = 0,
+        margin = { horizontal = 0 },
+      },
+      render = function(props)
+        local filename = vim.fn.fnamemodify(vim.api.nvim_buf_get_name(props.buf), ':t')
+        if filename == '' then
+          filename = '[No Name]'
+        end
+        local ft_icon, ft_color = devicons.get_icon_color(filename)
+        local modified = vim.bo[props.buf].modified
+        return {
+          ft_icon and { ' ', ft_icon, ' ', guibg = ft_color, guifg = helpers.contrast_color(ft_color) } or '',
+          ' ',
+          { filename, gui = modified and 'bold,italic' or 'bold' },
+          ' ',
+          guibg = '#44406e',
+        }
+      end,
+    })
+  end,
+  -- Optional: Lazy load Incline
+  event = 'VeryLazy',
+}

lua/plugins/indent_blankline.lua

@@ -1,20 +0,0 @@
-return {
-  'lukas-reineke/indent-blankline.nvim',
-  dependencies = {
-    'nvim-treesitter/nvim-treesitter',
-  },
-  opts = {
-    show_end_of_line = true,
-    use_treesitter = true,
-    show_current_context = true,
-    context_patterns = { 'class', 'function', 'method', 'block', '^if', '^for', '^while' },
-
-  },
-  config = function()
-    local opt = vim.opt -- to set options
-    opt.listchars:append('eol:↴')
-    -- opt.listchars:append("space: ")
-    opt.listchars:append('trail: ')
-    opt.listchars:append('tab:→ ')
-  end,
-}

lua/plugins/init.lua

@@ -1,2 +1 @@
-return {
-}
+return {}

lua/plugins/iron.lua

@@ -0,0 +1,63 @@
+return {
+  'Vigemus/iron.nvim',
+  branch = 'master',
+  config = function()
+    local iron = require('iron.core')
+
+    iron.setup({
+      config = {
+        -- Whether a repl should be discarded or not
+        scratch_repl = true,
+        -- Your repl definitions come here
+        repl_definition = {
+          sh = {
+            -- Can be a table or a function that
+            -- returns a table (see below)
+            command = { 'zsh' },
+          },
+          python = {
+            command = { 'python3' }, -- or { "ipython", "--no-autoindent" }
+            format = require('iron.fts.common').bracketed_paste_python,
+          },
+        },
+        -- How the repl window will be displayed
+        -- See below for more information
+        repl_open_cmd = require('iron.view').split.vertical('50%'),
+      },
+      -- Iron doesn't set keymaps by default anymore.
+      -- You can set them here or manually add keymaps to the functions in iron.core
+      keymaps = {
+        send_motion = '<space>sc',
+        visual_send = '<space>sc',
+        send_file = '<space>sf',
+        send_line = '<space>sl',
+        send_paragraph = '<space>sp',
+        send_until_cursor = '<space>su',
+        send_mark = '<space>sm',
+        mark_motion = '<space>mc',
+        mark_visual = '<space>mc',
+        remove_mark = '<space>md',
+        cr = '<space>s<cr>',
+        interrupt = '<space>s<space>',
+        exit = '<space>sq',
+        clear = '<space>cl',
+      },
+      -- If the highlight is on, you can change how it looks
+      -- For the available options, check nvim_set_hl
+      highlight = {
+        italic = true,
+      },
+      ignore_blank_lines = true, -- ignore blank lines when sending visual select lines
+    })
+
+    -- iron also has a list of commands, see :h iron-commands for all available commands
+  end,
+  cmd = {
+    'IronRepl',
+    'IronRestart',
+    'IronFocus',
+    'IronHide',
+    'IronRepl',
+    'IronReplHere',
+  },
+}

lua/plugins/lazydev.lua

@@ -0,0 +1,18 @@
+return {
+  {
+    'folke/lazydev.nvim',
+    ft = 'lua', -- only load on lua files
+    branch = 'main',
+    opts = {
+      library = {
+        -- See the configuration section for more details
+        -- Load luvit types when the `vim.uv` word is found
+        { path = 'luvit-meta/library', words = { 'vim%.uv' } },
+      },
+    },
+  },
+  {
+    'Bilal2453/luvit-meta',
+    lazy = true,
+  },
+}

lua/plugins/lazygit.lua

@@ -1,25 +0,0 @@
-return {
-  'kdheepak/lazygit.nvim',
-  dependencies = {
-    'nvim-telescope/telescope.nvim'
-  },
-  cmd = {
-    'LazyGit',
-    'LazyGitConfig',
-    'LazyGitFilter',
-    'LazyGitFilterCurrentFile',
-    'LazyGit',
-  },
-  config = function()
-    require('telescope').load_extension('lazygit')
-  end,
-  keys = {
-    {
-      '<Space>g',
-      function()
-        require('lazygit').lazygit()
-      end,
-      desc = 'LazyGit'
-    }
-  }
-}

lua/plugins/leap.lua

@@ -1,8 +0,0 @@
-return {
-  'ggandor/leap.nvim',
-  dependencies = { 'tpope/vim-repeat' },
-  config = function()
-    require('leap').set_default_keymaps()
-  end,
-  event = 'VeryLazy'
-}

lua/plugins/lsp.lua

@@ -0,0 +1,88 @@
+local lspKeys = function(client, bufnr)
+  local base_opts = { noremap = true, silent = false, buffer = bufnr }
+
+  local function opts(desc) return vim.tbl_extend('error', base_opts, { desc = desc }) end
+
+  local mappings = {
+    { mode = { 'n', 'x' }, key = '<space>a', fn = vim.lsp.buf.code_action, desc = 'Code action' },
+    { mode = 'n', key = '<space>e', fn = vim.lsp.buf.declaration, desc = 'Declaration' },
+    { mode = 'n', key = '<space>h', fn = function() vim.lsp.buf.hover({ border = 'none' }) end, desc = 'Hover' },
+    { mode = 'n', key = '<space>c', fn = vim.lsp.buf.outgoing_calls, desc = 'Outgoing calls' },
+    { mode = 'n', key = '<space>C', fn = vim.lsp.buf.incoming_calls, desc = 'Incoming calls' },
+    { mode = 'n', key = '<space>m', fn = vim.lsp.buf.rename, desc = 'Rename' },
+    { mode = 'n', key = '<space>D', fn = vim.lsp.buf.type_definition, desc = 'Type definition' },
+    { mode = { 'n', 'i', 'x' }, key = '<C-k>', fn = vim.lsp.buf.signature_help, desc = 'Signature help' },
+    { mode = 'n', key = '<space>v', fn = function() vim.diagnostic.open_float({ border = 'rounded' }) end, desc = 'Diagnostics Float' },
+    { mode = 'n', key = '<A-o>', fn = '<cmd>ClangdSwitchSourceHeader<CR>', desc = 'Switch Source/Header' },
+  }
+
+  for _, map in ipairs(mappings) do
+    vim.keymap.set(map.mode, map.key, map.fn, opts(map.desc))
+  end
+
+  if client.supports_method('inlayHintProvider') then
+    vim.keymap.set(
+      'n',
+      '<space>i',
+      function() vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled({ bufnr = bufnr }), { bufnr = bufnr }) end,
+      opts('Toggle inlay hints')
+    )
+  end
+end
+
+return {
+  'neovim/nvim-lspconfig',
+  dependencies = {
+    'williamboman/mason.nvim',
+    'williamboman/mason-lspconfig.nvim',
+    'SmiteshP/nvim-navic',
+  },
+  lazy = false,
+  config = function()
+    local servers = {
+      'basedpyright',
+      'ruff',
+      'clangd',
+      'lua_ls',
+      'jsonls',
+      'dockerls',
+      'yamlls',
+      'neocmake',
+      'markdown_oxide',
+      'taplo',
+    }
+
+    local capabilities = vim.lsp.protocol.make_client_capabilities()
+    capabilities = require('cmp_nvim_lsp').default_capabilities(capabilities)
+    -- capabilities = require('blink.cmp').get_lsp_capabilities(capabilities)
+    vim.lsp.config('*', {
+      capabilities = capabilities,
+    })
+
+    vim.lsp.enable(servers)
+
+    local lsp_group = vim.api.nvim_create_augroup('UserLspAttach', { clear = true })
+    vim.api.nvim_create_autocmd('LspAttach', {
+      group = lsp_group,
+      desc = 'Set buffer-local keymaps and options after an LSP client attaches',
+      callback = function(args)
+        local bufnr = args.buf
+        local client = vim.lsp.get_client_by_id(args.data.client_id)
+        if not client then
+          return
+        end
+        lspKeys(client, bufnr)
+
+        if client.server_capabilities.completionProvider then
+          vim.bo[bufnr].omnifunc = 'v:lua.vim.lsp.omnifunc'
+          vim.bo[bufnr].formatexpr = 'v:lua.vim.lsp.formatexpr()'
+        end
+
+        if client.server_capabilities.documentSymbolProvider then
+          local navic = require('nvim-navic')
+          navic.attach(client, bufnr)
+        end
+      end,
+    })
+  end,
+}

lua/plugins/lsp_lines.lua

@@ -1,14 +0,0 @@
-return {
-  'https://git.sr.ht/~whynothugo/lsp_lines.nvim',
-  config = true,
-  keys = {
-    {
-      '<space>l',
-      function()
-        require('lsp_lines').toggle()
-      end,
-      desc = 'Toggle lsp_lines',
-    }
-  },
-  event = 'LspAttach'
-}

lua/plugins/lspconfig.lua

@@ -1,322 +0,0 @@
-return {
-  'neovim/nvim-lspconfig',
-  dependencies = {
-    'williamboman/mason.nvim',
-    'williamboman/mason-lspconfig.nvim',
-    'p00f/clangd_extensions.nvim',
-    'jose-elias-alvarez/null-ls.nvim',
-    'ray-x/lsp_signature.nvim',
-    {
-      'folke/neodev.nvim',
-      config = true,
-    },
-  },
-  config = function()
-    require('mason').setup({
-      ui = {
-        border = 'rounded'
-      }
-    })
-    require('mason-lspconfig').setup({
-      automatic_installation = false,
-    })
-    local lspconfig = require 'lspconfig'
-
-    local capabilities = require('cmp_nvim_lsp').default_capabilities()
-
-    vim.api.nvim_set_hl(
-      0,
-      'LspReferenceText',
-      {
-        bold = true,
-        ctermbg = 'red',
-        bg = '#5a524c'
-      }
-    )
-    vim.api.nvim_set_hl(
-      0,
-      'LspReferenceRead',
-      {
-        bold = true,
-        ctermbg = 'red',
-        bg = 'DarkGreen'
-      }
-    )
-    vim.api.nvim_set_hl(
-      0,
-      'LspReferenceWrite',
-      {
-        bold = true,
-        ctermbg = 'red',
-        bg = 'DarkRed'
-      }
-    )
-    local diagnostics = {
-      Error = ' ',
-      Warning = ' ',
-      Information = ' ',
-      Question = ' ',
-      Hint = ' ',
-    }
-    local signs = {
-      { name = 'DiagnosticSignError', text = diagnostics.Error },
-      { name = 'DiagnosticSignWarn',  text = diagnostics.Warning },
-      { name = 'DiagnosticSignHint',  text = diagnostics.Hint },
-      { name = 'DiagnosticSignInfo',  text = diagnostics.Information },
-    }
-
-    for _, sign in ipairs(signs) do
-      vim.fn.sign_define(sign.name, { texthl = sign.name, text = sign.text, numhl = sign.name })
-    end
-
-    OpenDiagFloat = function()
-      for _, winid in pairs(vim.api.nvim_tabpage_list_wins(0)) do
-        if vim.api.nvim_win_get_config(winid).zindex then
-          return
-        end
-      end
-      vim.diagnostic.open_float({ focusable = false, width = 80 })
-    end
-
-    local on_attach = function(client, bufnr)
-      local function buf_set_option(...)
-        vim.api.nvim_buf_set_option(bufnr, ...)
-      end
-
-      buf_set_option('omnifunc', 'v:lua.vim.lsp.omnifunc')
-      vim.api.nvim_buf_set_option(0, 'formatexpr', 'v:lua.vim.lsp.formatexpr()')
-
-      -- Mappings.
-      local tele_builtins = require('telescope.builtin')
-      vim.keymap.set('n', '<space>,', vim.diagnostic.goto_prev,
-        { noremap = true, silent = false, desc = 'Diag prev', buffer = bufnr })
-      vim.keymap.set('n', '<space>;', vim.diagnostic.goto_next,
-        { noremap = true, silent = false, desc = 'Diag next', buffer = bufnr })
-      vim.keymap.set('n', '<space>a', vim.lsp.buf.code_action,
-        { noremap = true, silent = false, desc = 'Code action', buffer = bufnr })
-      vim.keymap.set('n', '<space>d', tele_builtins.lsp_definitions,
-        { noremap = true, silent = false, desc = 'Definition', buffer = bufnr })
-      vim.keymap.set('n', '<space>e', vim.lsp.buf.declaration,
-        { noremap = true, silent = false, desc = 'Declaration', buffer = bufnr })
-      vim.keymap.set('n', '<space>h', vim.lsp.buf.hover,
-        { noremap = true, silent = false, desc = 'Hover', buffer = bufnr })
-      vim.keymap.set('n', '<space>c', vim.lsp.buf.outgoing_calls,
-        { noremap = true, silent = false, desc = 'Outgoing calls', buffer = bufnr })
-      vim.keymap.set('n', '<space>C', vim.lsp.buf.incoming_calls,
-        { noremap = true, silent = false, desc = 'Incoming calls', buffer = bufnr })
-      vim.keymap.set('n', '<space>m', vim.lsp.buf.rename,
-        { noremap = true, silent = false, desc = 'Rename', buffer = bufnr })
-      vim.keymap.set('n', '<C-t>', tele_builtins.lsp_dynamic_workspace_symbols,
-        { noremap = true, silent = false, desc = 'Workspace symbols', buffer = bufnr })
-      vim.keymap.set('n', '<space>D', vim.lsp.buf.type_definition,
-        { noremap = true, silent = false, desc = 'Type definition', buffer = bufnr })
-      vim.keymap.set('n', '<C-k>', vim.lsp.buf.signature_help,
-        { noremap = true, silent = false, desc = 'Signature help', buffer = bufnr })
-      vim.keymap.set('n', '<space>r', tele_builtins.lsp_references,
-        { noremap = true, silent = false, desc = 'References', buffer = bufnr })
-      vim.keymap.set('n', '<A-m>', tele_builtins.lsp_document_symbols,
-        { noremap = true, silent = false, desc = 'References', buffer = bufnr })
-      vim.keymap.set('n', '<scapce>s', tele_builtins.lsp_dynamic_workspace_symbols,
-        { noremap = true, silent = false, desc = 'Workspace symbols', buffer = bufnr })
-      vim.keymap.set('n', '<space>v', function() tele_builtins.diagnostics({ bufnr = 0 }) end,
-        { noremap = true, silent = false, desc = 'Diagnostics', buffer = bufnr })
-      vim.keymap.set('n', '<A-o>', '<cmd>ClangdSwitchSourceHeader<CR>',
-        { noremap = true, silent = false, desc = 'Switch Source/Header', buffer = bufnr })
-
-
-      -- Set some keybinds conditional on server capabilities
-      if client.server_capabilities.documentFormattingProvider then
-        vim.keymap.set('n', '<space>f', function()
-            vim.lsp.buf.format({ timeout_ms = 10000 })
-          end,
-          { noremap = true, silent = false, desc = 'Format file', buffer = bufnr })
-      end
-      if client.server_capabilities.documentRangeFormattingProvider then
-        vim.keymap.set('x', '<space>f', function()
-            vim.lsp.buf.format({ timeout_ms = 10000 })
-          end,
-          { noremap = true, silent = false, desc = 'Format visual', buffer = bufnr })
-      end
-
-      -- Set autocommands conditional on server_capabilities
-      if client.server_capabilities.documentHighlightProvider then
-        local group = vim.api.nvim_create_augroup('lsp_document_highlight', { clear = false })
-        vim.api.nvim_create_autocmd({ 'CursorHold', 'CursorHoldI' }, {
-          callback = function()
-            vim.lsp.buf.document_highlight()
-          end,
-          buffer = bufnr,
-          group = group,
-          desc = 'Document Highlight',
-        })
-        vim.api.nvim_create_autocmd('CursorMoved', {
-          callback = function()
-            vim.lsp.buf.clear_references()
-          end,
-          buffer = bufnr,
-          group = group,
-          desc = 'Clear All the References',
-        })
-        vim.api.nvim_create_autocmd({ 'LspDetach' }, {
-          group = group,
-          buffer = bufnr,
-          callback = function()
-            vim.lsp.buf.clear_references()
-            vim.api.nvim_clear_autocmds {
-              group = group,
-              buffer = bufnr
-            }
-          end,
-        })
-      end
-
-      require('lsp_signature').on_attach({
-        bind = true, -- This is mandatory, otherwise border config won't get registered.
-        handler_opts = {
-          border = 'single',
-        },
-        hi_parameter = 'IncSearch',
-      }, bufnr)
-    end
-
-    lspconfig['pyright'].setup {
-      capabilities = capabilities,
-      on_attach = on_attach,
-    }
-
-    lspconfig['groovyls'].setup {
-      capabilities = capabilities,
-      on_attach = on_attach,
-    }
-
-    -- lspconfig['cmake'].setup {
-    --   capabilities = capabilities,
-    --   on_attach = on_attach,
-    -- }
-
-    local configs = require('lspconfig.configs')
-    if not configs.neocmake then
-      configs.neocmake = {
-        default_config = {
-          cmd = { 'neocmakelsp', '--stdio' },
-          filetypes = { 'cmake' },
-          root_dir = function(fname)
-            return lspconfig.util.find_git_ancestor(fname)
-          end,
-          single_file_support = true, -- suggested
-          on_attach = on_attach       -- on_attach is the on_attach function you defined
-        }
-      }
-      lspconfig.neocmake.setup({})
-    end
-
-    local clangd_capabilities = capabilities
-    clangd_capabilities.textDocument.semanticHighlighting = true
-    clangd_capabilities.offsetEncoding = { 'utf-16' }
-    require('clangd_extensions').setup {
-      server = {
-        capabilities = clangd_capabilities,
-        on_attach = on_attach,
-        cmd = { 'clangd', '--compile-commands-dir=build_nvim', '--query-driver',
-          '/opt/cortex-a78-2022.08-gcc12.1-linux5.15/bin/aarch64-linux-gnu-g*' },
-        root_dir = lspconfig.util.root_pattern(
-          '.clangd',
-          '.clang-tidy',
-          '.clang-format',
-          'compile_flags.txt',
-          'configure.ac',
-          '.git',
-          'build_nvim'
-        )
-      },
-      extensions =
-      {
-        inlay_hints = {
-          -- Only show inlay hints for the current line
-          only_current_line = true,
-        }
-      }
-
-    }
-
-    lspconfig['jsonls'].setup {
-      capabilities = capabilities,
-      on_attach = on_attach,
-    }
-
-    local lua_rtp = vim.split(package.path, ';')
-    table.insert(lua_rtp, 'lua/?.lua')
-    table.insert(lua_rtp, 'lua/?/init.lua')
-    lspconfig.lua_ls.setup {
-      capabilities = capabilities,
-      on_attach = on_attach,
-      settings = {
-        Lua = {
-          runtime = {
-            -- Tell the language server which version of Lua you're using (most likely LuaJIT in the case of Neovim)
-            version = 'LuaJIT',
-            -- Setup your lua path
-            path = lua_rtp,
-          },
-          diagnostics = {
-            -- Get the language server to recognize the `vim` global
-            globals = { 'vim' },
-          },
-          workspace = {
-            -- Make the server aware of Neovim runtime files
-            library = vim.api.nvim_get_runtime_file('', true),
-            checkThirdParty = false,
-          },
-          -- Do not send telemetry data containing a randomized but unique identifier
-          telemetry = {
-            enable = false,
-          },
-          format = {
-            enable = true,
-            defaultConfig = {
-              indent_style = 'space',
-              indent_size = '2',
-              quote_style = 'single',
-            }
-          }
-        },
-      }
-    }
-
-    lspconfig['dockerls'].setup {
-      capabilities = capabilities,
-      on_attach = on_attach,
-    }
-
-    lspconfig['yamlls'].setup {
-      capabilities = capabilities,
-      on_attach = on_attach,
-      settings = {
-        yaml = {
-          validate = true
-        }
-      }
-    }
-
-    local null_ls = require('null-ls')
-    null_ls.setup({
-      sources = {
-        null_ls.builtins.code_actions.gitsigns,
-        -- null_ls.builtins.formatting.black,
-        null_ls.builtins.formatting.autopep8,
-        null_ls.builtins.formatting.prettier,
-        null_ls.builtins.formatting.xmlformat,
-        null_ls.builtins.diagnostics.flake8,
-        null_ls.builtins.formatting.isort,
-        null_ls.builtins.formatting.cmake_format,
-      },
-      debug = true,
-      on_attach = on_attach,
-      capabilities = capabilities,
-    })
-
-    -- vim.diagnostic.config({ virtual_text = false })
-    vim.diagnostic.config({ virtual_text = false, virtual_lines = { only_current_line = true } })
-  end,
-  event = 'VeryLazy'
-}

lua/plugins/lualine.lua

@@ -1,45 +1,48 @@
 return {
   'nvim-lualine/lualine.nvim',
-  dependencies = { 'nvim-tree/nvim-web-devicons' },
+  dependencies = {
+    'nvim-tree/nvim-web-devicons',
+    'Isrothy/lualine-diagnostic-message',
+  },
   config = function()
-    local custom_gruvbox = require 'lualine.themes.gruvbox_dark'
-
-    -- Change the background of lualine_c section for normal mode
-    custom_gruvbox.normal.a.bg = '#282828'
-    custom_gruvbox.normal.b.bg = '#282828'
-    custom_gruvbox.normal.c.bg = '#282828'
-    -- custom_gruvbox.normal.a.fg = '#282828'
-    -- custom_gruvbox.normal.b.fg = '#282828'
-    -- custom_gruvbox.normal.c.fg = '#282828'
-
-    require('lualine').setup {
+    require('lualine').setup({
       options = {
-        -- theme = custom_gruvbox,
-        theme = 'gruvbox_dark',
+        theme = 'auto',
         disabled_filetypes = {
           statusline = {},
           winbar = { 'dap-repl', 'dapui_console' },
         },
+        section_separators = { left = '', right = '' },
+        component_separators = { left = '', right = '' },
       },
       globalstatus = true,
-      extensions = { 'aerial' },
+      extensions = { 'oil', 'toggleterm' },
       sections = {
         lualine_b = {
           'branch',
           'diff',
           {
             'diagnostics',
-            sources = { 'nvim_diagnostic' }
-          }
+            sources = { 'nvim_diagnostic' },
+          },
         },
         lualine_c = {
-          'hostname',
-          'getcwd',
-          { 'filename', path = 1, file_status = true }
+          {
+            'getcwd',
+          },
+          {
+            'filename',
+            path = 1,
+            file_status = true,
+          },
+          {
+            function() return require('nvim-navic').get_location() end,
+            cond = function() return package.loaded['nvim-navic'] and require('nvim-navic').is_available() end,
+          },
         },
         lualine_y = {
           'searchcount',
-          'progress'
+          'progress',
         },
       },
       inactive_sections = {
@@ -48,60 +51,9 @@ return {
           {
             'filename',
             path = 1,
-            file_status = true
-          }
-        }
-      },
-      winbar = {
-        lualine_a = {
-          {
-            'filename',
-            path = 0,
             file_status = true,
-            separator = { left = '', right = '' },
-            -- color = { fg = '#ffaa88', gui = 'bold' }
-            color = { fg = '#ffaa88', bg = '#282828', gui = 'bold' }
-          }
+          },
         },
-        lualine_b = {
-          {
-            'filesize',
-            color = { bg = '#282828' }
-          }
-        },
-        lualine_c = {
-          {
-            'aerial',
-            color = { fg = '#ebdbb2', bg = '#282828', gui = 'bold' }
-          }
-        },
-        lualine_x = {},
-        lualine_y = {},
-        lualine_z = {
-        }
-      },
-      inactive_winbar = {
-        lualine_a = {
-          {
-            'filename',
-            path = 0,
-            file_status = true,
-            separator = { left = '', right = '' },
-            color = { fg = '#ffaa88', bg = '#282828', gui = 'bold' }
-            -- color = { fg = '#ffaa88', bg = 'grey', gui = 'italic,bold' }
-            -- color = { fg = '#ff1111'}
-          }
-        },
-        lualine_b = {
-          {
-            'filesize',
-            color = { bg = '#282828' }
-          }
-        },
-        lualine_c = { 'aerial' },
-        lualine_x = {},
-        lualine_y = {},
-        lualine_z = {}
       },
       tabline = {
         lualine_a = {},
@@ -112,15 +64,16 @@ return {
             mode = 2,
             tabs_color = {
               -- Same values as the general color option can be used here.
-              active = 'lualine_a_normal',     -- Color for active tab.
-              inactive = 'lualine_a_inactive', -- Color for inactive tab.
+              active = { bg = 'orange', fg = 'black' },
+              inactive = { bg = 'grey', fg = 'black' },
             },
-          }
+          },
         },
         lualine_x = {},
         lualine_y = {},
-        lualine_z = {}
+        lualine_z = {},
       },
-    }
-  end
+    })
+  end,
+  enabled = true,
 }

lua/plugins/luasnip-snippets.lua

@@ -0,0 +1,9 @@
+return {
+  'mireq/luasnip-snippets',
+  dependencies = { 'L3MON4D3/LuaSnip' },
+  init = function()
+    -- Mandatory setup function
+    require('luasnip_snippets.common.snip_utils').setup()
+  end,
+  enabled = false,
+}

lua/plugins/luasnip.lua

@@ -1,7 +1,17 @@
 return {
   'L3MON4D3/LuaSnip',
+  dependencies = { 'rafamadriz/friendly-snippets' },
   config = function()
     local ls = require('luasnip')
+    ls.setup({
+      -- Required to automatically include base snippets, like "c" snippets for "cpp"
+      -- load_ft_func = require('luasnip_snippets.common.snip_utils').load_ft_func,
+      -- ft_func = require('luasnip_snippets.common.snip_utils').ft_func,
+      -- To enable auto expansin
+      enable_autosnippets = true,
+      -- Uncomment to enable visual snippets triggered using <c-x>
+      store_selection_keys = '<c-x>',
+    })
     -- some shorthands...
     local s = ls.snippet
     local sn = ls.snippet_node
@@ -34,33 +44,68 @@ return {
 
     ls.snippets = {
       cpp = {
-        s('TEST_F_getset',
-          {
-            t('TEST_F('), i(1, 'TestClass'), t(' ,test_'), p(getRegA, false), t({ '_set_get)', '{', '  ' }),
-            i(2, 'm_object'), t('.set'), p(getRegA, true), t('('), i(3, '32.F'), t({ ');', '  ' }),
-            i(4, 'EXPECT_EQ('), rep(3), t(', '), rep(2), t('.get'), p(getRegA, true), t({ '());', '' }),
-            t({ '', '}', '' })
-          }),
-        s('TEST_fn_getset',
-          {
-            t('void '), p(getRegA, false), t('_'), i(1, 'get'), t('_'), i(2, 'set'), t({ '()', '{', '  ' }),
-            i(3, 'm_object'), t('.set'), p(getRegA, true), t('('), i(4, '32.F'), t({ ');', '  ' }),
-            i(5, 'EXPECT_EQ('), rep(4), t(', '), rep(3), t('.get'), p(getRegA, true), t({ '());', '' }),
-            t({ '', '}', '', '' }),
+        s('TEST_F_getset', {
+          t('TEST_F('),
+          i(1, 'TestClass'),
+          t(' ,test_'),
+          p(getRegA, false),
+          t({ '_set_get)', '{', '  ' }),
+          i(2, 'm_object'),
+          t('.set'),
+          p(getRegA, true),
+          t('('),
+          i(3, '32.F'),
+          t({ ');', '  ' }),
+          i(4, 'EXPECT_EQ('),
+          rep(3),
+          t(', '),
+          rep(2),
+          t('.get'),
+          p(getRegA, true),
+          t({ '());', '' }),
+          t({ '', '}', '' }),
+        }),
+        s('TEST_fn_getset', {
+          t('void '),
+          p(getRegA, false),
+          t('_'),
+          i(1, 'get'),
+          t('_'),
+          i(2, 'set'),
+          t({ '()', '{', '  ' }),
+          i(3, 'm_object'),
+          t('.set'),
+          p(getRegA, true),
+          t('('),
+          i(4, '32.F'),
+          t({ ');', '  ' }),
+          i(5, 'EXPECT_EQ('),
+          rep(4),
+          t(', '),
+          rep(3),
+          t('.get'),
+          p(getRegA, true),
+          t({ '());', '' }),
+          t({ '', '}', '', '' }),
 
-            t('TEST_F('), i(5), t(' ,test_'), p(getRegA, false), t({ '_set_get)', '{', '  ' }),
-            p(getRegA, false), t('_'), rep(1), t('_'), rep(2), t({ '();' }),
-            t({ '', '}' }),
-          })
+          t('TEST_F('),
+          i(5),
+          t(' ,test_'),
+          p(getRegA, false),
+          t({ '_set_get)', '{', '  ' }),
+          p(getRegA, false),
+          t('_'),
+          rep(1),
+          t('_'),
+          rep(2),
+          t({ '();' }),
+          t({ '', '}' }),
+        }),
       },
     }
 
     require('luasnip.loaders.from_vscode').lazy_load()
     require('luasnip.loaders.from_vscode').lazy_load({ paths = { './my-snippets' } })
   end,
-  dependencies =
-  {
-    'rafamadriz/friendly-snippets'
-  },
-  cmd = 'LuaSnipListAvailable'
+  cmd = 'LuaSnipListAvailable',
 }

lua/plugins/markdown-preview.lua

@@ -0,0 +1,17 @@
+return {
+  'iamcco/markdown-preview.nvim',
+  cmd = {
+    'MarkdownPreviewToggle',
+    'MarkdownPreview',
+    'MarkdownPreviewStop',
+  },
+  branch = 'master',
+  ft = { 'markdown' },
+  build = function() vim.fn['mkdp#util#install']() end,
+  init = function()
+    vim.g.mkdp_auto_close = 0
+    vim.g.mkdp_auto_start = 0
+    vim.g.mkdp_combine_preview = 1
+    vim.g.mkdp_combine_preview_auto_refresh = 1
+  end,
+}

lua/plugins/mason.lua

@@ -0,0 +1,24 @@
+return {
+  'williamboman/mason.nvim',
+  dependencies = {
+    'williamboman/mason-lspconfig.nvim',
+    'WhoIsSethDaniel/mason-tool-installer.nvim',
+  },
+  build = ':MasonUpdate',
+  branch = 'main',
+  config = function()
+    require('mason').setup({
+      ui = {
+        border = 'rounded',
+      },
+    })
+    require('mason-lspconfig').setup({
+      automatic_installation = false,
+    })
+    require('mason-tool-installer').setup({
+
+      -- a list of all tools you want to ensure are installed upon
+      -- start
+    })
+  end,
+}

lua/plugins/mini-sessions.lua

@@ -0,0 +1,5 @@
+return {
+  'echasnovski/mini.sessions',
+  version = '*',
+  config = function() require('mini.sessions').setup() end,
+}

lua/plugins/mini-surround.lua

@@ -0,0 +1,20 @@
+return {
+  'echasnovski/mini.surround',
+  version = '*',
+  config = function()
+    require('mini.surround').setup({
+      mappings = {
+        add = '<leader>aa', -- Add surrounding in Normal and Visual modes
+        delete = '<leader>ad', -- Delete surrounding
+        find = '<leader>af', -- Find surrounding (to the right)
+        find_left = '<leader>aF', -- Find surrounding (to the left)
+        highlight = '<leader>ah', -- Highlight surrounding
+        replace = '<leader>ar', -- Replace surrounding
+        update_n_lines = '<leader>an', -- Update `n_lines`
+
+        suffix_last = 'l', -- Suffix to search with "prev" method
+        suffix_next = 'n', -- Suffix to search with "next" method
+      },
+    })
+  end,
+}

lua/plugins/mini_ai.lua

@@ -0,0 +1,10 @@
+return {
+  'echasnovski/mini.ai',
+  config = function()
+    require('mini.ai').setup({
+      -- Number of lines within which textobject is searched
+      n_lines = 150,
+      search_method = 'cover',
+    })
+  end,
+}

lua/plugins/navbuddy.lua

@@ -1,59 +0,0 @@
-return {
-  'SmiteshP/nvim-navbuddy',
-  dependencies = {
-    'neovim/nvim-lspconfig',
-    'SmiteshP/nvim-navic',
-    'MunifTanjim/nui.nvim'
-  },
-  config = function()
-    local actions = require('nvim-navbuddy.actions')
-    local navbuddy = require('nvim-navbuddy')
-    navbuddy.setup {
-      mappings = {
-        ['<esc>'] = actions.close,           -- Close and cursor to original location
-        ['q'] = actions.close,
-        ['j'] = actions.next_sibling,        -- down
-        ['k'] = actions.previous_sibling,    -- up
-        ['h'] = actions.parent,              -- Move to left panel
-        ['l'] = actions.children,            -- Move to right panel
-        ['v'] = actions.visual_name,         -- Visual selection of name
-        ['V'] = actions.visual_scope,        -- Visual selection of scope
-        ['y'] = actions.yank_name,           -- Yank the name to system clipboard "+
-        ['Y'] = actions.yank_scope,          -- Yank the scope to system clipboard "+
-        ['i'] = actions.insert_name,         -- Insert at start of name
-        ['I'] = actions.insert_scope,        -- Insert at start of scope
-        ['a'] = actions.append_name,         -- Insert at end of name
-        ['A'] = actions.append_scope,        -- Insert at end of scope
-        ['r'] = actions.rename,              -- Rename currently focused symbol
-        ['d'] = actions.delete,              -- Delete scope
-        ['f'] = actions.fold_create,         -- Create fold of current scope
-        ['F'] = actions.fold_delete,         -- Delete fold of current scope
-        ['c'] = actions.comment,             -- Comment out current scope
-        ['<enter>'] = actions.select,        -- Goto selected symbol
-        ['o'] = actions.select,
-        ['J'] = actions.move_down,           -- Move focused node down
-        ['K'] = actions.move_up,             -- Move focused node up
-        ['<down>'] = actions.next_sibling,   -- down
-        ['<uo>'] = actions.previous_sibling, -- up
-        ['<left>'] = actions.parent,         -- Move to left panel
-        ['<right>'] = actions.children,      -- Move to right panel
-        ['<S-down>'] = actions.move_down,    -- Move focused node down
-        ['<S-up>'] = actions.move_up,        -- Move focused node up
-      },
-      lsp = {
-        auto_attach = true, -- If set to true, you don't need to manually use attach function
-      },
-    }
-  end,
-  keys = {
-    {
-      '<Space>n',
-      function()
-        require('nvim-navbuddy').open()
-      end,
-      desc = 'Navbuddy'
-    },
-  },
-  cmd = 'Navbuddy',
-  event = 'LspAttach'
-}

lua/plugins/neoclip.lua

@@ -1,18 +0,0 @@
-return {
-  'AckslD/nvim-neoclip.lua',
-  dependencies = {
-    { 'kkharji/sqlite.lua', module = 'sqlite' },
-    -- { 'nvim-telescope/telescope.nvim' },
-  },
-  config = true,
-  keys = {
-    {
-      '[',
-      function()
-        require('telescope').extensions.neoclip.default({ initial_mode = 'normal' })
-      end,
-      desc = 'NeoClip'
-    }
-  },
-  event = 'VeryLazy'
-}

lua/plugins/neogen.lua

@@ -1,34 +1,32 @@
-return {
-  'danymat/neogen',
-  dependencies = 'nvim-treesitter/nvim-treesitter',
-  opts = {
-    enabled = true,
-    languages = {
-      cpp = {
-        template = {
-          annotation_convention = 'custom',
-          custom = {
-            { nil, '/// file', { no_results = true, type = { 'file' } } },
-            { nil, '/// $1', { no_results = true, type = { 'func', 'file' } } },
-            { nil, '', { no_results = true, type = { 'file' } } },
-
-            { nil, '/// $1', { type = { 'func' } } },
-            { 'tparam', '/// \\tparam %s $1' },
-            { 'parameters', '/// \\param %s $1' },
-            { 'return_statement', '/// \\return $1' },
-          },
-        },
-      },
-    },
-  },
-  keys = {
-    {
-      '<leader>n',
-      function()
-        require('neogen').generate({})
-      end,
-      desc = 'Add comment',
-    }
-  },
-  cmd = 'Neogen'
-}
+return {
+  'danymat/neogen',
+  dependencies = 'nvim-treesitter/nvim-treesitter',
+  opts = {
+    enabled = true,
+    languages = {
+      cpp = {
+        template = {
+          annotation_convention = 'custom',
+          custom = {
+            { nil, '/// file', { no_results = true, type = { 'file' } } },
+            { nil, '/// $1', { no_results = true, type = { 'func', 'file' } } },
+            { nil, '', { no_results = true, type = { 'file' } } },
+
+            { nil, '/// $1', { type = { 'func' } } },
+            { 'tparam', '/// \\tparam %s $1' },
+            { 'parameters', '/// \\param %s $1' },
+            { 'return_statement', '/// \\return $1' },
+          },
+        },
+      },
+    },
+  },
+  keys = {
+    {
+      '<leader>n',
+      function() require('neogen').generate({}) end,
+      desc = 'Add comment',
+    },
+  },
+  cmd = 'Neogen',
+}

lua/plugins/neogit.lua

@@ -0,0 +1,24 @@
+return {
+  branch = 'master',
+  'TimUntersberger/neogit',
+  dependencies = {
+    'nvim-lua/plenary.nvim',
+    'sindrets/diffview.nvim',
+  },
+  config = function()
+    local neogit = require('neogit')
+    neogit.setup({
+      integrations = {
+        diffview = true,
+      },
+      graph_style = 'unicode',
+    })
+  end,
+  keys = {
+    {
+      '<space>t',
+      function() require('neogit').open() end,
+    },
+  },
+  cmd = { 'Neogit ' },
+}

lua/plugins/neotest.lua

@@ -1,40 +1,35 @@
-return {
-  'nvim-neotest/neotest',
-  dependencies = {
-    'nvim-lua/plenary.nvim',
-    'nvim-treesitter/nvim-treesitter',
-    'antoinemadec/FixCursorHold.nvim',
-    'nvim-neotest/neotest-python'
-  },
-  config = function()
-    local pythonVenv = require('utils.python_venv')
-    require('neotest').setup({
-      adapters = {
-        require('neotest-python')({
-          dap = {
-            justMyCode = false
-          },
-          args = { '--log-level', 'DEBUG' },
-          runner = 'pytest',
-          python = pythonVenv.getPythonEnv
-        })
-      }
-    })
-  end,
-  keys = {
-    {
-      '<F3>',
-      function()
-        require('neotest').run.run()
-      end,
-      desc = 'Run nearest test'
-    },
-    {
-      '<S-F3>',
-      function()
-        require('neotest').run.run({ strategy = 'dap' })
-      end,
-      desc = 'Run nearest test'
-    }
-  }
-}
+return {
+  'nvim-neotest/neotest',
+  dependencies = {
+    'nvim-lua/plenary.nvim',
+    'nvim-treesitter/nvim-treesitter',
+    'antoinemadec/FixCursorHold.nvim',
+    'nvim-neotest/neotest-python',
+  },
+  config = function()
+    local pythonVenv = require('utils.python_venv')
+    require('neotest').setup({
+      adapters = {
+        require('neotest-python')({
+          dap = {
+            justMyCode = false,
+          },
+          runner = 'pytest',
+          python = pythonVenv.getPythonEnv,
+        }),
+      },
+    })
+  end,
+  keys = {
+    {
+      '<F3>',
+      function() require('neotest').run.run() end,
+      desc = 'Run nearest test',
+    },
+    {
+      '<S-F3>',
+      function() require('neotest').run.run({ strategy = 'dap' }) end,
+      desc = 'Run nearest test',
+    },
+  },
+}

lua/plugins/neotree.lua

@@ -1,63 +0,0 @@
-return {
-  'nvim-neo-tree/neo-tree.nvim',
-  cmd = 'Neotree',
-  keys = {
-    { '\\', '<cmd>Neotree reveal<cr>', desc = 'NeoTree' },
-  },
-  dependencies = {
-    'nvim-lua/plenary.nvim',
-    -- 'nvim-tree/nvim-web-devicons', -- not strictly required, but recommended
-    'nvim-tree/nvim-web-devicons',
-    'MunifTanjim/nui.nvim',
-  },
-  opts = {
-    window = { -- see https://github.com/MunifTanjim/nui.nvim/tree/main/lua/nui/popup for
-      -- possible options. These can also be functions that return these options.
-      position = 'float', -- left, right, float, current
-      width = 40, -- applies to left and right positions
-      popup = { -- settings that apply to float position only
-        size = {
-          height = '80%',
-          width = '50%',
-        },
-        position = '50%', -- 50% means center it
-        -- you can also specify border here, if you want a different setting from
-        -- the global popup_border_style.
-      },
-      enable_git_status = false,
-      -- Mappings for tree window. See `:h nep-tree-mappings` for a list of built-in commands.
-      -- You can also create your own commands by providing a function instead of a string.
-      mappings = {
-        ['<space>'] = 'toggle_node',
-        ['<2-LeftMouse>'] = 'open',
-        ['<cr>'] = 'open',
-        ['s'] = 'open_split',
-        ['v'] = 'open_vsplit',
-        ['C'] = 'close_node',
-        ['z'] = 'close_all_nodes',
-        ['R'] = 'refresh',
-        ['a'] = 'add',
-        ['A'] = 'add_directory',
-        ['d'] = 'delete',
-        ['r'] = 'rename',
-        ['y'] = 'copy_to_clipboard',
-        ['x'] = 'cut_to_clipboard',
-        ['p'] = 'paste_from_clipboard',
-        ['c'] = 'copy', -- takes text input for destination
-        ['m'] = 'move', -- takes text input for destination
-        ['q'] = 'close_window',
-      },
-    },
-    filesystem = {
-      filtered_items = {
-        hide_dotfiles = false,
-        hide_gitignored = false,
-      },
-      hijack_netrw_behavior = 'disabled',
-    },
-    source_selector = {
-      winbar = true,
-      statusline = false
-    }
-  }
-}

lua/plugins/nvim-colorizer.lua

@@ -1,10 +0,0 @@
-return {
-  'NvChad/nvim-colorizer.lua',
-  config = true,
-  cmd = {
-    'ColorizerAttachToBuffer',
-    'ColorizerDetachFromBuffer',
-    'ColorizerReloadAllBuffers',
-    'ColorizerToggle'
-  }
-}

lua/plugins/nvim-highlight-colors.lua

@@ -0,0 +1,9 @@
+return {
+  'brenoprata10/nvim-highlight-colors',
+  config = true,
+  opts = {
+    render = 'background', -- or 'foreground' or 'virtual',
+    enable_named_colors = true,
+  },
+  cmd = { 'HighlightColors' },
+}

lua/plugins/nvim-lint.lua

@@ -0,0 +1,22 @@
+return {
+  'mfussenegger/nvim-lint',
+  config = function()
+    require('lint').linters_by_ft = {
+      cpp = { 'clangtidy' },
+    }
+    vim.api.nvim_create_autocmd({ 'BufWritePost' }, {
+      callback = function()
+        -- try_lint without arguments runs the linters defined in `linters_by_ft`
+        -- for the current filetype
+        require('lint').try_lint()
+
+        -- You can call `try_lint` with a linter name or a list of names to always
+        -- run specific linters, independent of the `linters_by_ft` configuration
+        -- require('lint').try_lint('cspell')
+      end,
+    })
+  end,
+  ft = {
+    'cpp',
+  },
+}

lua/plugins/nvim-rooter.lua

@@ -1,7 +1,8 @@
 return {
   'notjedi/nvim-rooter.lua',
   opts = {
-    rooter_patterns = { '.git',
+    rooter_patterns = {
+      '.git',
       '_darcs',
       '.hg',
       '.bzr',
@@ -10,6 +11,7 @@ return {
       'package.json',
       'build_nvim',
       'real_path.txt',
-      'conaninfo.txt' },
-  }
+      'conaninfo.txt',
+    },
+  },
 }

lua/plugins/nvim-surround.lua

@@ -1,10 +0,0 @@
-return {
-  'kylechui/nvim-surround',
-  version = '*',   -- Use for stability; omit to use `main` branch for the latest features
-  event = 'VeryLazy',
-  config = function()
-    require('nvim-surround').setup({
-      -- Configuration here, or leave empty to use defaults
-    })
-  end
-}

lua/plugins/nvim-ts-rainbow.lua

@@ -1,5 +0,0 @@
-return {
-  'p00f/nvim-ts-rainbow',
-  dependencies = 'nvim-treesitter/nvim-treesitter',
-  event = 'VeryLazy'
-}

lua/plugins/octo.lua

@@ -1,4 +0,0 @@
-return { 'pwntester/octo.nvim',
-  cmd = 'Octo',
-  config = true,
-}

lua/plugins/oil.lua

@@ -1,6 +1,13 @@
 return {
   'stevearc/oil.nvim',
   opts = {
+    delete_to_trash = true,
+    default_file_explorer = true,
+    skip_confirm_for_simple_edits = true,
+    view_options = {
+      -- Show files and directories that start with "."
+      show_hidden = true,
+    },
     keymaps = {
       ['g?'] = 'actions.show_help',
       ['<CR>'] = 'actions.select',
@@ -17,15 +24,13 @@ return {
       ['g.'] = 'actions.toggle_hidden',
     },
   },
-  -- Optional dependencies
+  lazy = false,
   dependencies = { 'nvim-tree/nvim-web-devicons' },
   keys = {
     {
       '-',
-      function()
-        require('oil').open()
-      end,
+      function() require('oil').open() end,
       desc = 'Open oil',
-    }
-  }
+    },
+  },
 }

lua/plugins/overseer.lua

@@ -2,18 +2,30 @@ return {
   'stevearc/overseer.nvim',
   config = function()
     require('overseer').setup({
-      templates = { 'builtin', 'user.cmake.cmake' },
+      templates = { 'builtin', 'user.cmake.cmake', 'user.clang.clang-tidy' },
     })
   end,
   keys = {
     {
       '<f4>',
-      function()
-        require('overseer').open()
-        require('overseer').run_template()
-      end,
+      function() require('overseer').run_template() end,
       mode = { 'n', 'x' },
       desc = 'Start task (overseer)',
     },
-  }
+  },
+  cmd = {
+    'OverseerOpen',
+    'OverseerClose',
+    'OverseerToggle',
+    'OverseerSaveBundle',
+    'OverseerLoadBundle',
+    'OverseerDeleteBundle',
+    'OverseerRunCmd',
+    'OverseerRun',
+    'OverseerInfo',
+    'OverseerBuild',
+    'OverseerQuickAction',
+    'OverseerTaskAction',
+    'OverseerClearCache',
+  },
 }

lua/plugins/project.lua

@@ -1,22 +0,0 @@
-return {
-  'ahmedkhalf/project.nvim',
-  config = function()
-    require('project_nvim').setup(
-      {
-        silent_chdir = true,
-        ignore_lsp = { 'null-ls', 'cmake', 'neocmake' },
-        patterns = { '.git', '_darcs', '.hg', '.bzr', '.svn', 'Makefile', 'package.json', 'build_nvim', 'real_path.txt',
-          'conaninfo.txt' },
-      })
-  end,
-  enabled = false,
-  keys = {
-    {
-      '<space>p',
-      function()
-        require('telescope').extensions.projects.projects()
-      end,
-      desc = 'Select project',
-    },
-  }
-}

lua/plugins/rainbow-delimiters.lua

@@ -0,0 +1,6 @@
+return {
+  'HiPhish/rainbow-delimiters.nvim',
+  dependencies = 'nvim-treesitter/nvim-treesitter',
+  event = 'VeryLazy',
+  version = false,
+}

lua/plugins/render-markdown.lua

@@ -0,0 +1,11 @@
+return {
+  'MeanderingProgrammer/render-markdown.nvim',
+  dependencies = { 'nvim-treesitter/nvim-treesitter', 'nvim-tree/nvim-web-devicons' }, -- if you prefer nvim-web-devicons
+  ---@module 'render-markdown'
+  ---@type render.md.UserConfig
+  opts = {
+    completions = { blink = { enabled = true } },
+    ft = { 'markdown', 'codecompanion', 'Avante' },
+  },
+  ft = { 'markdown', 'Avante' },
+}

lua/plugins/rustaceanvim.lua

@@ -0,0 +1,39 @@
+return {
+  'mrcjkb/rustaceanvim',
+  ft = { 'rust' },
+  config = function()
+    vim.g.rustaceanvim = {
+      server = {
+        on_attach = function(client, bufnr)
+          local options = { noremap = true, silent = false, buffer = bufnr }
+          vim.keymap.set('n', '<space>y', function() vim.cmd.RustLsp({ 'hover', 'actions' }) end, vim.tbl_extend('error', options, { desc = 'Hover' }))
+
+          local group = vim.api.nvim_create_augroup('lsp_document_highlight', { clear = false })
+          vim.api.nvim_create_autocmd({ 'CursorHold', 'CursorHoldI' }, {
+            callback = function() vim.lsp.buf.document_highlight() end,
+            buffer = bufnr,
+            group = group,
+            desc = 'Document Highlight',
+          })
+          vim.api.nvim_create_autocmd('CursorMoved', {
+            callback = function() vim.lsp.buf.clear_references() end,
+            buffer = bufnr,
+            group = group,
+            desc = 'Clear All the References',
+          })
+          vim.api.nvim_create_autocmd({ 'LspDetach' }, {
+            group = group,
+            buffer = bufnr,
+            callback = function()
+              vim.lsp.buf.clear_references()
+              vim.api.nvim_clear_autocmds({
+                group = group,
+                buffer = bufnr,
+              })
+            end,
+          })
+        end,
+      },
+    }
+  end,
+}

lua/plugins/snacks.lua

@@ -0,0 +1,132 @@
+return {
+  'folke/snacks.nvim',
+  priority = 1000,
+  version = false,
+  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 },
+    notifier = { enabled = false },
+    quickfile = { enabled = true },
+    statuscolumn = { enabled = true },
+    words = {
+      enabled = true,
+      modes = { 'n', 'c' },
+    },
+    indent = {
+      indent = {
+        only_scope = false,
+        only_current = false,
+      },
+      enabled = true,
+      animate = {
+        enabled = true,
+      },
+      scope = {
+        enabled = true,
+      },
+      chunk = {
+        enabled = true,
+        hl = 'Debug',
+      },
+    },
+    dashboard = {
+      sections = {
+        { section = 'header' },
+        { icon = ' ', title = 'Keymaps', section = 'keys', indent = 2, padding = 1 },
+        { icon = ' ', title = 'Recent Files', section = 'recent_files', indent = 2, padding = 1 },
+        { icon = ' ', title = 'Projects', section = 'projects', indent = 2, padding = 1 },
+        { section = 'startup' },
+      },
+    },
+    picker = {
+      matcher = {
+        frecency = true,
+        cwd_bonus = true,
+        filename_bonus = true,
+        history_bonus = true,
+      },
+      win = {
+        input = {
+          keys = {
+            ['<c-t>'] = { 'edit_tab', mode = { 'n', 'i' } },
+          },
+        },
+      },
+      formatters = {
+        file = {
+          truncate = 100,
+          filename_first = true,
+        },
+      },
+    },
+  },
+  keys = {
+    { '<space>g', function() Snacks.lazygit() end, desc = 'Lazygit' },
+    { '<space>gf', function() Snacks.lazygit.log_file() end, desc = 'Lazygit Current File History' },
+    { '<space>gl', function() Snacks.lazygit.log() end, desc = 'Lazygit Log (cwd)' },
+    { 'm', function() Snacks.words.jump(vim.v.count1) end, desc = 'Next Reference', mode = { 'n' } },
+    { '<S-m>', function() Snacks.words.jump(-vim.v.count1) end, desc = 'Prev Reference', mode = { 'n' } },
+    -- Top Pickers & Explorer
+    { '<leader><space>', function() Snacks.picker.smart() end, desc = 'Smart Find Files' },
+    { '<leader>b', function() Snacks.picker.buffers() end, desc = 'Buffers' },
+    { '<leader>l', function() Snacks.picker.grep() end, desc = 'Grep' },
+    { '<leader>:', function() Snacks.picker.command_history() end, desc = 'Command History' },
+    { '<leader>n', function() Snacks.picker.notifications() end, desc = 'Notification History' },
+    { '<leader>e', function() Snacks.explorer() end, desc = 'File Explorer' },
+    -- find
+    -- { "<leader>fb", function() Snacks.picker.buffers() end, desc = "Buffers" },
+    -- { "<leader>f", function() Snacks.picker.files({ cwd = vim.fn.stdpath("config") }) end, desc = "Find Config File" },
+    { '<leader>f', function() Snacks.picker.files() end, desc = 'Find Files' },
+    { '<leader>g', function() Snacks.picker.git_files() end, desc = 'Find Git Files' },
+    { '<space>p', function() Snacks.picker.projects() end, desc = 'Projects' },
+    { '<leader>o', function() Snacks.picker.recent() end, desc = 'Recent' },
+    { '<leader>i', function() Snacks.picker.recent({ filter = { cwd = true } }) end, desc = 'Recent in cwd' },
+    -- git
+    { '<leader>nb', function() Snacks.picker.git_branches() end, desc = 'Git Branches' },
+    { '<leader>nl', function() Snacks.picker.git_log() end, desc = 'Git Log' },
+    { '<leader>nL', function() Snacks.picker.git_log_line() end, desc = 'Git Log Line' },
+    { '<leader>ns', function() Snacks.picker.git_status() end, desc = 'Git Status' },
+    { '<leader>nS', function() Snacks.picker.git_stash() end, desc = 'Git Stash' },
+    { '<leader>nd', function() Snacks.picker.git_diff() end, desc = 'Git Diff (Hunks)' },
+    { '<leader>nf', function() Snacks.picker.git_log_file() end, desc = 'Git Log File' },
+    -- Grep
+    { '<leader>sb', function() Snacks.picker.lines() end, desc = 'Buffer Lines' },
+    { '<leader>sB', function() Snacks.picker.grep_buffers() end, desc = 'Grep Open Buffers' },
+    -- { "<leader>sg", function() Snacks.picker.grep() end, desc = "Grep" },
+    { '<leader>d', function() Snacks.picker.grep_word() end, desc = 'Visual selection or word', mode = { 'n', 'x' } },
+    -- search
+    -- { '<leader>s"', function() Snacks.picker.registers() end, desc = "Registers" },
+    -- { '<leader>s/', function() Snacks.picker.search_history() end, desc = "Search History" },
+    -- { "<leader>sa", function() Snacks.picker.autocmds() end, desc = "Autocmds" },
+    -- { "<leader>sb", function() Snacks.picker.lines() end, desc = "Buffer Lines" },
+    -- { "<leader>sc", function() Snacks.picker.command_history() end, desc = "Command History" },
+    -- { "<leader>sC", function() Snacks.picker.commands() end, desc = "Commands" },
+    { '<leader>v', function() Snacks.picker.diagnostics() end, desc = 'Diagnostics' },
+    { '<space>V', function() Snacks.picker.diagnostics_buffer() end, desc = 'Buffer Diagnostics' },
+    { '<leader>sh', function() Snacks.picker.help() end, desc = 'Help Pages' },
+    { '<leader>sH', function() Snacks.picker.highlights() end, desc = 'Highlights' },
+    { '<leader>si', function() Snacks.picker.icons() end, desc = 'Icons' },
+    { '<leader>j', function() Snacks.picker.jumps() end, desc = 'Jumps' },
+    { '<leader>sk', function() Snacks.picker.keymaps() end, desc = 'Keymaps' },
+    { '<leader>sl', function() Snacks.picker.loclist() end, desc = 'Location List' },
+    { '<leader>sm', function() Snacks.picker.marks() end, desc = 'Marks' },
+    { '<leader>sM', function() Snacks.picker.man() end, desc = 'Man Pages' },
+    { '<leader>sp', function() Snacks.picker.lazy() end, desc = 'Search for Plugin Spec' },
+    { '<leader>sq', function() Snacks.picker.qflist() end, desc = 'Quickfix List' },
+    { '<leader>sR', function() Snacks.picker.resume() end, desc = 'Resume' },
+    { '<leader>su', function() Snacks.picker.undo() end, desc = 'Undo History' },
+    -- { "<leader>uC", function() Snacks.picker.colorschemes() end, desc = "Colorschemes" },
+    -- LSP
+    { '<space>d', function() Snacks.picker.lsp_definitions() end, desc = 'Goto Definition' },
+    { '<space>D', function() Snacks.picker.lsp_declarations() end, desc = 'Goto Declaration' },
+    { '<space>r', function() Snacks.picker.lsp_references() end, nowait = true, desc = 'References' },
+    { '<space>I', function() Snacks.picker.lsp_implementations() end, desc = 'Goto Implementation' },
+    { '<space>e', function() Snacks.picker.lsp_type_definitions() end, desc = 'Goto T[y]pe Definition' },
+    { '<A-m>', function() Snacks.picker.lsp_symbols() end, desc = 'LSP Symbols' },
+    { '<leader>sS', function() Snacks.picker.lsp_workspace_symbols() end, desc = 'LSP Workspace Symbols' },
+  },
+}

lua/plugins/telescope.lua

@@ -1,203 +0,0 @@
-return {
-  'nvim-telescope/telescope.nvim',
-  dependencies = {
-    'nvim-lua/plenary.nvim',
-    'nvim-tree/nvim-web-devicons',
-    'molecule-man/telescope-menufacture',
-    {
-      'nvim-telescope/telescope-fzf-native.nvim',
-      build = {
-        'cmake -S. -Bbuild -DCMAKE_BUILD_TYPE=Release  -G Ninja', -- On windows add -DCMAKE_C_FLAGS="-target x86_64-w64-mingw32"
-        'cmake --build build --config Release',
-        'cmake --install build --prefix build'
-      },
-    },
-    'nvim-telescope/telescope-ui-select.nvim',
-    'ahmedkhalf/project.nvim',
-  },
-  cmd = { 'Telescope' },
-  keys = {
-    {
-      '<leader>f',
-      function()
-        require('telescope').extensions.menufacture.find_files({ no_ignore = true, hidden = true })
-      end,
-      desc = 'Find file',
-    },
-    {
-      '<leader>c',
-      function()
-        require('telescope.builtin').commands()
-      end,
-      desc = 'Telescope commands',
-    },
-    {
-      '<leader>g',
-      function()
-        Project_files()
-      end,
-      desc = 'Find git files',
-    },
-    {
-      '<leader>o',
-      function()
-        require('telescope.builtin').oldfiles()
-      end,
-      desc = 'Find old files',
-    },
-    {
-      '<leader>b',
-      function()
-        require('telescope.builtin').buffers()
-      end,
-      desc = 'Select buffer',
-    },
-    {
-      '<leader>q',
-      function()
-        require('telescope.builtin').quickfix()
-      end,
-      desc = 'Quickfix list with telescope',
-    },
-    {
-      '<leader>l',
-      function()
-        require('telescope').extensions.menufacture.live_grep()
-      end,
-      desc = 'Search in project',
-    },
-    {
-      '<leader>j',
-      function()
-        require('telescope.builtin').jumplist()
-      end,
-      desc = 'Open jumplist',
-    },
-    {
-      '<c-f>',
-      function()
-        require('telescope.builtin').current_buffer_fuzzy_find()
-      end,
-      desc = 'Find in buffer',
-    },
-    {
-      '<leader>d',
-      function()
-        require('telescope').extensions.menufacture.grep_string()
-      end,
-      desc = 'Find in workspace',
-    },
-  },
-  config = function()
-    local actions = require('telescope.actions')
-
-    local mappingTab = {
-      i = {
-        ['<cr>'] = actions.select_tab,
-        ['<C-b>'] = actions.select_default,
-      },
-    }
-
-    Project_files = function()
-      local opts = {} -- define here if you want to define something
-      local ok = pcall(require('telescope').extensions.menufacture.git_files, opts)
-      if not ok then require('telescope').extensions.menufacture.find_files(opts) end
-    end
-
-
-    local telescopeConfig = require('telescope.config')
-
-    -- Clone the default Telescope configuration
-    local vimgrep_arguments = { unpack(telescopeConfig.values.vimgrep_arguments) }
-
-    -- I want to search in hidden/dot files.
-    table.insert(vimgrep_arguments, '--hidden')
-    -- I don't want to search in the `.git` directory.
-    table.insert(vimgrep_arguments, '--glob')
-    table.insert(vimgrep_arguments, '!**/.git/*')
-
-    require('telescope').setup({
-      defaults = {
-        mappings = {
-          i = {
-            ['<cr>'] = actions.select_default + actions.center,
-            ['<C-l>'] = actions.send_selected_to_loclist,
-            ['<C-q>'] = actions.smart_send_to_qflist,
-          },
-        },
-        -- `hidden = true` is not supported in text grep commands.
-        vimgrep_arguments = vimgrep_arguments,
-      },
-      pickers = {
-        -- Your special builtin config goes in here
-        buffers                       = {
-          sort_lastused = false,
-          sort_mru = true,
-          ignore_current_buffer = true,
-          theme = 'ivy',
-          mappings = {
-            i = {
-              ['<c-w>'] = actions.delete_buffer,
-              ['<cr>'] = actions.select_default,
-            },
-            n = {
-              ['<c-w>'] = actions.delete_buffer,
-            },
-          },
-        },
-        find_files                    = {
-          theme = 'ivy',
-          previewer = false,
-          -- `hidden = true` will still show the inside of `.git/` as it's not `.gitignore`d.
-          find_command = { 'rg', '--files', '--hidden', '--glob', '!**/.git/*' },
-        },
-        oldfiles                      = {
-          theme = 'ivy',
-        },
-        git_files                     = {
-          theme = 'ivy',
-          previewer = false,
-        },
-        lsp_references                = {
-          show_line = false,
-          include_declaration = false,
-        },
-        lsp_dynamic_workspace_symbols = {
-          theme = 'ivy',
-          fname_width = 80,
-          symbol_width = 55,
-          symbol_type_width = 8,
-          ignore_symbols = { 'namespace' }
-        },
-        lsp_document_symbols          = {
-          theme = 'ivy',
-          fname_width = 80,
-          symbol_width = 85,
-          symbol_type_width = 8,
-          ignore_symbols = { 'namespace' }
-        },
-        lsp_workspace_symbols         = {
-          fname_width = 30,
-          symbol_width = 85,
-          symbol_type_width = 8,
-          ignore_symbols = { 'namespace' }
-        },
-      },
-      extensions = {
-        ['ui-select'] = {
-          require('telescope.themes').get_dropdown {
-          }
-        },
-        ['menufacture'] = {
-          mappings = {
-            main_menu = { [{ 'n' }] = 'm' },
-          },
-        },
-      }
-    })
-
-    require('telescope').load_extension('ui-select')
-    require('telescope').load_extension('fzf')
-    require('telescope').load_extension('menufacture')
-  end
-}

lua/plugins/todo-comments.lua

@@ -0,0 +1,9 @@
+return {
+  'folke/todo-comments.nvim',
+  dependencies = { 'nvim-lua/plenary.nvim' },
+  opts = {
+    -- your configuration comes here
+    -- or leave it empty to use the default settings
+    -- refer to the configuration section below
+  },
+}

lua/plugins/toggleterm.lua

@@ -3,7 +3,7 @@ return {
   config = function()
     function _G.set_terminal_keymaps(term)
       local opts = { noremap = true }
-      if (term.cmd ~= 'lazygit') then
+      if term.cmd ~= 'lazygit' then
         vim.api.nvim_buf_set_keymap(term.bufnr, 't', '<esc>', [[<C-\><C-n>]], opts)
       end
       vim.api.nvim_buf_set_keymap(term.bufnr, 't', 'jk', [[<C-\><C-n>]], opts)
@@ -14,11 +14,29 @@ return {
     end
 
     require('toggleterm').setup({
-      on_open = set_terminal_keymaps
+      on_open = set_terminal_keymaps,
     })
 
     local Terminal = require('toggleterm.terminal').Terminal
 
+    function _lazygit_toggle()
+      local lazygit = Terminal:new({
+        cmd = 'lazygit',
+        direction = 'float',
+        cwd = function() return vim.fn.getcwd() end,
+        float_opts = {
+          border = 'double',
+        },
+        -- function to run on opening the terminal
+        on_open = function(term)
+          vim.cmd('startinsert!')
+          vim.api.nvim_buf_set_keymap(term.bufnr, 'n', 'q', '<cmd>close<CR>', { noremap = true, silent = true })
+        end,
+        -- function to run on closing the terminal
+        on_close = function(term) vim.cmd('startinsert!') end,
+      })
+      lazygit:open()
+    end
   end,
   cmd = 'ToggleTerm',
 }

lua/plugins/treesitter.lua

@@ -1,49 +1,31 @@
-return {
-  'nvim-treesitter/nvim-treesitter',
-  build = ':TSUpdate',
-  config = function()
-    require('nvim-treesitter.configs').setup({
-      ensure_installed = 'all',
-      highlight = {
-        enable = true
-      },
-      rainbow = {
-        enable = true,
-        extended_mode = true, -- Also highlight non-bracket delimiters like html tags, boolean or table: lang -> boolean
-        max_file_lines = nil, -- Do not enable for files with more than n lines, int
-        -- colors = {}, -- table of hex strings
-        -- termcolors = {} -- table of colour name strings
-      },
-      indent = {
-        enable = false -- maybe buggy
-      },
-      textobjects = {
-        select = {
-          enable = true,
-
-          -- Automatically jump forward to textobj, similar to targets.vim
-          lookahead = true,
-
-          keymaps = {
-            -- You can use the capture groups defined in textobjects.scm
-            ['af'] = '@function.outer',
-            ['if'] = '@function.inner',
-            ['ac'] = '@class.outer',
-            ['ic'] = '@class.inner',
-          },
-        },
-        lsp_interop = {
-          enable = true,
-          border = 'none',
-          peek_definition_code = {
-            ['<leader>df'] = '@function.outer',
-            ['<leader>dF'] = '@class.outer',
-          },
-        },
-      },
-    })
-    local parser = require('nvim-treesitter.parsers').filetype_to_parsername
-    parser.groovy = 'java' -- the someft filetype will use the python parser and queries.
-    require('nvim-treesitter.install').prefer_git = true
-  end
-}
+return {
+  'nvim-treesitter/nvim-treesitter',
+  version = false,
+  build = ':TSUpdate',
+  config = function()
+    require('nvim-treesitter.install').compilers = { 'clang' }
+    require('nvim-treesitter.configs').setup({
+      ensure_installed = '',
+      modules = {},
+      sync_install = true,
+      auto_install = true,
+      ignore_install = {},
+      highlight = {
+        enable = true,
+        additional_vim_regex_highlighting = { 'markdown' },
+      },
+      rainbow = {
+        enable = true,
+        extended_mode = true, -- Also highlight non-bracket delimiters like html tags, boolean or table: lang -> boolean
+        max_file_lines = nil, -- Do not enable for files with more than n lines, int
+        -- colors = {}, -- table of hex strings
+        -- termcolors = {} -- table of colour name strings
+      },
+      indent = {
+        enable = false, -- maybe buggy
+      },
+    })
+    vim.treesitter.language.register('groovy', 'java')
+    require('nvim-treesitter.install').prefer_git = false
+  end,
+}

lua/plugins/which-key.lua

@@ -1,12 +1,13 @@
-return {
-  'folke/which-key.nvim',
-  opts = {
-    plugins = {
-      marks = false,
-      registers = false,
-      presets = {
-        operators = false
-      }
-    }
-  }
-}
+return {
+  'folke/which-key.nvim',
+  version = '*',
+  opts = {
+    plugins = {
+      marks = false,
+      registers = false,
+      presets = {
+        operators = false,
+      },
+    },
+  },
+}

lua/plugins/yanky.lua

@@ -0,0 +1,25 @@
+return {
+  'gbprod/yanky.nvim',
+  config = function()
+    require('yanky').setup({
+      ring = {
+        history_length = 100,
+        storage = 'shada',
+        sync_with_numbered_registers = true,
+        cancel_event = 'update',
+        ignore_registers = { '_' },
+        update_register_on_cycle = false,
+      },
+      system_clipboard = {
+        sync_with_ring = false,
+      },
+    })
+    vim.keymap.set({ 'n', 'x' }, 'p', '<Plug>(YankyPutAfter)')
+    vim.keymap.set({ 'n', 'x' }, 'P', '<Plug>(YankyPutBefore)')
+    vim.keymap.set({ 'n', 'x' }, 'gp', '<Plug>(YankyGPutAfter)')
+    vim.keymap.set({ 'n', 'x' }, 'gP', '<Plug>(YankyGPutBefore)')
+
+    vim.keymap.set('n', '<c-p>', '<Plug>(YankyPreviousEntry)')
+    vim.keymap.set('n', '<c-n>', '<Plug>(YankyNextEntry)')
+  end,
+}

lua/themes/astrodark.lua

@@ -0,0 +1,63 @@
+return {
+  'AstroNvim/astrotheme',
+  lazy = true,
+  priority = 1000,
+  config = function()
+    local C = require('astrotheme.palettes.astrodark')
+    require('astrotheme').setup({
+      palette = 'astrodark', -- String of the default palette to use when calling `:colorscheme astrotheme`
+
+      termguicolors = true, -- Bool value, toggles if termguicolors are set by AstroTheme.
+
+      terminal_color = true, -- Bool value, toggles if terminal_colors are set by AstroTheme.
+
+      plugin_default = 'auto', -- Sets how all plugins will be loaded
+      -- "auto": Uses lazy / packer enabled plugins to load highlights.
+      -- true: Enables all plugins highlights.
+      -- false: Disables all plugins.
+
+      plugins = { -- Allows for individual plugin overides using plugin name and value from above.
+        -- ['lualine'] = true,
+      },
+
+      palettes = {
+        global = {},
+        astrodark = {},
+      },
+      highlights = {
+        global = {
+          modify_hl_groups = function(hl, c) end,
+        },
+        astrodark = {
+          modify_hl_groups = function(hl, c) -- modify_hl_groups function allows you to modify hl groups,
+            hl.Type = { fg = c.Yellow }
+            hl.Comment = { italic = true }
+          end,
+          ['@lsp.mod.readonly'] = { bold = true },
+          ['@lsp.type.namespace.cpp'] = { fg = C.rb },
+          ['@lsp.type.variable'] = { fg = C.light_purple },
+          -- ['@lsp.type.variable'] = { link = '@variable' },
+          ['@variable'] = { fg = C.light_purple, link = '' },
+          -- ['Function'] = { fg = C.light_cyan },
+          ['@lsp.type.enumMember'] = { fg = C.cyan },
+          ['Comment'] = { italic = true },
+          ['Type'] = { fg = C.dark_orange },
+          ['Structure'] = { link = 'Type' },
+          ['Constant'] = { fg = 'NONE' },
+          ['@parameter'] = { fg = C.toml },
+          ['NormalFloat'] = { bg = C.surface0 },
+          ['TelescopeBorder'] = { bg = C.surface0 },
+          ['TelescopeNormal'] = { bg = C.surface0 },
+          ['TelescopePreviewBorder'] = { link = 'TelescopeBorder' },
+          ['TelescopeResultsBorder'] = { link = 'TelescopeResultsNormal' },
+          ['TelescopePreviewNormal'] = { bg = C.surface0 },
+          ['TelescopeTitle'] = { bg = C.surface0 },
+          ['TelescopePromptNormal'] = { bg = C.surface0 },
+          ['TelescopePromptBorder'] = { link = 'TelescopeBorder' },
+        },
+      },
+    })
+    vim.cmd('colorscheme astrodark')
+  end,
+  enabled = true,
+}

lua/themes/bamboo.lua

@@ -0,0 +1,82 @@
+return {
+  'ribru17/bamboo.nvim',
+  lazy = true,
+  -- priority = 1000,
+  config = function()
+    local colors = require('bamboo.palette')
+    require('bamboo').setup({
+      dim_inactive = false, -- Dim inactive windows/buffers
+      lualine = {
+        transparent = false, -- lualine center bar transparency
+      },
+      code_style = {
+        comments = { italic = false },
+        conditionals = { italic = false },
+        keywords = {},
+        functions = {},
+        namespaces = { italic = false },
+        parameters = { italic = false },
+        strings = {},
+        variables = {},
+      },
+      highlights = {
+        ['@lsp.type.comment'] = { link = '@comment', default = true },
+        ['@comment'] = { fg = colors.vulgaris.light_grey, default = true },
+        ['@lsp.type.parameter'] = { fg = colors.vulgaris.red },
+        ['@lsp.mod.readonly'] = { fmt = 'bold', fg = 'NONE' },
+        ['@lsp.typemod.parameter.readonly'] = { fmt = 'bold', fg = 'NONE' },
+        ['@lsp.typemod.method.defaultLibrary.cpp'] = { fg = 'NONE' },
+        ['@function.builtin'] = { fg = 'NONE' },
+        ['LspReferenceRead'] = { bg = colors.vulgaris.green, fg = colors.vulgaris.bg1, fmt = 'nocombine' },
+        ['LspReferenceWrite'] = { bg = colors.vulgaris.red, fg = colors.vulgaris.bg1, fmt = 'nocombine' },
+        ['LspReferenceText'] = { bg = colors.vulgaris.cyan, fg = colors.vulgaris.bg1, fmt = 'nocombine' },
+        -- ['NormalFloat'] = { bg = colors.vulgaris.bg3, fmt = 'nocombine' },
+        -- ['FloatBorder'] = { bg = colors.vulgaris.bg_d, fmt = 'nocombine' },
+        ['SnacksPickerList'] = { bg = colors.vulgaris.bg_d, fmt = 'nocombine' },
+        ['SnacksPickerListCursorLine'] = { bg = colors.vulgaris.bg3, fmt = 'nocombine' },
+        ['SnacksPickerPrompt'] = { bg = colors.vulgaris.bg_d, fmt = 'nocombine' },
+        ['SnacksPickerInput'] = { bg = colors.vulgaris.bg_d, fmt = 'nocombine' },
+        ['SnacksPickerPreview'] = { bg = colors.vulgaris.bg_d, fmt = 'nocombine' },
+        ['SnacksPickerInputBorder'] = { bg = colors.vulgaris.bg_d, fmt = 'nocombine' },
+        ['NonText'] = { fg = colors.vulgaris.blue },
+        ['BlinkCmpMenu'] = { bg = colors.vulgaris.bg2 },
+        ['BlinkCmpDoc'] = { bg = colors.vulgaris.bg2 },
+        ['CmpDocumentation'] = { bg = colors.vulgaris.bg2 },
+        ['BlinkCmpMenuSelection'] = { bg = colors.vulgaris.grey },
+        ['PmenuSel'] = { bg = '#282C34', fg = 'NONE' },
+        ['Pmenu'] = { fg = '#C5CDD9', bg = colors.vulgaris.bg3 },
+        ['CmpItemAbbrDeprecated'] = { fg = '#7E8294', bg = 'NONE', strikethrough = true },
+        ['CmpItemAbbrMatch'] = { fg = '#82AAFF', bg = 'NONE', bold = true },
+        ['CmpItemAbbrMatchFuzzy'] = { fg = '#82AAFF', bg = 'NONE', bold = true },
+        ['CmpItemMenu'] = { fg = '#C792EA', bg = 'NONE', italic = true },
+        ['CmpItemKindField'] = { fg = '#EED8DA', bg = '#B5585F' },
+        ['CmpItemKindProperty'] = { fg = '#EED8DA', bg = '#B5585F' },
+        ['CmpItemKindEvent'] = { fg = '#EED8DA', bg = '#B5585F' },
+        ['CmpItemKindText'] = { fg = '#C3E88D', bg = '#9FBD73' },
+        ['CmpItemKindEnum'] = { fg = '#C3E88D', bg = '#9FBD73' },
+        ['CmpItemKindKeyword'] = { fg = '#C3E88D', bg = '#9FBD73' },
+        ['CmpItemKindConstant'] = { fg = '#FFE082', bg = '#D4BB6C' },
+        ['CmpItemKindConstructor'] = { fg = '#FFE082', bg = '#D4BB6C' },
+        ['CmpItemKindReference'] = { fg = '#FFE082', bg = '#D4BB6C' },
+        ['CmpItemKindFunction'] = { fg = '#EADFF0', bg = '#A377BF' },
+        ['CmpItemKindStruct'] = { fg = '#EADFF0', bg = '#A377BF' },
+        ['CmpItemKindClass'] = { fg = '#EADFF0', bg = '#A377BF' },
+        ['CmpItemKindModule'] = { fg = '#EADFF0', bg = '#A377BF' },
+        ['CmpItemKindOperator'] = { fg = '#EADFF0', bg = '#A377BF' },
+        ['CmpItemKindVariable'] = { fg = '#C5CDD9', bg = '#7E8294' },
+        ['CmpItemKindFile'] = { fg = '#C5CDD9', bg = '#7E8294' },
+        ['CmpItemKindUnit'] = { fg = '#F5EBD9', bg = '#D4A959' },
+        ['CmpItemKindSnippet'] = { fg = '#F5EBD9', bg = '#D4A959' },
+        ['CmpItemKindFolder'] = { fg = '#F5EBD9', bg = '#D4A959' },
+        ['CmpItemKindMethod'] = { fg = '#DDE5F5', bg = '#6C8ED4' },
+        ['CmpItemKindValue'] = { fg = '#DDE5F5', bg = '#6C8ED4' },
+        ['CmpItemKindEnumMember'] = { fg = '#DDE5F5', bg = '#6C8ED4' },
+        ['CmpItemKindInterface'] = { fg = '#D8EEEB', bg = '#58B5A8' },
+        ['CmpItemKindColor'] = { fg = '#D8EEEB', bg = '#58B5A8' },
+        ['CmpItemKindTypeParameter'] = { fg = '#D8EEEB', bg = '#58B5A8' },
+      },
+    })
+    require('bamboo').load()
+  end,
+  enabled = false,
+}

lua/themes/everforest.lua

@@ -0,0 +1,15 @@
+return {
+  'neanias/everforest-nvim',
+  version = false,
+  lazy = true,
+  priority = 1000, -- make sure to load this before all the other start plugins
+  -- Optional; default configuration will be used if setup isn't called.
+  config = function()
+    require('everforest').setup({
+      background = 'hard',
+      -- Your config here
+    })
+    require('everforest').load()
+  end,
+  enabled = true,
+}

lua/themes/github-theme.lua

@@ -0,0 +1,42 @@
+return {
+  'projekt0n/github-nvim-theme',
+  lazy = false, -- make sure we load this during startup if it is your main colorscheme
+  priority = 1000, -- make sure to load this before all the other start plugins
+  config = function()
+    require('github-theme').setup({
+      options = {
+        dim_inactive = true,
+        modules = {
+          'cmp',
+          -- 'coc',
+          -- 'coc_explorer',
+          'dapui',
+          -- 'diffchar',
+          -- 'dashboard',
+          'diagnostic',
+          -- 'fidget',
+          -- 'fzf',
+          'gitgutter',
+          'gitsigns',
+          'indent_blankline',
+          'lsp_semantic_tokens',
+          -- 'lsp_trouble',
+          -- 'mini',
+          'native_lsp',
+          'neogit',
+          'neotree',
+          -- 'notify',
+          -- 'nvimtree',
+          'telescope',
+          'treesitter',
+          'treesitter_context',
+          'whichkey',
+        },
+      },
+    })
+
+    -- vim.cmd('colorscheme github_dark')
+    vim.cmd('colorscheme github_dark_dimmed')
+  end,
+  enabled = false,
+}

lua/themes/gruvbox-baby.lua

@@ -0,0 +1,7 @@
+return {
+  'luisiacc/gruvbox-baby',
+  lazy = true,
+  priority = 1000, -- make sure to load this before all the other start plugins
+  config = function() vim.cmd('colorscheme gruvbox-baby') end,
+  enabled = true,
+}

lua/themes/gruvbox.lua

@@ -1,8 +1,10 @@
 return {
   'ellisonleao/gruvbox.nvim',
   priority = 1000,
+  lazy = true,
+  branch = 'main',
   config = function()
-    local colors = require('gruvbox.palette').colors
+    -- local colors = require('gruvbox.palette').colors
 
     require('gruvbox').setup({
       undercurl = true,
@@ -21,7 +23,7 @@ return {
       invert_intend_guides = false,
       palette_overrides = {},
       overrides = {
-        ['@lsp.type.parameter'] = { fg = colors.faded_purple },
+        -- ['@lsp.type.parameter'] = { fg = colors.faded_purple },
         ['@lsp.type.function'] = { fg = '#797df2' },
         ['@lsp.type.method'] = { fg = '#797df2' },
         ['@lsp.mod.readonly'] = { bold = true },
@@ -29,7 +31,7 @@ return {
       dim_inactive = true,
       transparent_mode = false,
     })
-    -- vim.cmd('colorscheme gruvbox')
+    vim.cmd('colorscheme gruvbox')
   end,
-  enabled = true
+  enabled = true,
 }

lua/themes/gruvbox_flat.lua

@@ -1,19 +1,19 @@
-return {
-  'eddyekofo94/gruvbox-flat.nvim',
-  priority = 1000,
-  config = function()
-    local colors = require('gruvbox.colors')
-    vim.g.gruvbox_flat_style = 'dark'
-    vim.g.gruvbox_colors = {
-      bg_search = 'purple',
-      fg_search = 'black',
-    }
-    vim.g.gruvbox_theme = {
-      Pmenu = { bg = 'bg_visual' },
-      NormalFloat = { bg = 'bg_visual' }
-    }
-    vim.g.gruvbox_dark_float = false
-    vim.cmd('colorscheme gruvbox-flat')
-  end,
-  enabled = false
-}
+return {
+  'eddyekofo94/gruvbox-flat.nvim',
+  priority = 1000,
+  config = function()
+    local colors = require('gruvbox.colors')
+    vim.g.gruvbox_flat_style = 'dark'
+    vim.g.gruvbox_colors = {
+      bg_search = 'purple',
+      fg_search = 'black',
+    }
+    vim.g.gruvbox_theme = {
+      Pmenu = { bg = 'bg_visual' },
+      NormalFloat = { bg = 'bg_visual' },
+    }
+    vim.g.gruvbox_dark_float = false
+    vim.cmd('colorscheme gruvbox-flat')
+  end,
+  enabled = false,
+}

lua/themes/gruvbox_material.lua

@@ -1,42 +1,42 @@
-return {
-  'sainnhe/gruvbox-material',
-  priority = 1000,
-  config = function()
-    -- local colors = require('gruvbox.colors')
-    -- vim.g.gruvbox_flat_style = "dark"
-    -- vim.g.gruvbox_colors = {
-    --   bg_search = 'purple',
-    --   fg_search = 'black',
-    -- }
-    -- vim.g.gruvbox_theme = {
-    --   Pmenu = { bg = 'bg_visual' },
-    --   NormalFloat = { bg = 'bg_visual' }
-    -- }
-    -- vim.g.gruvbox_dark_float = false
-    vim.g.gruvbox_material_ui_contrast = 'high'
-    vim.g.gruvbox_material_dim_inactive_windows = 1 -- Dim inactive windows. Only works in neovim currently.
-    vim.g.gruvbox_material_disable_terminal_colors = 0
-    local links = {
-      ['@lsp.type.namespace'] = '@namespace',
-      ['@lsp.type.type'] = '@type',
-      ['@lsp.type.class'] = '@type',
-      ['@lsp.type.enum'] = '@type',
-      ['@lsp.type.interface'] = '@type',
-      ['@lsp.type.struct'] = '@structure',
-      ['@lsp.type.parameter'] = '@parameter',
-      ['@lsp.type.variable'] = '@variable',
-      ['@lsp.type.property'] = '@property',
-      ['@lsp.type.enumMember'] = '@constant',
-      ['@lsp.type.function'] = '@function',
-      ['@lsp.type.method'] = '@method',
-      ['@lsp.type.macro'] = '@macro',
-      ['@lsp.type.decorator'] = '@function',
-    }
-    -- for newgroup, oldgroup in pairs(links) do
-    --   vim.api.nvim_set_hl(0, newgroup, { link = oldgroup, default = true })
-    -- end
-    vim.cmd('colorscheme gruvbox-material')
-    vim.api.nvim_set_hl(0, '@lsp.mod.readonly', { italic = true, fg = 'Purple' })
-  end,
-  enabled = false
-}
+return {
+  'sainnhe/gruvbox-material',
+  priority = 1000,
+  config = function()
+    -- local colors = require('gruvbox.colors')
+    -- vim.g.gruvbox_flat_style = "dark"
+    -- vim.g.gruvbox_colors = {
+    --   bg_search = 'purple',
+    --   fg_search = 'black',
+    -- }
+    -- vim.g.gruvbox_theme = {
+    --   Pmenu = { bg = 'bg_visual' },
+    --   NormalFloat = { bg = 'bg_visual' }
+    -- }
+    -- vim.g.gruvbox_dark_float = false
+    vim.g.gruvbox_material_ui_contrast = 'high'
+    vim.g.gruvbox_material_dim_inactive_windows = 1 -- Dim inactive windows. Only works in neovim currently.
+    vim.g.gruvbox_material_disable_terminal_colors = 0
+    local links = {
+      ['@lsp.type.namespace'] = '@namespace',
+      ['@lsp.type.type'] = '@type',
+      ['@lsp.type.class'] = '@type',
+      ['@lsp.type.enum'] = '@type',
+      ['@lsp.type.interface'] = '@type',
+      ['@lsp.type.struct'] = '@structure',
+      ['@lsp.type.parameter'] = '@parameter',
+      ['@lsp.type.variable'] = '@variable',
+      ['@lsp.type.property'] = '@property',
+      ['@lsp.type.enumMember'] = '@constant',
+      ['@lsp.type.function'] = '@function',
+      ['@lsp.type.method'] = '@method',
+      ['@lsp.type.macro'] = '@macro',
+      ['@lsp.type.decorator'] = '@function',
+    }
+    -- for newgroup, oldgroup in pairs(links) do
+    --   vim.api.nvim_set_hl(0, newgroup, { link = oldgroup, default = true })
+    -- end
+    vim.cmd('colorscheme gruvbox-material')
+    vim.api.nvim_set_hl(0, '@lsp.mod.readonly', { italic = true, fg = 'Purple' })
+  end,
+  enabled = false,
+}

lua/themes/kanagawa.lua

@@ -0,0 +1,40 @@
+return {
+  'rebelot/kanagawa.nvim',
+  lazy = false,
+  priority = 1000,
+  config = function()
+    require('kanagawa').setup({
+      compile = false, -- enable compiling the colorscheme
+      undercurl = true, -- enable undercurls
+      commentStyle = { italic = true },
+      functionStyle = {},
+      keywordStyle = { italic = true },
+      statementStyle = { bold = true },
+      typeStyle = {},
+      transparent = false, -- do not set background color
+      dimInactive = false, -- dim inactive window `:h hl-NormalNC`
+      terminalColors = true, -- define vim.g.terminal_color_{0,17}
+      colors = {
+        -- add/modify theme and palette colors
+        palette = {},
+        theme = { wave = {}, lotus = {}, dragon = {}, all = {} },
+      },
+      overrides = function(colors) -- add/modify highlights
+        return {
+          ['@lsp.mod.readonly'] = { bold = true },
+          ['@lsp.mod.static'] = { italic = true },
+          ['LspReferenceRead'] = { bg = colors.palette.lotusGreen, fg = colors.palette.dragonBlack0 },
+          ['LspReferenceWrite'] = { bg = colors.palette.samuraiRed, fg = colors.palette.dragonBlack0 },
+        }
+      end,
+      theme = 'wave', -- Load "wave" theme when 'background' option is not set
+      background = {
+        -- map the value of 'background' option to a theme
+        dark = 'wave', -- try "dragon" !
+        light = 'lotus',
+      },
+    })
+    require('kanagawa').load('wave')
+  end,
+  enabled = true,
+}

lua/themes/material.lua

@@ -2,7 +2,7 @@ return {
   'marko-cerovac/material.nvim',
   priority = 1000,
   config = function()
-    local colors = require 'material.colors'
+    local colors = require('material.colors')
     require('material').setup({
 
       contrast = {
@@ -15,10 +15,14 @@ return {
       },
 
       styles = { -- Give comments style such as bold, italic, underline etc.
-        comments = { --[[ italic = true ]] },
-        strings = { --[[ bold = true ]] },
-        keywords = { --[[ underline = true ]] },
-        functions = { --[[ bold = true, undercurl = true ]] },
+        comments = { --[[ italic = true ]]
+        },
+        strings = { --[[ bold = true ]]
+        },
+        keywords = { --[[ underline = true ]]
+        },
+        functions = { --[[ bold = true, undercurl = true ]]
+        },
         variables = {},
         operators = {},
         types = {},
@@ -26,23 +30,23 @@ return {
 
       plugins = { -- Uncomment the plugins that you use to highlight them
         -- Available plugins:
-        "dap",
+        'dap',
         -- "dashboard",
-        "gitsigns",
+        'gitsigns',
         -- "hop",
-        "indent-blankline",
+        'indent-blankline',
         -- "lspsaga",
         -- "mini",
         -- "neogit",
         -- "neorg",
-        "nvim-cmp",
-        "nvim-navic",
+        'nvim-cmp',
+        'nvim-navic',
         -- "nvim-tree",
-        "nvim-web-devicons",
+        'nvim-web-devicons',
         -- "sneak",
-        "telescope",
+        'telescope',
         -- "trouble",
-        "which-key",
+        'which-key',
       },
 
       disable = {
@@ -50,12 +54,12 @@ return {
         borders = false, -- Disable borders between verticaly split windows
         background = false, -- Prevent the theme from setting the background (NeoVim then uses your terminal background)
         term_colors = false, -- Prevent the theme from setting terminal colors
-        eob_lines = false -- Hide the end-of-buffer lines
+        eob_lines = false, -- Hide the end-of-buffer lines
       },
 
       high_visibility = {
         lighter = false, -- Enable higher contrast text for lighter style
-        darker = true-- Enable higher contrast text for darker style
+        darker = true, -- Enable higher contrast text for darker style
       },
 
       lualine_style = 'default', -- Lualine style ( can be 'stealth' or 'default' )
@@ -66,8 +70,8 @@ return {
 
       custom_highlights = {}, -- Overwrite highlights with your own
     })
-    vim.g.material_style = "darker"
+    vim.g.material_style = 'darker'
     vim.cmd('colorscheme material')
   end,
-  enabled = false
+  enabled = false,
 }

lua/themes/monokai-pro.lua

@@ -1,5 +1,6 @@
 return {
   'loctvl842/monokai-pro.nvim',
+  lazy = true,
   config = function()
     require('monokai-pro').setup({
       -- filter = 'spectrum'
@@ -42,9 +43,9 @@ return {
           -- ["@lsp.typemod.interface"] = {},
           -- ["@lsp.typemod.macro"] = {},
           -- ["@lsp.typemod.method"] = {},
-          ["@lsp.typemod.namespace"] = { fg = c.base.red },
+          ['@lsp.typemod.namespace'] = { fg = c.base.red },
           -- ['@lsp.typemod.parameter.declaration'] = { fg = c.base.blue, italic = styles.parameter.italic },
-          ["@lsp.typemod.property"] = { fg = '#9699f2' },
+          ['@lsp.typemod.property'] = { fg = '#9699f2' },
           -- ["@lsp.typemod.struct"] = {},
           -- ["@lsp.typemod.type"] = {},
           -- ["@lsp.typemod.typeParameter"] = {},
@@ -58,5 +59,6 @@ return {
       end,
     })
     vim.cmd('colorscheme monokai-pro')
-  end
+  end,
+  enabled = true,
 }

lua/utils/json_workaround.lua

@@ -0,0 +1,53 @@
+local M = {}
+local function str_splice(string, start_idx, end_idx)
+  local new_content = string:sub(1, start_idx - 1)
+  if end_idx then
+    return new_content .. string:sub(end_idx + 1)
+  else
+    return new_content
+  end
+end
+
+local function str_rfind(string, idx, needle)
+  for i = idx, 1, -1 do
+    if string:sub(i, i - 1 + needle:len()) == needle then
+      return i
+    end
+  end
+end
+local function get_to_line_end(string, idx)
+  local newline = string:find('\n', idx, true)
+  local to_end = newline and string:sub(idx, newline - 1) or string:sub(idx)
+  return to_end, newline
+end
+
+M.decode_json = function(content)
+  local ok, data = pcall(vim.json.decode, content, { luanil = { object = true } })
+  while not ok do
+    local char = data:match('invalid token at character (%d+)$')
+    if char then
+      local to_end, newline = get_to_line_end(content, char)
+      if to_end:match('^//') then
+        content = str_splice(content, char, newline)
+        goto continue
+      end
+    end
+
+    char = data:match('Expected object key string but found [^%s]+ at character (%d+)$')
+    char = char or data:match('Expected value but found T_ARR_END at character (%d+)')
+    if char then
+      local comma_idx = str_rfind(content, char, ',')
+      if comma_idx then
+        content = str_splice(content, comma_idx, comma_idx)
+        goto continue
+      end
+    end
+
+    error(data)
+    ::continue::
+    ok, data = pcall(vim.json.decode, content, { luanil = { object = true } })
+  end
+  return data
+end
+
+return M

lua/utils/python_venv.lua

@@ -62,14 +62,14 @@ function M.getPythonEnvs()
   if venv ~= nil then
     table.insert(venvs, {
       name = 'VIRTUAL_ENV',
-      path = string.format('%s/%s', venv, M.getVenvSuffix())
+      path = string.format('%s/%s', venv, M.getVenvSuffix()),
     })
   end
   local conda = os.getenv('CONDA_PREFIX')
   if conda ~= nil then
     table.insert(venvs, {
       name = 'CONDA_PREFIX',
-      path = string.format('%s/%s', conda, 'python.exe')
+      path = string.format('%s/%s', conda, 'python.exe'),
     })
   end
 
@@ -79,7 +79,7 @@ function M.getPythonEnvs()
   if jsonVenv ~= nil then
     table.insert(venvs, {
       name = 'pyrightconfig.json',
-      path = jsonVenv .. '/' .. M.getVenvSuffix()
+      path = jsonVenv .. '/' .. M.getVenvSuffix(),
     })
   end
 
@@ -88,20 +88,20 @@ function M.getPythonEnvs()
     if vim.fn.executable(cwd .. '/' .. envDir .. '/' .. M.getVenvSuffix()) == 1 then
       table.insert(venvs, {
         name = envDir,
-        path = cwd .. '/' .. envDir .. '/' .. M.getVenvSuffix()
+        path = cwd .. '/' .. envDir .. '/' .. M.getVenvSuffix(),
       })
     end
   end
   if vim.loop.os_uname().sysname == 'Linux' then
     table.insert(venvs, {
       name = 'system',
-      path = '/usr/bin/python'
+      path = '/usr/bin/python',
     })
   end
   if vim.loop.os_uname().sysname == 'Windows_NT' then
     table.insert(venvs, {
       name = 'system',
-      path = os.getenv('SCOOP') .. '/apps/python/current/python.exe'
+      path = os.getenv('SCOOP') .. '/apps/python/current/python.exe',
     })
   end
   return venvs

pyproject.toml

@@ -14,3 +14,6 @@ analyzeUnannotatedFunctions = 'false'
 executionEnvironments = [
   { root = "./" }
 ]
+
+[tool.black]
+line-length=120

readme.md

@@ -0,0 +1,9 @@
+# pre-commit
+
+Install with
+
+```bash
+pre-commit install
+```
+
+`stylua` has to be installed in the system

snapshots/stable.json

@@ -1 +0,0 @@
-{"litee.nvim": {"commit": "de1a3d6"}, "nvim-dap": {"commit": "f4a3be5"}, "telescope-fzf-native.nvim": {"commit": "6a33ece"}, "packer.nvim": {"commit": "d268d2e"}, "tabout.nvim": {"commit": "be655cc"}, "nvim-lspconfig": {"commit": "b9c375c"}, "command-center.nvim": {"commit": "baaf831"}, "nvim-cmp": {"commit": "9897465"}, "clangd_extensions.nvim": {"commit": "81b56d4"}, "cmp-emoji": {"commit": "19075c3"}, "null-ls.nvim": {"commit": "a2b7bf8"}, "lualine.nvim": {"commit": "5113cdb"}, "cmp-cmdline": {"commit": "c36ca4b"}, "nvim-treesitter-textobjects": {"commit": "c8a393e"}, "cmp-nvim-lsp": {"commit": "affe808"}, "cmp_luasnip": {"commit": "a9de941"}, "friendly-snippets": {"commit": "15ecafe"}, "gitsigns.nvim": {"commit": "4883988"}, "dressing.nvim": {"commit": "af17983"}, "indent-blankline.nvim": {"commit": "4a58fe6"}, "lspkind-nvim": {"commit": "57e5b5d"}, "neo-tree.nvim": {"commit": "8613c45"}, "cmp-nvim-lsp-signature-help": {"commit": "007dd27"}, "cmp-look": {"commit": "b39c50b"}, "telescope.nvim": {"commit": "6ea1063"}, "litee-calltree.nvim": {"commit": "71f7eee"}, "lsp_signature.nvim": {"commit": "9c51678"}, "Comment.nvim": {"commit": "4086630"}, "cmp-spell": {"commit": "5602f1a"}, "yanky.nvim": {"commit": "521b94d"}, "gruvbox.nvim": {"commit": "79419f9"}, "gh.nvim": {"commit": "cdf177c"}, "aerial.nvim": {"commit": "bd6de88"}, "neovim-cmake": {"commit": "d0ffe31"}, "nvim-autopairs": {"commit": "4a95b39"}, "LuaSnip": {"commit": "295cc9e"}, "popup.nvim": {"commit": "b7404d3"}, "litee-symboltree.nvim": {"commit": "8f13d50"}, "nvim-web-devicons": {"commit": "8d2c533"}, "nvim-treesitter": {"commit": "cf6d84b"}, "nui.nvim": {"commit": "4af402d"}, "nvim-terminal": {"commit": "e058de4"}, "cmp-treesitter": {"commit": "c2886bb"}, "neogen": {"commit": "c5a0c39"}, "nvim-lsp-installer": {"commit": "12e7c06"}, "cmp-calc": {"commit": "f7efc20"}, "toggleterm.nvim": {"commit": "04174e1"}, "plenary.nvim": {"commit": "46e8bb9"}, "project.nvim": {"commit": "541115e"}, "cmp-nvim-lua": {"commit": "d276254"}, "nvim-ts-rainbow": {"commit": "837167f"}, "cmp-path": {"commit": "981baf9"}, "cmp-buffer": {"commit": "62fc67a"}}

snapshots/working.json

@@ -1 +0,0 @@
-{"litee.nvim": {"commit": "d346001"}, "nvim-dap": {"commit": "66d33b7"}, "telescope-fzf-native.nvim": {"commit": "6a33ece"}, "packer.nvim": {"commit": "afab895"}, "nvim-lspconfig": {"commit": "a78831f"}, "command-center.nvim": {"commit": "31468fd"}, "clangd_extensions.nvim": {"commit": "2390bf7"}, "nvim-dap-virtual-text": {"commit": "2971ce3"}, "null-ls.nvim": {"commit": "53622ed"}, "mason-lspconfig.nvim": {"commit": "3cbd87f"}, "lualine.nvim": {"commit": "4b5048a"}, "cmp-cmdline": {"commit": "9c0e331"}, "hlargs.nvim": {"commit": "f603d88"}, "aerial.nvim": {"commit": "1abd19b"}, "nvim-autopairs": {"commit": "ca89ab9"}, "cmp_luasnip": {"commit": "a9de941"}, "friendly-snippets": {"commit": "7339def"}, "leap.nvim": {"commit": "b9bc061"}, "gitsigns.nvim": {"commit": "1e107c9"}, "dressing.nvim": {"commit": "d886a1b"}, "indent-blankline.nvim": {"commit": "c15bbe9"}, "lspkind-nvim": {"commit": "57e5b5d"}, "neo-tree.nvim": {"commit": "a922c3a"}, "cmp-nvim-lsp-signature-help": {"commit": "57c4db7"}, "cmp-look": {"commit": "b39c50b"}, "telescope.nvim": {"commit": "4725867"}, "litee-calltree.nvim": {"commit": "7779988"}, "lsp_signature.nvim": {"commit": "4665921"}, "Comment.nvim": {"commit": "fe9bbdb"}, "cmp-spell": {"commit": "5602f1a"}, "yanky.nvim": {"commit": "d55f095"}, "mason.nvim": {"commit": "6171213"}, "gh.nvim": {"commit": "a675ce6"}, "nvim-treesitter-textobjects": {"commit": "b8df8b0"}, "neovim-cmake": {"commit": "338fd2a"}, "cmp-nvim-lsp": {"commit": "affe808"}, "LuaSnip": {"commit": "c599c56"}, "nvim-dap-ui": {"commit": "225115a"}, "popup.nvim": {"commit": "b7404d3"}, "litee-symboltree.nvim": {"commit": "426d4db"}, "nvim-web-devicons": {"commit": "2d02a56"}, "vim-repeat": {"commit": "24afe92"}, "cmp-dap": {"commit": "e21f0e5"}, "nvim-treesitter": {"commit": "501db14"}, "nui.nvim": {"commit": "9531977"}, "nvim-terminal": {"commit": "e058de4"}, "gruvbox-baby": {"commit": "a7dd15a"}, "cmp-emoji": {"commit": "19075c3"}, "cmp-treesitter": {"commit": "c2886bb"}, "neogen": {"commit": "c5a0c39"}, "project.nvim": {"commit": "090bb11"}, "cmp-calc": {"commit": "f7efc20"}, "nvim-dap-python": {"commit": "86d2636"}, "toggleterm.nvim": {"commit": "dfce846"}, "plenary.nvim": {"commit": "31807ee"}, "nvim-cmp": {"commit": "b588569"}, "telescope-dap.nvim": {"commit": "b4134ff"}, "cmp-path": {"commit": "447c87c"}, "nvim-ts-rainbow": {"commit": "d16220f"}, "cmp-nvim-lua": {"commit": "d276254"}, "cmp-buffer": {"commit": "62fc67a"}}