Merge branch 'main' of labs.scarif.space:chris/nvim

lua/autocmd.lua

@@ -14,17 +14,16 @@ vim.api.nvim_create_autocmd('TextYankPost', {
 
 local autosave_group = vim.api.nvim_create_augroup('autosaving', { clear = true })
 
-vim.api.nvim_create_autocmd('FocusLost', {
+vim.api.nvim_create_autocmd({ 'FocusLost', 'BufLeave' }, {
     group = autosave_group,
     pattern = '*',
-    command = 'silent! wa', -- Save all files when moving away from the window
-    nested = true, -- Allow other autocommands to run after this one
-})
+    callback = function(args)
+        if vim.bo[args.buf].filetype == 'oil' then
+            return
+        end
 
-vim.api.nvim_create_autocmd('BufLeave', {
-    group = autosave_group,
-    pattern = '*',
-    command = 'silent! wa', -- Save all files when switching buffers
+        vim.cmd 'silent! wa'
+    end,
     nested = true, -- Allow other autocommands to run after this one
 })
 
@@ -212,4 +211,3 @@ vim.api.nvim_create_autocmd('VimLeavePre', {
 })
 
 require('helpers').edit_cf('a', '/lua/autocmd.lua')
-

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" }, "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({ '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('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()
-	local node = vim.treesitter.get_node({})
+vim.keymap.set('n', '<C-S-D>', function()
+    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")
-end, { desc = "Select surrounding treesitter node" })
+    vim.cmd.normal 'v`x'
+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,36 +49,32 @@ 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("v`x")
-end, { desc = "Select surrounding treesitter node" })
+    vim.cmd.normal 'i'
+    vim.cmd.normal 'v`x'
+end, { desc = 'Select surrounding treesitter node' })
 
 local swappable_nodes = {
-	"argument",
-	"array_element_initializer",
-	"simple_parameter",
-	"string",
-	"integer",
-	"member_call_expression",
-	"method_declaration",
+    '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
@@ -90,9 +86,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)
-end, { desc = "Swap with node to the left" })
-vim.keymap.set({ "n" }, "<C-S-l>", function()
+    require('nvim-treesitter.ts_utils').swap_nodes(node, prev_node, 0, true)
+end, { desc = 'Swap with node to the left' })
+vim.keymap.set({ 'n' }, '<C-S-l>', function()
     local node = closest_swappable_node(vim.treesitter.get_node())
     if not node then
         return
@@ -104,12 +100,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)
-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-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-k>", "dkO<Esc>p`[v`]", { desc = "Move selection up" })
+    require('nvim-treesitter.ts_utils').swap_nodes(node, next_node, 0, true)
+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-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-k>', 'dkO<Esc>p`[v`]', { desc = 'Move selection up' })
 
 -- Keybinds to make split navigation easier.
 --  Use CTRL+<hjkl> to switch between windows
@@ -118,112 +114,97 @@ 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")
-			if ok and type(treesj.toggle) == "function" then
+            local ok, treesj = pcall(require, 'treesj')
+            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-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-k>", (win_or_treesj)("k", "Move focus to the upper window or treesj.toggle()"))
+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-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("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-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-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-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({ "i" }, "<C-J>", function()
-	local ls = require("luasnip")
+vim.keymap.set({ 'i' }, '<C-J>', function()
+    local ls = require 'luasnip'
     if ls.choice_active() then
         ls.change_choice(1)
     end
-end, { desc = "Toggle snippet choice", silent = true })
-vim.keymap.set({ "i" }, "<C-k>", function()
-	local ls = require("luasnip")
+end, { desc = 'Toggle snippet choice', silent = true })
+vim.keymap.set({ 'i' }, '<C-k>', function()
+    local ls = require 'luasnip'
     if ls.choice_active() then
         ls.change_choice(-1)
     end
-end, { desc = "Toggle snippet choice", silent = true })
-vim.keymap.set({ "i", "s" }, "<C-L>", function()
-	local ls = require("luasnip")
+end, { desc = 'Toggle snippet choice', silent = true })
+vim.keymap.set({ 'i', 's' }, '<C-L>', function()
+    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 })
-vim.keymap.set({ "i", "s" }, "<C-H>", function()
-	local ls = require("luasnip")
+end, { desc = 'Expand snippet', silent = true })
+vim.keymap.set({ 'i', 's' }, '<C-H>', function()
+    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>tabprevious<CR>", { desc = "Previous tab" })
+vim.keymap.set('n', '<Leader>.', '<Cmd>tabnext<CR>', { desc = 'Next tab' })
+vim.keymap.set('n', '<Leader>,', '<Cmd>tabprevious<CR>', { desc = 'Previous tab' })
 
 -- Overriding CTRL mappings because some of them are stupid
-vim.keymap.set({ "n", "v", "c", "i" }, "<C-S-B>", "<CMD>Git blame<CR>", { desc = "Git blame" })
-vim.keymap.set(
-	{ "n", "v", "c", "i" },
-	"<C-Q>",
-	"<CMD>Telescope lsp_document_symbols<CR>",
-	{ desc = "Show symbols in current document" }
-)
-vim.keymap.set(
-	{ "n", "v", "c", "i" },
-	"<C-S-Q>",
-	"<CMD>Telescope lsp_workspace_symbols<CR>",
-	{ desc = "Show symbols in workspace" }
-)
-vim.keymap.set({ "n", "v", "c", "i" }, "<C-E>", "<CMD>Telescope oldfiles<CR>", { desc = "Show recently opened files" })
-vim.keymap.set({ "n", "v", "c", "i" }, "<C-P>", function()
-	require("telescope.builtin").find_files({
+vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-S-B>', '<CMD>Git blame<CR>', { desc = 'Git blame' })
+vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-Q>', '<CMD>Telescope lsp_document_symbols<CR>', { desc = 'Show symbols in current document' })
+vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-S-Q>', '<CMD>Telescope lsp_workspace_symbols<CR>', { desc = 'Show symbols in workspace' })
+vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-E>', '<CMD>Telescope oldfiles<CR>', { desc = 'Show recently opened files' })
+vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-P>', function()
+    require('telescope.builtin').find_files {
         show_untracked = true,
         no_ignore = false,
         hidden = true,
-	})
-end, { desc = "Find all files" })
-vim.keymap.set({ "n", "v", "c", "i" }, "<C-S-P>", function()
-	require("telescope.builtin").find_files({
+    }
+end, { desc = 'Find all files' })
+vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-S-P>', function()
+    require('telescope.builtin').find_files {
         show_untracked = true,
         no_ignore = true,
         hidden = true,
-	})
-end, { desc = "Find all files" })
-vim.keymap.set({ "n", "v", "c", "i" }, "<C-f>", function()
-	require("telescope.builtin").live_grep({
+    }
+end, { desc = 'Find all files' })
+vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-f>', function()
+    require('telescope.builtin').live_grep {
         hidden = true,
-	})
-end, { desc = "Search within the whole project" })
-vim.keymap.set({ "n", "v", "c", "i" }, "<C-Y>", "<CMD>Telescope quickfix<CR>", { desc = "Show quickfix list" })
-vim.keymap.set(
-	{ "n", "v", "c", "i" },
-	"<C-S-Y>",
-	"<CMD>Telescope quickfixhistory<CR>",
-	{ desc = "Show quickfix history" }
-)
-vim.keymap.set({ "n", "v", "c", "i", "t" }, "<C-A>", function()
-	local ai_tools = { "codex", "agy", "opencode" }
+    }
+end, { desc = 'Search within the whole project' })
+vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-Y>', '<CMD>Telescope quickfix<CR>', { desc = 'Show quickfix list' })
+vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-S-Y>', '<CMD>Telescope quickfixhistory<CR>', { desc = 'Show quickfix history' })
+vim.keymap.set({ 'n', 'v', 'c', 'i', '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
@@ -243,99 +224,66 @@ 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,
-		{}
-	)
-end, { desc = "Toggle AI tool" })
+    vim.api.nvim_echo({ { '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()
-	require("snacks").scratch()
-end, { desc = "Open scratchpad" })
-vim.keymap.set({ "n", "v", "c", "i" }, "<C-S-S>", function()
-	require("snacks").scratch.select()
-end, { desc = "Open scratchpad buffers" })
-vim.keymap.set({ "n", "v", "c", "i", "t" }, "<C-T>", function()
-	require("snacks").terminal.toggle()
-end, { desc = "Toggle terminal" })
-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-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({ 'n', 'v', 'c', 'i' }, '<C-S>', function()
+    require('snacks').scratch()
+end, { desc = 'Open scratchpad' })
+vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-S-S>', function()
+    require('snacks').scratch.select()
+end, { desc = 'Open scratchpad buffers' })
+vim.keymap.set({ 'n', 'v', 'c', 'i', 't' }, '<C-T>', function()
+    require('snacks').terminal.toggle()
+end, { desc = 'Toggle terminal' })
+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-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' })
 
 -- Editing helpers
-vim.keymap.set("i", "<C-O>", "<Esc>o", { desc = "Add line below" })
-vim.keymap.set("i", "<C-S-O>", "<Esc>O", { desc = "Add line above" })
-local esc_keys = { "jj", "jk", "kk" }
+vim.keymap.set('i', '<C-O>', '<Esc>o', { desc = 'Add line below' })
+vim.keymap.set('i', '<C-S-O>', '<Esc>O', { desc = 'Add line above' })
+local esc_keys = { 'jj', 'jk', 'kk' }
 for _, key in ipairs(esc_keys) do
-	vim.keymap.set("i", key, "<Esc>", { desc = "Exit insert mode" })
+    vim.keymap.set('i', key, '<Esc>', { desc = 'Exit insert mode' })
 end
-vim.keymap.set("i", "<C-D>", "<Esc>ddi", { desc = "Delete line" })
-vim.keymap.set("i", "<Leader>;", "<Esc>mzA;<Esc>`za", { desc = "Append a semicolon" })
-vim.keymap.set("n", "<Leader>;", "mzA;<Esc>`za", { desc = "Append a semicolon" })
-vim.keymap.set("n", "<Leader>{", "mzF[`a<CR><Esc>``%i<CR><Esc>`z", { desc = "Indent an array" })
-vim.keymap.set(
-	"n",
-	"<Leader>}",
-	"mzF[`a<CR><Esc>``%i<CR><Esc>`zvi[:s/,\\s*/,\\r/g<CR>vi[=<Esc>`z:nohlsearch<CR>",
-	{ desc = "Indent an array some other way?" }
-)
+vim.keymap.set('i', '<C-D>', '<Esc>ddi', { desc = 'Delete line' })
+vim.keymap.set('i', '<Leader>;', '<Esc>mzA;<Esc>`za', { desc = 'Append a semicolon' })
+vim.keymap.set('n', '<Leader>;', 'mzA;<Esc>`za', { desc = 'Append a semicolon' })
+vim.keymap.set('n', '<Leader>{', 'mzF[`a<CR><Esc>``%i<CR><Esc>`z', { desc = 'Indent an array' })
+vim.keymap.set('n', '<Leader>}', 'mzF[`a<CR><Esc>``%i<CR><Esc>`zvi[:s/,\\s*/,\\r/g<CR>vi[=<Esc>`z:nohlsearch<CR>', { desc = 'Indent an array some other way?' })
 
 -- Git mappings
-vim.keymap.set("n", "<Leader>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>gdc", "<CMD>Git diff --cached<CR>", { desc = "Git diff" })
-vim.keymap.set("n", "<Leader>G", function()
-	helpers.open_term({ cmd = "lazygit" })
-end, { desc = "Git" })
+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>gdc', '<CMD>Git diff --cached<CR>', { desc = 'Git diff' })
+vim.keymap.set('n', '<Leader>G', function()
+    helpers.open_term { cmd = 'lazygit' }
+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(
-				0,
-				"n",
-				"<S-Tab>",
-				"[c",
-				{ noremap = true, silent = true, desc = "Previous hunk in diff mode" }
-			)
+            vim.api.nvim_buf_set_keymap(0, 'n', '<Tab>', ']c', { noremap = true, silent = true, desc = 'Next hunk in diff mode' })
+            vim.api.nvim_buf_set_keymap(0, 'n', '<S-Tab>', '[c', { noremap = true, silent = true, desc = 'Previous hunk in diff mode' })
 
             -- Keymaps for resolving conflicts
-			vim.api.nvim_buf_set_keymap(
-				0,
-				"n",
-				"<leader>dl",
-				":diffget LOCAL<CR>",
-				{ noremap = true, silent = true, desc = "Get LOCAL changes" }
-			)
-			vim.api.nvim_buf_set_keymap(
-				0,
-				"n",
-				"<leader>dr",
-				":diffget REMOTE<CR>",
-				{ noremap = true, silent = true, desc = "Get REMOTE changes" }
-			)
+            vim.api.nvim_buf_set_keymap(0, 'n', '<leader>dl', ':diffget LOCAL<CR>', { noremap = true, silent = true, desc = 'Get LOCAL changes' })
+            vim.api.nvim_buf_set_keymap(0, 'n', '<leader>dr', ':diffget REMOTE<CR>', { noremap = true, silent = true, desc = 'Get REMOTE changes' })
         end
     end,
 })
