Fix error tabbing

lua/autocmd.lua

@@ -51,32 +51,6 @@ vim.api.nvim_create_autocmd('User', {
     end,
 })
 
-local fidget_group = vim.api.nvim_create_augroup('CodeCompanionFidgetHooks', { clear = true })
-
-vim.api.nvim_create_autocmd({ 'User' }, {
-    pattern = 'CodeCompanionRequestStarted',
-    group = fidget_group,
-    callback = function(event)
-        local FidgetHelper = require 'utils.fidget_helper'
-        -- Pass event instead of request if the callback receives the full event object
-        local handle = FidgetHelper:create_progress_handle(event)
-        FidgetHelper:store_progress_handle(event.data.id, handle)
-    end,
-})
-
-vim.api.nvim_create_autocmd({ 'User' }, {
-    pattern = 'CodeCompanionRequestFinished',
-    group = fidget_group,
-    callback = function(event)
-        local FidgetHelper = require 'utils.fidget_helper'
-        local handle = FidgetHelper:pop_progress_handle(event.data.id)
-        if handle then
-            FidgetHelper:report_exit_status(handle, event)
-            handle:finish()
-        end
-    end,
-})
-
 -- vim.api.nvim_create_autocmd('BufEnter', {
 --     callback = function(event)
 --         local windows = vim.api.nvim_list_wins()
@@ -128,8 +102,8 @@ vim.api.nvim_create_autocmd('BufWritePost', {
 -- Run shortcuts script when saving shortcut files
 vim.api.nvim_create_autocmd('BufWritePost', {
     pattern = {
-        os.getenv 'XDG_CONFIG_HOME' .. '/shell/bm-files',
+        (os.getenv 'XDG_CONFIG_HOME' or (os.getenv 'HOME' .. '/.config')) .. '/shell/bm-files',
-        os.getenv 'XDG_CONFIG_HOME' .. '/shell/bm-dirs',
+        (os.getenv 'XDG_CONFIG_HOME' or (os.getenv 'HOME' .. '/.config')) .. '/shell/bm-dirs',
     },
     desc = 'Run shortcuts script',
     callback = function()
@@ -153,6 +127,13 @@ local configs = {
         track_untracked = false,
         force_add = false,
     },
+    {
+        path = os.getenv 'HOME' .. '/Notes',
+        worktree = nil,
+        git_dir = nil,
+        track_untracked = true,
+        force_add = false,
+    },
     {
         path = os.getenv 'HOME',
         worktree = os.getenv 'HOME',

lua/keymap.lua

@@ -1,22 +1,22 @@
 -- Basic Keymaps
 -- See `:help vim.keymap.set()`
 
-local helpers = require 'helpers'
+local helpers = require("helpers")
 
 -- Swap : and ; around
-vim.keymap.set({ 'n', 'v' }, ':', ';')
+vim.keymap.set({ "n", "v" }, ":", ";")
-vim.keymap.set({ 'n', 'v' }, ';', ':')
+vim.keymap.set({ "n", "v" }, ";", ":")
 
 -- Clear highlights on search when pressing <Esc> in normal mode
 --  See `:help hlsearch`
-vim.keymap.set('n', '<Esc>', '<cmd>nohlsearch<CR>')
+vim.keymap.set("n", "<Esc>", "<cmd>nohlsearch<CR>")
 
 -- Diagnostic keymaps
-vim.keymap.set('n', '<leader>q', vim.diagnostic.setloclist, { desc = 'Open diagnostic [Q]uickfix list' })
+vim.keymap.set("n", "<leader>q", vim.diagnostic.setloclist, { desc = "Open diagnostic [Q]uickfix list" })
 
-vim.keymap.set({ 'n', 'v' }, 'c', '"zc', { desc = 'Change without copying to clipboard' })
+vim.keymap.set({ "n", "v" }, "c", '"zc', { desc = "Change without copying to clipboard" })
-vim.keymap.set({ 'n', 'v' }, 'x', '"zx', { desc = 'Cut without copying to clipboard' })
+vim.keymap.set({ "n", "v" }, "x", '"zx', { desc = "Cut without copying to clipboard" })
-vim.keymap.set('v', 'p', '"zdP', { desc = 'Paste over selection without yanking replaced text' })
+vim.keymap.set("v", "p", '"zdP', { desc = "Paste over selection without yanking replaced text" })
 
 -- Exit terminal mode in the builtin terminal with a shortcut that is a bit easier
 -- for people to discover. Otherwise, you normally need to press <C-\><C-n>, which
@@ -24,21 +24,21 @@ vim.keymap.set('v', 'p', '"zdP', { desc = 'Paste over selection without yanking
 --
 -- NOTE: This won't work in all terminal emulators/tmux/etc. Try your own mapping
 -- or just use <C-\><C-n> to exit terminal mode
-vim.keymap.set('t', '<Esc><Esc>', '<C-\\><C-n>', { desc = 'Exit terminal mode' })
+vim.keymap.set("t", "<Esc><Esc>", "<C-\\><C-n>", { desc = "Exit terminal mode" })
 
-vim.keymap.set('n', '<Leader>z', function()
+vim.keymap.set("n", "<Leader>z", function()
 	vim.treesitter.inspect_tree()
-end, { desc = 'Treesitter' })
+end, { desc = "Treesitter" })
 
-vim.keymap.set('n', '<C-S-D>', function()
+vim.keymap.set("n", "<C-S-D>", function()
-    local node = vim.treesitter.get_node {}
+	local node = vim.treesitter.get_node({})
 	local range = { vim.treesitter.get_node_range(node) }
 	vim.api.nvim_win_set_cursor(0, { range[3] + 1, range[4] - 1 })
 	vim.fn.setpos("'x", { 0, range[1] + 1, range[2] + 1, 0 })
-    vim.cmd.normal 'v`x'
+	vim.cmd.normal("v`x")
-end, { desc = 'Select surrounding treesitter node' })
+end, { desc = "Select surrounding treesitter node" })
 
-vim.keymap.set('v', '<C-S-D>', function()
+vim.keymap.set("v", "<C-S-D>", function()
 	local start = vim.api.nvim_win_get_cursor(0)
 	local start_row, start_column
 	if start[2] == 0 then
@@ -49,24 +49,36 @@ vim.keymap.set('v', '<C-S-D>', function()
 		start_column = start[2] - 1
 	end
 	vim.api.nvim_win_set_cursor(0, { start_row, start_column })
-    local node = vim.treesitter.get_node {}
+	local node = vim.treesitter.get_node({})
 	local range = { vim.treesitter.get_node_range(node) }
 	vim.api.nvim_win_set_cursor(0, { range[3] + 1, range[4] - 1 })
 	vim.fn.setpos("'x", { 0, range[1] + 1, range[2] + 1, 0 })
-    vim.cmd.normal 'i'
+	vim.cmd.normal("i")
-    vim.cmd.normal 'v`x'
+	vim.cmd.normal("v`x")
-end, { desc = 'Select surrounding treesitter node' })
+end, { desc = "Select surrounding treesitter node" })
 
-local swappable_nodes = { 'argument', 'array_element_initializer', 'simple_parameter', 'string', 'integer', 'member_call_expression', 'method_declaration' }
+local swappable_nodes = {
+	"argument",
+	"array_element_initializer",
+	"simple_parameter",
+	"string",
+	"integer",
+	"member_call_expression",
+	"method_declaration",
+}
 
 local function closest_swappable_node(node)
-    while node and not vim.list_contains(swappable_nodes, node:type()) and (not node:next_named_sibling() or not node:prev_named_sibling()) do
+	while
+		node
+		and not vim.list_contains(swappable_nodes, node:type())
+		and (not node:next_named_sibling() or not node:prev_named_sibling())
+	do
 		node = node:parent()
 	end
 	return node
 end
 
-vim.keymap.set({ 'n' }, '<C-S-h>', function()
+vim.keymap.set({ "n" }, "<C-S-h>", function()
 	local node = closest_swappable_node(vim.treesitter.get_node())
 	if not node then
 		return
@@ -78,9 +90,9 @@ vim.keymap.set({ 'n' }, '<C-S-h>', function()
 	if prev_node == nil then
 		return
 	end
-    require('nvim-treesitter.ts_utils').swap_nodes(node, prev_node, 0, true)
+	require("nvim-treesitter.ts_utils").swap_nodes(node, prev_node, 0, true)
-end, { desc = 'Swap with node to the left' })
+end, { desc = "Swap with node to the left" })
-vim.keymap.set({ 'n' }, '<C-S-l>', function()
+vim.keymap.set({ "n" }, "<C-S-l>", function()
 	local node = closest_swappable_node(vim.treesitter.get_node())
 	if not node then
 		return
@@ -92,12 +104,12 @@ vim.keymap.set({ 'n' }, '<C-S-l>', function()
 	if next_node == nil then
 		return
 	end
-    require('nvim-treesitter.ts_utils').swap_nodes(node, next_node, 0, true)
+	require("nvim-treesitter.ts_utils").swap_nodes(node, next_node, 0, true)
-end, { desc = 'Swap with node to the right' })
+end, { desc = "Swap with node to the right" })
-vim.keymap.set('n', '<C-S-j>', 'ddp', { desc = 'Move line down' })
+vim.keymap.set("n", "<C-S-j>", "ddp", { desc = "Move line down" })
-vim.keymap.set('n', '<C-S-k>', 'ddkP', { desc = 'Move line up' })
+vim.keymap.set("n", "<C-S-k>", "ddkP", { desc = "Move line up" })
-vim.keymap.set('v', '<C-S-j>', 'do<Esc>p`[v`]', { desc = 'Move selection down' })
+vim.keymap.set("v", "<C-S-j>", "do<Esc>p`[v`]", { desc = "Move selection down" })
-vim.keymap.set('v', '<C-S-k>', 'dkO<Esc>p`[v`]', { desc = 'Move selection up' })
+vim.keymap.set("v", "<C-S-k>", "dkO<Esc>p`[v`]", { desc = "Move selection up" })
 
 -- Keybinds to make split navigation easier.
 --  Use CTRL+<hjkl> to switch between windows
@@ -106,97 +118,112 @@ vim.keymap.set('v', '<C-S-k>', 'dkO<Esc>p`[v`]', { desc = 'Move selection up' })
 local function win_or_treesj(dir_cmd, desc)
 	return function()
 		local cur = vim.api.nvim_get_current_win()
-        vim.cmd('wincmd ' .. dir_cmd)
+		vim.cmd("wincmd " .. dir_cmd)
 		if vim.api.nvim_get_current_win() == cur then
-            local ok, treesj = pcall(require, 'treesj')
+			local ok, treesj = pcall(require, "treesj")
-            if ok and type(treesj.toggle) == 'function' then
+			if ok and type(treesj.toggle) == "function" then
 				treesj.toggle()
 			end
 		end
 	end, { desc = desc }
 end
 
-vim.keymap.set('n', '<C-h>', '<C-w><C-h>', { desc = 'Move focus to the left window' })
+vim.keymap.set("n", "<C-h>", "<C-w><C-h>", { desc = "Move focus to the left window" })
-vim.keymap.set('n', '<C-l>', '<C-w><C-l>', { desc = 'Move focus to the right window' })
+vim.keymap.set("n", "<C-l>", "<C-w><C-l>", { desc = "Move focus to the right window" })
-vim.keymap.set('n', '<C-j>', (win_or_treesj)('j', 'Move focus to the lower window or treesj.toggle()'))
+vim.keymap.set("n", "<C-j>", (win_or_treesj)("j", "Move focus to the lower window or treesj.toggle()"))
-vim.keymap.set('n', '<C-k>', (win_or_treesj)('k', 'Move focus to the upper window or treesj.toggle()'))
+vim.keymap.set("n", "<C-k>", (win_or_treesj)("k", "Move focus to the upper window or treesj.toggle()"))
 
-vim.keymap.set('t', '<C-h>', '<C-\\><C-n><C-w>h', { desc = 'Move focus to the left window' })
+vim.keymap.set("t", "<C-h>", "<C-\\><C-n><C-w>h", { desc = "Move focus to the left window" })
-vim.keymap.set('t', '<C-l>', '<C-\\><C-n><C-w>l', { desc = 'Move focus to the right window' })
+vim.keymap.set("t", "<C-l>", "<C-\\><C-n><C-w>l", { desc = "Move focus to the right window" })
-vim.keymap.set('t', '<C-j>', '<C-\\><C-n><C-w>j', { desc = 'Move focus to the lower window' })
+vim.keymap.set("t", "<C-j>", "<C-\\><C-n><C-w>j", { desc = "Move focus to the lower window" })
-vim.keymap.set('t', '<C-k>', '<C-\\><C-n><C-w>k', { desc = 'Move focus to the upper window' })
+vim.keymap.set("t", "<C-k>", "<C-\\><C-n><C-w>k", { desc = "Move focus to the upper window" })
 
-vim.keymap.set({ 'i' }, '<C-J>', function()
+vim.keymap.set({ "i" }, "<C-J>", function()
-    local ls = require 'luasnip'
+	local ls = require("luasnip")
 	if ls.choice_active() then
 		ls.change_choice(1)
 	end
-end, { desc = 'Toggle snippet choice', silent = true })
+end, { desc = "Toggle snippet choice", silent = true })
-vim.keymap.set({ 'i' }, '<C-k>', function()
+vim.keymap.set({ "i" }, "<C-k>", function()
-    local ls = require 'luasnip'
+	local ls = require("luasnip")
 	if ls.choice_active() then
 		ls.change_choice(-1)
 	end
-end, { desc = 'Toggle snippet choice', silent = true })
+end, { desc = "Toggle snippet choice", silent = true })
-vim.keymap.set({ 'i', 's' }, '<C-L>', function()
+vim.keymap.set({ "i", "s" }, "<C-L>", function()
-    local ls = require 'luasnip'
+	local ls = require("luasnip")
 	if ls.expandable() then
 		ls.expand()
 	elseif ls.in_snippet() then
 		ls.jump(1)
 	end
-end, { desc = 'Expand snippet', silent = true })
+end, { desc = "Expand snippet", silent = true })
-vim.keymap.set({ 'i', 's' }, '<C-H>', function()
+vim.keymap.set({ "i", "s" }, "<C-H>", function()
-    local ls = require 'luasnip'
+	local ls = require("luasnip")
 	if ls.in_snippet() then
 		ls.jump(-1)
 	end
-end, { desc = 'Go back a snippet slot', silent = true })
+end, { desc = "Go back a snippet slot", silent = true })
 
-vim.keymap.set('n', '<Leader>.', '<Cmd>tabnext<CR>', { desc = 'Next tab' })
+vim.keymap.set("n", "<Leader>.", "<Cmd>tabnext<CR>", { desc = "Next tab" })
-vim.keymap.set('n', '<Leader>,', '<Cmd>tabprevious<CR>', { desc = 'Previous tab' })
+vim.keymap.set("n", "<Leader>,", "<Cmd>tabprevious<CR>", { desc = "Previous tab" })
 
 -- Overriding CTRL mappings because some of them are stupid
-vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-S-B>', '<CMD>Git blame<CR>', { desc = 'Git blame' })
+vim.keymap.set({ "n", "v", "c", "i" }, "<C-S-B>", "<CMD>Git blame<CR>", { desc = "Git blame" })
-vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-Q>', '<CMD>Telescope lsp_document_symbols<CR>', { desc = 'Show symbols in current document' })
+vim.keymap.set(
-vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-S-Q>', '<CMD>Telescope lsp_workspace_symbols<CR>', { desc = 'Show symbols in workspace' })
+	{ "n", "v", "c", "i" },
-vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-E>', '<CMD>Telescope oldfiles<CR>', { desc = 'Show recently opened files' })
+	"<C-Q>",
-vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-P>', function()
+	"<CMD>Telescope lsp_document_symbols<CR>",
-    require('telescope.builtin').find_files {
+	{ desc = "Show symbols in current document" }
+)
+vim.keymap.set(
+	{ "n", "v", "c", "i" },
+	"<C-S-Q>",
+	"<CMD>Telescope lsp_workspace_symbols<CR>",
+	{ desc = "Show symbols in workspace" }
+)
+vim.keymap.set({ "n", "v", "c", "i" }, "<C-E>", "<CMD>Telescope oldfiles<CR>", { desc = "Show recently opened files" })
+vim.keymap.set({ "n", "v", "c", "i" }, "<C-P>", function()
+	require("telescope.builtin").find_files({
 		show_untracked = true,
 		no_ignore = false,
 		hidden = true,
-    }
+	})
-end, { desc = 'Find all files' })
+end, { desc = "Find all files" })
-vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-S-P>', function()
+vim.keymap.set({ "n", "v", "c", "i" }, "<C-S-P>", function()
-    require('telescope.builtin').find_files {
+	require("telescope.builtin").find_files({
 		show_untracked = true,
 		no_ignore = true,
 		hidden = true,
-    }
+	})
-end, { desc = 'Find all files' })
+end, { desc = "Find all files" })
-vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-f>', function()
+vim.keymap.set({ "n", "v", "c", "i" }, "<C-f>", function()
-    require('telescope.builtin').live_grep {
+	require("telescope.builtin").live_grep({
 		hidden = true,
-    }
+	})
-end, { desc = 'Search within the whole project' })
+end, { desc = "Search within the whole project" })
-vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-Y>', '<CMD>Telescope quickfix<CR>', { desc = 'Show quickfix list' })
+vim.keymap.set({ "n", "v", "c", "i" }, "<C-Y>", "<CMD>Telescope quickfix<CR>", { desc = "Show quickfix list" })
-vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-S-Y>', '<CMD>Telescope quickfixhistory<CR>', { desc = 'Show quickfix history' })
+vim.keymap.set(
-vim.keymap.set({ 'n', 'v', 'c', 'i', 't' }, '<C-A>', function()
+	{ "n", "v", "c", "i" },
-    local ai_tools = { 'codex', 'agy', 'opencode' }
+	"<C-S-Y>",
+	"<CMD>Telescope quickfixhistory<CR>",
+	{ desc = "Show quickfix history" }
+)
+vim.keymap.set({ "n", "v", "c", "i", "t" }, "<C-A>", function()
+	local ai_tools = { "codex", "agy", "opencode" }
 	local ai_win_opts = {
 		width = math.floor(vim.o.columns / 3),
 		vertical = true,
-        split = 'right',
+		split = "right",
 	}
 
 	local term_bufnr = -1
 	for _, bufnr in ipairs(vim.api.nvim_list_bufs()) do
-        if vim.bo[bufnr].buftype == 'terminal' then
+		if vim.bo[bufnr].buftype == "terminal" then
 			local name = vim.api.nvim_buf_get_name(bufnr)
 
 			for _, tool in ipairs(ai_tools) do
-                if name:match(':' .. tool .. '$') or name:match('/' .. tool .. '$') then
+				if name:match(":" .. tool .. "$") or name:match("/" .. tool .. "$") then
 					term_bufnr = bufnr
 				end
 			end
@@ -216,66 +243,99 @@ vim.keymap.set({ 'n', 'v', 'c', 'i', 't' }, '<C-A>', function()
 	end
 	for _, tool in ipairs(ai_tools) do
 		if vim.fn.executable(tool) == 1 then
-            helpers.open_term {
+			helpers.open_term({
 				cmd = tool,
 				win_opts = ai_win_opts,
 				buf_opts = {
-                    bufhidden = 'hide',
+					bufhidden = "hide",
 					modifiable = false,
 				},
-            }
+			})
 			return
 		end
 	end
-    vim.api.nvim_echo({ { 'No AI tool found. Please install one of the following: codex, agy, opencode', 'WarningMsg' } }, false, {})
+	vim.api.nvim_echo(
-end, { desc = 'Toggle AI tool' })
+		{ { "No AI tool found. Please install one of the following: codex, agy, opencode", "WarningMsg" } },
+		false,
+		{}
+	)
+end, { desc = "Toggle AI tool" })
 -- vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-A>', '<CMD>vsplit term://codex<CR>i', { desc = 'Open AI tool' })
-vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-S>', function()
+vim.keymap.set({ "n", "v", "c", "i" }, "<C-S>", function()
-    require('snacks').scratch()
+	require("snacks").scratch()
-end, { desc = 'Open scratchpad' })
+end, { desc = "Open scratchpad" })
-vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-S-S>', function()
+vim.keymap.set({ "n", "v", "c", "i" }, "<C-S-S>", function()
-    require('snacks').scratch.select()
+	require("snacks").scratch.select()
-end, { desc = 'Open scratchpad buffers' })
+end, { desc = "Open scratchpad buffers" })
-vim.keymap.set({ 'n', 'v', 'c', 'i', 't' }, '<C-T>', function()
+vim.keymap.set({ "n", "v", "c", "i", "t" }, "<C-T>", function()
-    require('snacks').terminal.toggle()
+	require("snacks").terminal.toggle()
-end, { desc = 'Toggle terminal' })
+end, { desc = "Toggle terminal" })
-vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-N>', '<Esc>', { desc = 'Enter normal mode' })
+vim.keymap.set({ "n", "v", "c", "i" }, "<C-N>", "<Esc>", { desc = "Enter normal mode" })
-vim.keymap.set({ 't' }, '<C-N>', '<C-\\><C-N>', { desc = 'Enter normal mode' })
+vim.keymap.set({ "t" }, "<C-N>", "<C-\\><C-N>", { desc = "Enter normal mode" })
-vim.keymap.set({ 't' }, '<C-U>', '<C-\\><C-N><C-U>', { desc = 'Scroll up in terminal' })
+vim.keymap.set({ "t" }, "<C-U>", "<C-\\><C-N><C-U>", { desc = "Scroll up in terminal" })
-vim.keymap.set({ 't' }, '<C-D>', '<C-\\><C-N><C-D>', { desc = 'Scroll down in terminal' })
+vim.keymap.set({ "t" }, "<C-D>", "<C-\\><C-N><C-D>", { desc = "Scroll down in terminal" })
 
 -- Editing helpers
-vim.keymap.set('i', '<C-O>', '<Esc>o', { desc = 'Add line below' })
+vim.keymap.set("i", "<C-O>", "<Esc>o", { desc = "Add line below" })
-vim.keymap.set('i', '<C-S-O>', '<Esc>O', { desc = 'Add line above' })
+vim.keymap.set("i", "<C-S-O>", "<Esc>O", { desc = "Add line above" })
-local esc_keys = { 'jj', 'jk', 'kk' }
+local esc_keys = { "jj", "jk", "kk" }
 for _, key in ipairs(esc_keys) do
-    vim.keymap.set('i', key, '<Esc>', { desc = 'Exit insert mode' })
+	vim.keymap.set("i", key, "<Esc>", { desc = "Exit insert mode" })
 end
-vim.keymap.set('i', '<C-D>', '<Esc>ddi', { desc = 'Delete line' })
+vim.keymap.set("i", "<C-D>", "<Esc>ddi", { desc = "Delete line" })
-vim.keymap.set('i', '<Leader>;', '<Esc>mzA;<Esc>`za', { desc = 'Append a semicolon' })
+vim.keymap.set("i", "<Leader>;", "<Esc>mzA;<Esc>`za", { desc = "Append a semicolon" })
-vim.keymap.set('n', '<Leader>;', 'mzA;<Esc>`za', { desc = 'Append a semicolon' })
+vim.keymap.set("n", "<Leader>;", "mzA;<Esc>`za", { desc = "Append a semicolon" })
-vim.keymap.set('n', '<Leader>{', 'mzF[`a<CR><Esc>``%i<CR><Esc>`z', { desc = 'Indent an array' })
+vim.keymap.set("n", "<Leader>{", "mzF[`a<CR><Esc>``%i<CR><Esc>`z", { desc = "Indent an array" })
-vim.keymap.set('n', '<Leader>}', 'mzF[`a<CR><Esc>``%i<CR><Esc>`zvi[:s/,\\s*/,\\r/g<CR>vi[=<Esc>`z:nohlsearch<CR>', { desc = 'Indent an array some other way?' })
+vim.keymap.set(
+	"n",
+	"<Leader>}",
+	"mzF[`a<CR><Esc>``%i<CR><Esc>`zvi[:s/,\\s*/,\\r/g<CR>vi[=<Esc>`z:nohlsearch<CR>",
+	{ desc = "Indent an array some other way?" }
+)
 
 -- Git mappings
-vim.keymap.set('n', '<Leader>gb', '<CMD>Git blame<CR>', { desc = 'Git blame' })
+vim.keymap.set("n", "<Leader>gb", "<CMD>Git blame<CR>", { desc = "Git blame" })
-vim.keymap.set('n', '<Leader>gd', '<CMD>Git diff<CR>', { desc = 'Git diff' })
+vim.keymap.set("n", "<Leader>gd", "<CMD>Git diff<CR>", { desc = "Git diff" })
-vim.keymap.set('n', '<Leader>gdc', '<CMD>Git diff --cached<CR>', { desc = 'Git diff' })
+vim.keymap.set("n", "<Leader>gdc", "<CMD>Git diff --cached<CR>", { desc = "Git diff" })
-vim.keymap.set('n', '<Leader>G', function()
+vim.keymap.set("n", "<Leader>G", function()
-    helpers.open_term { cmd = 'lazygit' }
+	helpers.open_term({ cmd = "lazygit" })
-end, { desc = 'Git' })
+end, { desc = "Git" })
 
 -- Add keymaps for diff mode
-vim.api.nvim_create_autocmd('BufEnter', {
+vim.api.nvim_create_autocmd("BufEnter", {
 	callback = function()
 		if vim.wo.diff then
 			-- Keymaps for navigating hunks
-            vim.api.nvim_buf_set_keymap(0, 'n', '<Tab>', ']c', { noremap = true, silent = true, desc = 'Next hunk in diff mode' })
+			vim.api.nvim_buf_set_keymap(
-            vim.api.nvim_buf_set_keymap(0, 'n', '<S-Tab>', '[c', { noremap = true, silent = true, desc = 'Previous hunk in diff mode' })
+				0,
+				"n",
+				"<Tab>",
+				"]c",
+				{ noremap = true, silent = true, desc = "Next hunk in diff mode" }
+			)
+			vim.api.nvim_buf_set_keymap(
+				0,
+				"n",
+				"<S-Tab>",
+				"[c",
+				{ noremap = true, silent = true, desc = "Previous hunk in diff mode" }
+			)
 
 			-- Keymaps for resolving conflicts
-            vim.api.nvim_buf_set_keymap(0, 'n', '<leader>dl', ':diffget LOCAL<CR>', { noremap = true, silent = true, desc = 'Get LOCAL changes' })
+			vim.api.nvim_buf_set_keymap(
-            vim.api.nvim_buf_set_keymap(0, 'n', '<leader>dr', ':diffget REMOTE<CR>', { noremap = true, silent = true, desc = 'Get REMOTE changes' })
+				0,
+				"n",
+				"<leader>dl",
+				":diffget LOCAL<CR>",
+				{ noremap = true, silent = true, desc = "Get LOCAL changes" }
+			)
+			vim.api.nvim_buf_set_keymap(
+				0,
+				"n",
+				"<leader>dr",
+				":diffget REMOTE<CR>",
+				{ noremap = true, silent = true, desc = "Get REMOTE changes" }
+			)
 		end
 	end,
 })
@@ -283,91 +343,106 @@ vim.api.nvim_create_autocmd('BufEnter', {
 -- AI mappings
 -- vim.keymap.set('v', '<Leader>ae', '<CMD>CodeCompanion<CR>', { desc = 'Edit selection with AI' })
 -- vim.keymap.set('n', '<Leader>ac', '<CMD>CodeCompanionCmd<CR>', { desc = 'Run Neovim commands with AI' })
-vim.api.nvim_create_autocmd('FileType', {
+vim.api.nvim_create_autocmd("FileType", {
-    pattern = 'codecompanion',
+	pattern = "codecompanion",
 	callback = function()
-        vim.keymap.set('i', '<Enter>', function()
+		vim.keymap.set("i", "<Enter>", function()
-            require('codecompanion').last_chat():submit()
+			require("codecompanion").last_chat():submit()
-        end, { buffer = true, desc = 'Use enter to send the message' })
+		end, { buffer = true, desc = "Use enter to send the message" })
-        vim.keymap.set('i', '<S-Enter>', '<Enter>', { buffer = true, desc = 'Use shift enter to start a new line' })
+		vim.keymap.set("i", "<S-Enter>", "<Enter>", { buffer = true, desc = "Use shift enter to start a new line" })
-        vim.keymap.set('n', '<Enter>', 'G', { buffer = true, desc = 'Use enter in normal mode to go to the end of the chat' })
+		vim.keymap.set(
+			"n",
+			"<Enter>",
+			"G",
+			{ buffer = true, desc = "Use enter in normal mode to go to the end of the chat" }
+		)
 
 		local models = { vim.env.DEFAULT_AI_MODEL, vim.env.REASONING_MODEL, vim.env.FAST_MODEL }
 		-- Loop through models and create keymaps for each
 		for i, model in ipairs(models) do
-            vim.keymap.set('n', '<C-' .. i .. '>', 'mzggj0W"_C' .. model .. '<Esc>`z', { desc = 'Switch to ' .. model })
+			vim.keymap.set("n", "<C-" .. i .. ">", 'mzggj0W"_C' .. model .. "<Esc>`z", { desc = "Switch to " .. model })
-            vim.keymap.set('i', '<C-' .. i .. '>', '<Esc>mzggj0W"_C' .. model .. '<Esc>`za', { desc = 'Switch to ' .. model })
+			vim.keymap.set(
+				"i",
+				"<C-" .. i .. ">",
+				'<Esc>mzggj0W"_C' .. model .. "<Esc>`za",
+				{ desc = "Switch to " .. model }
+			)
 		end
 	end,
 })
 
 -- Search mappings
-vim.keymap.set('n', '<Leader>sGb', '<CMD>Telescope git_branches<CR>', { desc = 'Search git branches' })
+vim.keymap.set("n", "<Leader>sGb", "<CMD>Telescope git_branches<CR>", { desc = "Search git branches" })
-vim.keymap.set('n', '<Leader>sGc', '<CMD>Telescope git_commits<CR>', { desc = 'Search git history' })
+vim.keymap.set("n", "<Leader>sGc", "<CMD>Telescope git_commits<CR>", { desc = "Search git history" })
-vim.keymap.set('n', '<Leader>sGh', '<CMD>Telescope git_bcommits<CR>', { desc = 'Search git history within current buffer/selection' })
+vim.keymap.set(
-vim.keymap.set('n', '<Leader>sGs', '<CMD>Telescope git_status<CR>', { desc = 'Search git status' })
+	"n",
-vim.keymap.set('n', '<Leader>sGS', '<CMD>Telescope git_stash<CR>', { desc = 'Search git stash' })
+	"<Leader>sGh",
+	"<CMD>Telescope git_bcommits<CR>",
+	{ desc = "Search git history within current buffer/selection" }
+)
+vim.keymap.set("n", "<Leader>sGs", "<CMD>Telescope git_status<CR>", { desc = "Search git status" })
+vim.keymap.set("n", "<Leader>sGS", "<CMD>Telescope git_stash<CR>", { desc = "Search git stash" })
 
 -- Misc
-vim.keymap.set('n', '<Leader>]', '<CMD>cnext<CR>', { desc = 'Next item in quickfix list' })
+vim.keymap.set("n", "<Leader>]", "<CMD>cnext<CR>", { desc = "Next item in quickfix list" })
-vim.keymap.set('n', '<Leader>[', '<CMD>cprevious<CR>', { desc = 'Previous item in quickfix list' })
+vim.keymap.set("n", "<Leader>[", "<CMD>cprevious<CR>", { desc = "Previous item in quickfix list" })
-vim.keymap.set('n', 'gd', '<CMD>Telescope lsp_definitions<CR>', { desc = 'Go to definition' })
+vim.keymap.set("n", "gd", "<CMD>Telescope lsp_definitions<CR>", { desc = "Go to definition" })
-vim.keymap.set('n', '<Leader>r', function()
+vim.keymap.set("n", "<Leader>r", function()
-    for _, c in ipairs(vim.lsp.get_clients { bufnr = 0 }) do
+	for _, c in ipairs(vim.lsp.get_clients({ bufnr = 0 })) do
-        if c.name == 'phpantom_lsp' then
+		if c.name == "phpantom_lsp" then
 			c:stop(true)
 		end
 	end
-    vim.cmd 'edit'
+	vim.cmd("edit")
-end, { desc = 'Reload buffer' })
+end, { desc = "Reload buffer" })
 
 local function open_test()
-    require('neotest').summary.open()
+	require("neotest").summary.open()
-    require('neotest').output_panel.open()
+	require("neotest").output_panel.open()
 end
 -- Testing
 local test_maps = {
 	{
-        keys = { '<Leader>tc' },
+		keys = { "<Leader>tc" },
 		action = function()
-            require('neotest').summary.close()
+			require("neotest").summary.close()
-            require('neotest').output_panel.close()
+			require("neotest").output_panel.close()
 		end,
-        desc = 'Close [T]est panels',
+		desc = "Close [T]est panels",
 	},
 	{
-        keys = { '<Leader>tn' },
+		keys = { "<Leader>tn" },
 		action = function()
-            require('neotest').run.run()
+			require("neotest").run.run()
 			open_test()
 		end,
-        desc = 'Run nearest [T]est',
+		desc = "Run nearest [T]est",
 	},
 	{
-        keys = { '<Leader>ta' },
+		keys = { "<Leader>ta" },
 		action = function()
-            require('neotest').run.run { suite = true }
+			require("neotest").run.run({ suite = true })
 			open_test()
 		end,
-        desc = 'Run all [T]ests in the project',
+		desc = "Run all [T]ests in the project",
 	},
 	{
-        keys = { '<Leader>tp' },
+		keys = { "<Leader>tp" },
 		action = function()
-            require('neotest').run.run_last()
+			require("neotest").run.run_last()
 			open_test()
 		end,
-        desc = 'Run previous [T]est again',
+		desc = "Run previous [T]est again",
 	},
 	{
-        keys = { '<Leader>td' },
+		keys = { "<Leader>td" },
 		action = function()
-            local dap = require 'dap'
+			local dap = require("dap")
 			if dap.session() == nil then
 				dap.continue()
 			end
-            require('dapui').open()
+			require("dapui").open()
-            local neotest = require 'neotest'
+			local neotest = require("neotest")
 			local bufnr = vim.api.nvim_get_current_buf()
 			local row = vim.api.nvim_win_get_cursor(0)[1] - 1
 
@@ -378,8 +453,8 @@ local test_maps = {
 			for _, adapter_id in ipairs(adapters) do
 				local tree = neotest.state.positions(adapter_id, { buffer = bufnr })
 				if tree then
-                    local nearest = require('neotest.lib.positions').nearest(tree, row)
+					local nearest = require("neotest.lib.positions").nearest(tree, row)
-                    if nearest and nearest:data().type ~= 'file' then
+					if nearest and nearest:data().type ~= "file" then
 						neotest.run.run()
 						found = true
 						break
@@ -392,33 +467,34 @@ local test_maps = {
 			end
 			vim.g.neotest_debug = nil
 		end,
-        desc = 'Run last [T]est with debugger',
+		desc = "Run last [T]est with debugger",
 	},
 }
 
 for _, map_info in ipairs(test_maps) do
 	for _, key in ipairs(map_info.keys) do
-        vim.keymap.set('n', key, map_info.action, { desc = map_info.desc })
+		vim.keymap.set("n", key, map_info.action, { desc = map_info.desc })
 	end
 end
-vim.keymap.set('n', '<Leader>tf', function()
+vim.keymap.set("n", "<Leader>tf", function()
-    require('neotest').run.run(vim.fn.expand '%')
+	require("neotest").run.run(vim.fn.expand("%"))
 	open_test()
-end, { desc = 'Run all tests in the current file' })
+end, { desc = "Run all tests in the current file" })
-vim.keymap.set('n', '<Leader>tc', function()
+vim.keymap.set("n", "<Leader>tc", function()
-    require('neotest').summary.close()
+	require("neotest").summary.close()
-    require('neotest').output_panel.close()
+	require("neotest").output_panel.close()
-end, { desc = 'Close test panels' })
+end, { desc = "Close test panels" })
 
-vim.keymap.set('i', '<Tab>', function()
+vim.keymap.set("i", "<Tab>", function()
+	local ls = require("luasnip")
 	if ls.jumpable(1) then
-        vim.api.nvim_echo({ { 'Jumping in snippet' } }, false, {})
+		vim.api.nvim_echo({ { "Jumping in snippet" } }, false, {})
 		ls.jump()
 	else
-        vim.api.nvim_echo({ { 'Inserting tab' } }, false, {})
+		vim.api.nvim_echo({ { "Inserting tab" } }, false, {})
-        vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes('<Tab>', true, true, true), 'n', true)
+		vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes("<Tab>", true, true, true), "n", true)
 	end
-end, { desc = 'Luasnip accept copilot or jump forward' })
+end, { desc = "Luasnip accept copilot or jump forward" })
 
 -- Leaving this commented out, I will try the format command instead
 -- "A command to properly indent json code
@@ -426,25 +502,25 @@ end, { desc = 'Luasnip accept copilot or jump forward' })
 
 -- Edit the snippet file for the current buffer filetype or the snippets
 -- directory if the file does not exist
-vim.keymap.set('n', '<Leader>es', function()
+vim.keymap.set("n", "<Leader>es", function()
 	local ft = vim.bo.filetype
-    if ft == 'vue' or ft == 'typescript' then
+	if ft == "vue" or ft == "typescript" then
-        ft = 'javascript'
+		ft = "javascript"
 	end
-    local snippets_dir = vim.fn.stdpath 'config' .. '/lua/snippets'
+	local snippets_dir = vim.fn.stdpath("config") .. "/lua/snippets"
-    local snippets_file = snippets_dir .. '/' .. ft .. '.lua'
+	local snippets_file = snippets_dir .. "/" .. ft .. ".lua"
-    vim.cmd('tabedit ' .. snippets_file)
+	vim.cmd("tabedit " .. snippets_file)
-end, { desc = 'Edit snippets file' })
+end, { desc = "Edit snippets file" })
 
-vim.keymap.set('n', '<Leader>cz', function()
+vim.keymap.set("n", "<Leader>cz", function()
-    require('utils/cheatsheets').open 'zsh'
+	require("utils/cheatsheets").open("zsh")
-end, { desc = 'Open zsh cheat sheet' })
+end, { desc = "Open zsh cheat sheet" })
-vim.keymap.set('n', '<Leader>cb', function()
+vim.keymap.set("n", "<Leader>cb", function()
-    require('utils/cheatsheets').open 'bash'
+	require("utils/cheatsheets").open("bash")
-end, { desc = 'Open bash cheat sheet' })
+end, { desc = "Open bash cheat sheet" })
-vim.keymap.set('n', '<Leader>cr', function()
+vim.keymap.set("n", "<Leader>cr", function()
-    require('utils/cheatsheets').open 'regex'
+	require("utils/cheatsheets").open("regex")
-end, { desc = 'Open RegExp cheat sheet' })
+end, { desc = "Open RegExp cheat sheet" })
 
-require('helpers').edit_cf('k', '/lua/keymap.lua')
+require("helpers").edit_cf("k", "/lua/keymap.lua")