@@ -343,109 +291,96 @@ 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", {
-	pattern = "codecompanion",
+vim.api.nvim_create_autocmd('FileType', {
+    pattern = 'codecompanion',
     callback = function()
-		vim.keymap.set("i", "<Enter>", function()
-			require("codecompanion").last_chat():submit()
-		end, { buffer = true, desc = "Use enter to send the message" })
-		vim.keymap.set("i", "<S-Enter>", "<Enter>", { buffer = true, desc = "Use shift enter to start a new line" })
-		vim.keymap.set(
-			"n",
-			"<Enter>",
-			"G",
-			{ buffer = true, desc = "Use enter in normal mode to go to the end of the chat" }
-		)
+        vim.keymap.set('i', '<Enter>', function()
+            require('codecompanion').last_chat():submit()
+        end, { buffer = true, desc = 'Use enter to send the message' })
+        vim.keymap.set('i', '<S-Enter>', '<Enter>', { buffer = true, desc = 'Use shift enter to start a new line' })
+        vim.keymap.set('n', '<Enter>', 'G', { buffer = true, desc = 'Use enter in normal mode to go to the end of the chat' })
 
         local models = { 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(
-				"i",
-				"<C-" .. i .. ">",
-				'<Esc>mzggj0W"_C' .. model .. "<Esc>`za",
-				{ 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 })
         end
     end,
 })
 
 -- Search mappings
-vim.keymap.set("n", "<Leader>sGb", "<CMD>Telescope git_branches<CR>", { desc = "Search git branches" })
-vim.keymap.set("n", "<Leader>sGc", "<CMD>Telescope git_commits<CR>", { desc = "Search git history" })
-vim.keymap.set(
-	"n",
-	"<Leader>sGh",
-	"<CMD>Telescope git_bcommits<CR>",
-	{ desc = "Search git history within current buffer/selection" }
-)
-vim.keymap.set("n", "<Leader>sGs", "<CMD>Telescope git_status<CR>", { desc = "Search git status" })
-vim.keymap.set("n", "<Leader>sGS", "<CMD>Telescope git_stash<CR>", { desc = "Search git stash" })
+vim.keymap.set('n', '<Leader>sGb', '<CMD>Telescope git_branches<CR>', { desc = 'Search git branches' })
+vim.keymap.set('n', '<Leader>sGc', '<CMD>Telescope git_commits<CR>', { desc = 'Search git history' })
+vim.keymap.set('n', '<Leader>sGh', '<CMD>Telescope git_bcommits<CR>', { desc = 'Search git history within current buffer/selection' })
+vim.keymap.set('n', '<Leader>sGs', '<CMD>Telescope git_status<CR>', { desc = 'Search git status' })
+vim.keymap.set('n', '<Leader>sGS', '<CMD>Telescope git_stash<CR>', { desc = 'Search git stash' })
 
 -- Misc
-vim.keymap.set("n", "<Leader>]", "<CMD>cnext<CR>", { desc = "Next item in quickfix list" })
-vim.keymap.set("n", "<Leader>[", "<CMD>cprevious<CR>", { desc = "Previous item in quickfix list" })
-vim.keymap.set("n", "gd", "<CMD>Telescope lsp_definitions<CR>", { desc = "Go to definition" })
-vim.keymap.set("n", "<Leader>r", function()
-	for _, c in ipairs(vim.lsp.get_clients({ bufnr = 0 })) do
-		if c.name == "phpantom_lsp" then
+vim.keymap.set('n', '<Leader>]', '<CMD>cnext<CR>', { desc = 'Next item in quickfix list' })
+vim.keymap.set('n', '<Leader>[', '<CMD>cprevious<CR>', { desc = 'Previous item in quickfix list' })
+vim.keymap.set('n', 'gd', '<CMD>Telescope lsp_definitions<CR>', { desc = 'Go to definition' })
+vim.keymap.set('n', '<Leader>r', function()
+    for _, c in ipairs(vim.lsp.get_clients { bufnr = 0 }) do
+        if c.name == 'phpantom_lsp' then
             c:stop(true)
         end
     end
-	vim.cmd("edit")
-end, { desc = "Reload buffer" })
+    vim.cmd 'edit'
+end, { desc = 'Reload buffer' })
 
 local function open_test()
-	require("neotest").summary.open()
-	require("neotest").output_panel.open()
+    require('neotest').summary.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").output_panel.close()
+            require('neotest').summary.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()
+            vim.cmd 'write'
+            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 })
+            vim.cmd 'write'
+            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()
+            vim.cmd 'write'
+            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()
-			local neotest = require("neotest")
+            require('dapui').open()
+            local neotest = require 'neotest'
             local bufnr = vim.api.nvim_get_current_buf()
             local row = vim.api.nvim_win_get_cursor(0)[1] - 1
-
             local adapters = neotest.state.adapter_ids()
             local found = false
 
@@ -453,8 +388,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)
-					if nearest and nearest:data().type ~= "file" then
+                    local nearest = require('neotest.lib.positions').nearest(tree, row)
+                    if nearest and nearest:data().type ~= 'file' then
                         neotest.run.run()
                         found = true
                         break
@@ -467,34 +402,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()
-	require("neotest").run.run(vim.fn.expand("%"))
+vim.keymap.set('n', '<Leader>tf', function()
+    require('neotest').run.run(vim.fn.expand '%')
     open_test()
-end, { desc = "Run all tests in the current file" })
-vim.keymap.set("n", "<Leader>tc", function()
-	require("neotest").summary.close()
-	require("neotest").output_panel.close()
-end, { desc = "Close test panels" })
+end, { desc = 'Run all tests in the current file' })
+vim.keymap.set('n', '<Leader>tc', function()
+    require('neotest').summary.close()
+    require('neotest').output_panel.close()
+end, { desc = 'Close test panels' })
 
-vim.keymap.set("i", "<Tab>", function()
-	local ls = require("luasnip")
+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_feedkeys(vim.api.nvim_replace_termcodes("<Tab>", true, true, true), "n", true)
+        vim.api.nvim_echo({ { 'Inserting tab' } }, false, {})
+        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
@@ -502,25 +437,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
-		ft = "javascript"
+    if ft == 'vue' or ft == 'typescript' then
+        ft = 'javascript'
     end
-	local snippets_dir = vim.fn.stdpath("config") .. "/lua/snippets"
-	local snippets_file = snippets_dir .. "/" .. ft .. ".lua"
-	vim.cmd("tabedit " .. snippets_file)
-end, { desc = "Edit snippets file" })
+    local snippets_dir = vim.fn.stdpath 'config' .. '/lua/snippets'
+    local snippets_file = snippets_dir .. '/' .. ft .. '.lua'
+    vim.cmd('tabedit ' .. snippets_file)
+end, { desc = 'Edit snippets file' })
 
-vim.keymap.set("n", "<Leader>cz", function()
-	require("utils/cheatsheets").open("zsh")
-end, { desc = "Open zsh cheat sheet" })
-vim.keymap.set("n", "<Leader>cb", function()
-	require("utils/cheatsheets").open("bash")
-end, { desc = "Open bash cheat sheet" })
-vim.keymap.set("n", "<Leader>cr", function()
-	require("utils/cheatsheets").open("regex")
-end, { desc = "Open RegExp cheat sheet" })
+vim.keymap.set('n', '<Leader>cz', function()
+    require('utils/cheatsheets').open 'zsh'
+end, { desc = 'Open zsh cheat sheet' })
+vim.keymap.set('n', '<Leader>cb', function()
+    require('utils/cheatsheets').open 'bash'
+end, { desc = 'Open bash cheat sheet' })
+vim.keymap.set('n', '<Leader>cr', function()
+    require('utils/cheatsheets').open 'regex'
+end, { desc = 'Open RegExp cheat sheet' })
 
-require("helpers").edit_cf("k", "/lua/keymap.lua")
+require('helpers').edit_cf('k', '/lua/keymap.lua')
 

lua/projects/framework_utils/laravel.lua

@@ -21,7 +21,7 @@ local function make_laravel_file(dir, cmd)
             return
         end
 
-        local output = vim.system({ 'vendor/bin/sail', 'artisan', 'make:' .. cmd, input }):wait().stdout
+        local output = vim.system({ 'php', 'artisan', 'make:' .. cmd, input }):wait().stdout
         local new_file = output:match '%[([%w%./]+)%]'
         if new_file ~= nil then
             vim.cmd('edit ' .. new_file)

lua/projects/hylark.lua

@@ -29,6 +29,8 @@ return function(dir)
         vim.notify('Compiling typescript types', vim.log.levels.INFO, { title = 'hylark.lua' })
     end
 
+    switch_to_root()
+
     map('<leader>pl', ':cexpr system("vendor/bin/phpstan analyse --no-progress --error-format=raw --memory-limit=2G -vv") <CR>', { desc = 'Run lint' })
     map('<leader>T', function()
         helpers.open_term { cmd = 'lazysql pgsql://homestead:password@localhost:5432/homestead' }
@@ -83,22 +85,22 @@ return function(dir)
         end,
     })
 
-    vim.api.nvim_create_autocmd({ 'BufEnter' }, {
-        pattern = { dir .. '**' },
-        callback = function()
-            if vim.fn.expand('%:p'):match(dir .. '/server/') then
-                switch_to_server()
-            elseif vim.fn.expand('%:p'):match(dir .. '/frontend2/') then
-                switch_to_frontend()
-            else
-                switch_to_root()
-            end
-        end,
-    })
+    -- vim.api.nvim_create_autocmd({ 'BufEnter' }, {
+    --     pattern = { dir .. '**' },
+    --     callback = function()
+    --         if vim.fn.expand('%:p'):match(dir .. '/server/') then
+    --             switch_to_server()
+    --         elseif vim.fn.expand('%:p'):match(dir .. '/frontend2/') then
+    --             switch_to_frontend()
+    --         else
+    --             switch_to_root()
+    --         end
+    --     end,
+    -- })
 
-    laravel_utils.laravel_keymaps 'server/'
-    laravel_utils.laravel_makes 'server/'
-    laravel_utils.laravel_utils 'server/'
+    laravel_utils.laravel_keymaps(dir .. '/server/')
+    laravel_utils.laravel_makes(dir .. '/server/')
+    laravel_utils.laravel_utils(dir .. '/server/')
     laravel_utils.laravel_bookmarks(dir .. '/server/')
 
     create_bookmark('s', dir .. '/frontend2/src/types/api/server-types.d.ts')

lua/projects/runcats.lua

@@ -30,10 +30,10 @@ return function(dir)
         end,
     })
 
-    laravel_utils.laravel_keymaps 'server/'
-    laravel_utils.laravel_makes 'server/'
-    laravel_utils.laravel_utils 'server/'
-    laravel_utils.laravel_bookmarks 'server/'
+    laravel_utils.laravel_keymaps(dir .. '/server/')
+    laravel_utils.laravel_makes(dir .. '/server/')
+    laravel_utils.laravel_utils(dir .. '/server/')
+    laravel_utils.laravel_bookmark(dir .. '/server/')
 
     create_bookmark('E', dir .. '/client/src/types/api/endpointMap.d.ts')
     create_bookmark('q', dir .. '/client/quasar.config.ts')

lua/snippets/php.lua

@@ -433,7 +433,7 @@ return {
                          */
                         public function #~(): HasMany
                         {
-                            return $this->hasOne(#~::class);
+                            return $this->hasMany(#~::class);
                         }
                     ]],
                     { rep(1), i(2), i(1) }
@@ -448,7 +448,7 @@ return {
                          */
                         public function #~(): HasMany
                         {
-                            return $this->hasOne(#~::class, #~);
+                            return $this->hasMany(#~::class, #~);
                         }
                     ]],
                     { rep(1), i(2), i(1), i(3) }
@@ -615,3 +615,4 @@ return {
     --     })
     -- ),
 }
+