735 lines
20 KiB
Nix
735 lines
20 KiB
Nix
{pkgs, ...}: let
|
|
mkMappings = mappings:
|
|
[]
|
|
++ (pkgs.lib.optionals (builtins.hasAttr "normal" mappings) (mkMode mappings.normal "n"))
|
|
++ (pkgs.lib.optionals (builtins.hasAttr "terminal" mappings) (mkMode mappings.terminal "t"))
|
|
++ (pkgs.lib.optionals (builtins.hasAttr "insert" mappings) (mkMode mappings.insert "i"))
|
|
++ (pkgs.lib.optionals (builtins.hasAttr "visual" mappings) (mkMode mappings.visual "v"))
|
|
++ (pkgs.lib.optionals (builtins.hasAttr "global" mappings) (mkMode mappings.global ""));
|
|
mkMode = mappings: mode:
|
|
pkgs.lib.mapAttrsToList
|
|
(key: value: {
|
|
key = key;
|
|
action = rawLua value;
|
|
mode = mode;
|
|
})
|
|
mappings;
|
|
border = ["╭" "─" "╮" "│" "╯" "─" "╰" "│"];
|
|
rawLua = lua: {
|
|
"__raw" = ''
|
|
${lua}
|
|
'';
|
|
};
|
|
in rec {
|
|
neovim = (pkgs.nixvim.makeNixvim config) // {config = config;};
|
|
config = {
|
|
plugins = {
|
|
fugitive.enable = true;
|
|
gitsigns.enable = true;
|
|
neogit.enable = true;
|
|
surround.enable = true;
|
|
todo-comments.enable = true;
|
|
trouble.enable = true;
|
|
ts-context-commentstring.enable = true;
|
|
which-key.enable = true;
|
|
|
|
oil = {
|
|
enable = true;
|
|
settings.skip_confirm_for_simple_edits = true;
|
|
};
|
|
|
|
navic = {
|
|
enable = true;
|
|
lsp.autoAttach = true;
|
|
};
|
|
|
|
mini = {
|
|
enable = true;
|
|
modules = {
|
|
ai = {};
|
|
starter = {};
|
|
};
|
|
};
|
|
|
|
lualine = {
|
|
enable = true;
|
|
sections = {
|
|
lualine_c = [
|
|
{
|
|
name =
|
|
rawLua
|
|
/*
|
|
lua
|
|
*/
|
|
''
|
|
function(bufnr)
|
|
local opts = { highlight = true }
|
|
return require'nvim-navic'.get_location(opts)
|
|
end,
|
|
cond = function()
|
|
return require'nvim-navic'.is_available()
|
|
end
|
|
'';
|
|
}
|
|
];
|
|
};
|
|
};
|
|
|
|
comment = {
|
|
enable = true;
|
|
settings.pre_hook =
|
|
/*
|
|
lua
|
|
*/
|
|
''
|
|
require('ts_context_commentstring.integrations.comment_nvim').create_pre_hook()
|
|
'';
|
|
};
|
|
|
|
markdown-preview = {
|
|
enable = true;
|
|
settings.auto_start = false;
|
|
};
|
|
|
|
noice = {
|
|
enable = true;
|
|
notify.enabled = false;
|
|
lsp.override = {
|
|
"vim.lsp.util.convert_input_to_markdown_lines" = true;
|
|
"vim.lsp.util.stylize_markdown" = true;
|
|
"cmp.entry.get_documentation" = true;
|
|
};
|
|
presets = {
|
|
bottom_search = false;
|
|
command_palette = true;
|
|
long_message_to_split = true;
|
|
inc_rename = false;
|
|
lsp_doc_border = true;
|
|
};
|
|
};
|
|
|
|
treesitter = {
|
|
enable = true;
|
|
indent = true;
|
|
folding = true;
|
|
grammarPackages =
|
|
pkgs.vimPlugins.nvim-treesitter.allGrammars
|
|
++ (with pkgs.tree-sitter-grammars; [
|
|
tree-sitter-just
|
|
tree-sitter-nu
|
|
tree-sitter-d2
|
|
tree-sitter-norg-meta
|
|
]);
|
|
};
|
|
|
|
telescope = {
|
|
enable = true;
|
|
# settings = {
|
|
# defaults = {
|
|
# layout_strategy = "vertical";
|
|
# layout_config = {
|
|
# preview_height = 0.8;
|
|
# vertical = {
|
|
# size = {
|
|
# width = "99%";
|
|
# height = "99%";
|
|
# };
|
|
# };
|
|
# };
|
|
# };
|
|
# };
|
|
extensions = {
|
|
undo.enable = true;
|
|
ui-select.enable = true;
|
|
fzf-native.enable = true;
|
|
file-browser.enable = true;
|
|
};
|
|
};
|
|
|
|
fidget = {
|
|
enable = true;
|
|
notification.overrideVimNotify = true;
|
|
};
|
|
|
|
dap = {
|
|
enable = true;
|
|
extensions = {
|
|
dap-ui.enable = true;
|
|
dap-virtual-text.enable = true;
|
|
};
|
|
};
|
|
|
|
nvim-ufo = {
|
|
enable = true;
|
|
closeFoldKinds = null;
|
|
providerSelector =
|
|
/*
|
|
lua
|
|
*/
|
|
''
|
|
function(bufnr, filetype, buftype)
|
|
return {'treesitter', 'indent'}
|
|
end
|
|
'';
|
|
};
|
|
rustaceanvim = {
|
|
enable = true;
|
|
settings = {
|
|
server = {
|
|
on_attach =
|
|
/*
|
|
lua
|
|
*/
|
|
''
|
|
function(client, bufnr)
|
|
if client.server_capabilities.inlayHintProvider then
|
|
vim.lsp.inlay_hint.enable(true)
|
|
end
|
|
end
|
|
'';
|
|
# settings =
|
|
# /*
|
|
# lua
|
|
# */
|
|
# ''
|
|
# function(project_root)
|
|
# local ra = require('rustaceanvim.config.server')
|
|
# return ra.load_rust_analyzer_settings(project_root, {
|
|
# settings_file_pattern = 'rust-analyzer.json'
|
|
# })
|
|
# end
|
|
# '';
|
|
#cmd =
|
|
# /*
|
|
# lua
|
|
# */
|
|
# ''
|
|
# function()
|
|
# return { '${pkgs.ra-multiplex}/bin/ra-multiplex', 'client' }
|
|
# end
|
|
# '';
|
|
};
|
|
dap = {
|
|
autoload_configurations = false;
|
|
};
|
|
tools = {
|
|
float_win_config = {border = "rounded";};
|
|
enable_clippy = false;
|
|
};
|
|
};
|
|
};
|
|
|
|
lsp = {
|
|
enable = true;
|
|
servers = {
|
|
gopls.enable = true;
|
|
nil-ls = {
|
|
enable = true;
|
|
settings.formatting.command = [
|
|
"${pkgs.alejandra}/bin/alejandra"
|
|
];
|
|
# nix.flake.autoArchive = true;
|
|
};
|
|
marksman.enable = true;
|
|
nushell.enable = true;
|
|
clangd.enable = true;
|
|
lua-ls.enable = true;
|
|
jsonls.enable = true;
|
|
html.enable = true;
|
|
ast-grep.enable = true;
|
|
# pylyzer.enable = true;
|
|
rust-analyzer.enable = false;
|
|
};
|
|
onAttach =
|
|
/*
|
|
lua
|
|
*/
|
|
''
|
|
if client.server_capabilities.inlayHintProvider then
|
|
vim.lsp.inlay_hint.enable(true)
|
|
end
|
|
'';
|
|
};
|
|
cmp = {
|
|
enable = true;
|
|
settings = {
|
|
autoEnableSources = true;
|
|
sources = [
|
|
{name = "buffer";}
|
|
{name = "buffer";}
|
|
{name = "cmdline";}
|
|
{name = "cmp-clippy";}
|
|
{name = "cmp-cmdline-history";}
|
|
{name = "crates";}
|
|
{name = "dap";}
|
|
{name = "dictionary";}
|
|
{name = "fish";}
|
|
{name = "git";}
|
|
{name = "luasnip";}
|
|
{name = "nvim_lsp";}
|
|
{name = "nvim_lua";}
|
|
{name = "nvim_lsp_signature_help";}
|
|
{name = "nvim_lsp_document_symbol";}
|
|
{name = "path";}
|
|
{name = "rg";}
|
|
{name = "spell";}
|
|
{name = "tmux";}
|
|
{name = "treesitter";}
|
|
];
|
|
view = {
|
|
entries = {
|
|
name = "custom";
|
|
selection_order = "near_cursor";
|
|
};
|
|
};
|
|
window = {
|
|
completion = {
|
|
inherit border;
|
|
};
|
|
documentation = {
|
|
inherit border;
|
|
};
|
|
};
|
|
mapping = {
|
|
# "<CR>" = "cmp.mapping.confirm({select = true})";
|
|
"<CR>" = "cmp.mapping.confirm()";
|
|
"<C-Space>" = "cmp.mapping.complete()";
|
|
"<C-n>" = "cmp.mapping(cmp.mapping.select_next_item(), {'i', 's'})";
|
|
"<C-p>" = "cmp.mapping(cmp.mapping.select_prev_item(), {'i', 's'})";
|
|
};
|
|
snippet.expand =
|
|
/*
|
|
lua
|
|
*/
|
|
''
|
|
function(args)
|
|
require('luasnip').lsp_expand(args.body)
|
|
end
|
|
'';
|
|
};
|
|
};
|
|
};
|
|
globals = {
|
|
mapleader = " ";
|
|
};
|
|
colorschemes = {
|
|
catppuccin = {
|
|
enable = true;
|
|
settings.flavour = "mocha";
|
|
};
|
|
};
|
|
keymaps = mkMappings {
|
|
normal = {
|
|
"<C-l>" = "[[<cmd>Outline<cr>]]";
|
|
"<C-w>\"" = "[[<cmd>split<cr>]]";
|
|
"<C-w>%" = "[[<cmd>vsplit<cr>]]";
|
|
"gh" = "[[<cmd>Octo actions<cr>]]";
|
|
"<leader>\"" = ''[["+]]'';
|
|
"<C-c>" = "[[<cmd>ChatGPT<cr>]]";
|
|
"<leader>dr" = "[[<cmd>RustLsp debuggables<cr>]]";
|
|
#"<leader>ee" = "[[<cmd>Rest run<cr>]]";
|
|
#"<leader>el" = "[[<cmd>Rest run last<cr>]]";
|
|
"<leader>hh" = "[[<cmd>DevdocsOpen<cr>]]";
|
|
"<leader>hl" = "[[<cmd>DevdocsToggle<cr>]]";
|
|
"<leader><leader>" = "'<c-^>'";
|
|
"<leader>n" = "[[<cmd>bnext<cr>]]";
|
|
"<leader>o" = "[[<cmd>Trouble diagnostics<cr>]]";
|
|
"<leader>p" = "[[<cmd>bprev<cr>]]";
|
|
"<leader>q" = "[[<cmd>bw<cr>]]";
|
|
"<leader>mm" = "[[<cmd>Neorg<cr>]]";
|
|
"vff" = "[[<cmd>vertical Gdiffsplit<cr>]]";
|
|
|
|
"<leader>rr" = "vim.lsp.buf.rename";
|
|
"<C-k>" = "vim.lsp.buf.definition";
|
|
"<C-\\>" = "require('FTerm').toggle";
|
|
"F" = "function() vim.lsp.buf.format({ async = true }) end";
|
|
"gi" = "require'telescope.builtin'.lsp_references";
|
|
"<leader>a" = "vim.lsp.buf.code_action";
|
|
"<leader>bb" = "require'dap'.toggle_breakpoint";
|
|
"<leader>du" = "require'dapui'.toggle";
|
|
"<leader>fb" = "require'telescope'.extensions.file_browser.file_browser";
|
|
"<leader>ff" = "require'telescope.builtin'.find_files";
|
|
"<leader>gg" = "require'telescope.builtin'.live_grep";
|
|
"<leader>;" = "require'telescope.builtin'.buffers";
|
|
|
|
# Emulate tmux bindings with prefix <C-q> and tabs
|
|
"<C-q><C-q>" = "[[g<Tab>]]";
|
|
"<C-q>c" = "[[<cmd>tabnew<cr>]]";
|
|
"<C-q>x" = "[[<cmd>tabclose<cr>]]";
|
|
"<C-q>n" = "[[<cmd>tabnext<cr>]]";
|
|
"<C-q>p" = "[[<cmd>tabprevious<cr>]]";
|
|
};
|
|
terminal = {
|
|
"<C-\\>" = "require('FTerm').toggle";
|
|
};
|
|
insert = {
|
|
"<C-\\>" = "require('FTerm').toggle";
|
|
};
|
|
visual = {
|
|
"L" = "[[:'<,'>!sort -u<cr>]]";
|
|
};
|
|
};
|
|
|
|
autoCmd = [
|
|
{
|
|
event = ["BufEnter" "BufWinEnter"];
|
|
pattern = "*.norg";
|
|
command = "set conceallevel=3";
|
|
}
|
|
{
|
|
event = ["BufWinLeave"];
|
|
pattern = "?*";
|
|
command = "mkview!";
|
|
}
|
|
{
|
|
event = ["BufWinEnter"];
|
|
pattern = "?*";
|
|
command = "silent! loadview!";
|
|
}
|
|
];
|
|
|
|
extraConfigLua = let
|
|
codelldb = pkgs.vscode-extensions.vadimcn.vscode-lldb.adapter;
|
|
liblldb =
|
|
if pkgs.stdenv.isLinux
|
|
then "${codelldb}/lldb/lib/liblldb.so"
|
|
else if pkgs.stdenv.isDarwin
|
|
then "${codelldb}/lldb/lib/liblldb.dylib"
|
|
else null;
|
|
apikey =
|
|
pkgs.writeShellScriptBin
|
|
"openapikey" (
|
|
if pkgs.stdenv.isDarwin
|
|
then ''
|
|
${pkgs._1password}/bin/op item get 'OpenAI API Token' --fields label='api key'
|
|
''
|
|
else ''
|
|
/run/wrappers/bin/op item get 'OpenAI API Token' --fields label='api key'
|
|
''
|
|
);
|
|
in
|
|
/*
|
|
lua
|
|
*/
|
|
''
|
|
function catcher(callback)
|
|
do
|
|
success, output = pcall(callback)
|
|
if not success then
|
|
print("Failed to setup: " .. output)
|
|
end
|
|
end
|
|
end
|
|
|
|
do
|
|
function setup()
|
|
require'neotest'.setup({
|
|
adapters = {
|
|
require('rustaceanvim.neotest'),
|
|
}
|
|
})
|
|
end
|
|
success, output = pcall(setup)
|
|
if not success then
|
|
print("Failed to setup neotest: " .. output)
|
|
end
|
|
end
|
|
|
|
-- catcher(require('rest-nvim').setup)
|
|
|
|
-- catcher(require('lspconfig').ast_grep.setup)
|
|
|
|
-- require('telescope').load_extension("dap")
|
|
-- require('telescope').load_extension("rest")
|
|
require('telescope').load_extension("neorg")
|
|
|
|
require("copilot").setup({
|
|
suggestion = {
|
|
enabled = true,
|
|
auto_trigger = true,
|
|
keymap = {
|
|
accept = "<C-l>",
|
|
}
|
|
},
|
|
panel = { enabled = true },
|
|
})
|
|
|
|
catcher(require('crates').setup)
|
|
catcher(require('outline').setup)
|
|
-- catcher(require('navigator').setup)
|
|
|
|
require('FTerm').setup({
|
|
border = 'single',
|
|
dimensions = {
|
|
height = 0.99,
|
|
width = 0.95,
|
|
},
|
|
cmd = "sh -c 'tmux new -As scratch'",
|
|
blend = 10,
|
|
})
|
|
|
|
local load = {
|
|
["core.defaults"] = {},
|
|
["core.completion"] = { config = { engine = "nvim-cmp", name = "[Norg]" } },
|
|
["core.concealer"] = {
|
|
config = { icon_preset = "diamond" }
|
|
},
|
|
["core.export"] = {},
|
|
["core.keybinds"] = {
|
|
-- https://github.com/nvim-neorg/neorg/blob/main/lua/neorg/modules/core/keybinds/keybinds.lua
|
|
config = {
|
|
default_keybinds = true,
|
|
neorg_leader = "<C-m>",
|
|
},
|
|
},
|
|
["core.dirman"] = {
|
|
config = {
|
|
default_workspace = "Notes",
|
|
workspaces = {
|
|
Notes = "~/Nextcloud/Notes",
|
|
Work = "~/Nextcloud/Work",
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
require('neorg').setup({
|
|
load = load,
|
|
})
|
|
|
|
require('chatgpt').setup({
|
|
api_key_cmd = "${apikey}/bin/openapikey",
|
|
})
|
|
|
|
require('octo').setup({
|
|
use_local_fs = false,
|
|
enable_builtin = false,
|
|
default_remote = {"upstream", "origin"};
|
|
default_merge_method = "squash";
|
|
})
|
|
|
|
local rr_dap = require('nvim-dap-rr')
|
|
rr_dap.setup({
|
|
mappings = {
|
|
continue = "<F7>"
|
|
},
|
|
})
|
|
|
|
local dap = require'dap';
|
|
dap.configurations.rust = { rr_dap.get_rust_config() }
|
|
dap.configurations.cpp = { rr_dap.get_config() }
|
|
|
|
if not vim.g.neovide then
|
|
require('neoscroll').setup()
|
|
require('image').setup({["backend"] = "kitty",["tmux_show_only_in_active_window"] = true})
|
|
load["core.integrations.image"] = {
|
|
config = {
|
|
tmux_show_only_in_active_window = true,
|
|
}
|
|
}
|
|
else
|
|
vim.o.guifont = "Hasklug Nerd Font Mono:h13"
|
|
vim.g.neovide_cursor_vfx_mode = "railgun"
|
|
end
|
|
|
|
|
|
-- do
|
|
-- function setup()
|
|
-- local capabilities = vim.lsp.protocol.make_client_capabilities()
|
|
-- capabilities.textDocument.foldingRange = {
|
|
-- dynamicRegistration = false,
|
|
-- lineFoldingOnly = true
|
|
-- }
|
|
-- -- local language_servers = require("lspconfig").util.available_servers() -- or list servers manually like {'gopls', 'clangd'}
|
|
-- local language_servers = {"nil_ls"};
|
|
-- for _, ls in ipairs(language_servers) do
|
|
-- require('lspconfig')[ls].setup({
|
|
-- capabilities = capabilities
|
|
-- -- you can add other fields for setting up lsp server in this table
|
|
-- })
|
|
-- end
|
|
-- end
|
|
-- success, output = pcall(setup)
|
|
-- if not success then
|
|
-- print("Failed to setup lspconfig folds: " .. output)
|
|
-- end
|
|
-- end
|
|
require('lspconfig.ui.windows').default_options.border = 'single'
|
|
|
|
catcher(require('nvim_context_vt').setup)
|
|
catcher(function()
|
|
require('nvim-devdocs').setup({
|
|
ensure_installed = {"nix", "rust"},
|
|
float_win = {
|
|
relative = "editor",
|
|
height = 80,
|
|
width = 100,
|
|
border = "rounded",
|
|
},
|
|
after_open = function()
|
|
vim.o.conceallevel = 3
|
|
end,
|
|
})
|
|
end)
|
|
|
|
vim.api.nvim_create_user_command('Reso',
|
|
function()
|
|
pcall(vim.cmd'source ~/.config/nvim/init.lua')
|
|
end,
|
|
{})
|
|
|
|
vim.api.nvim_create_user_command('Sqlfmt',
|
|
function()
|
|
pcall(vim.cmd'%!${pkgs.sleek}/bin/sleek')
|
|
end,
|
|
{})
|
|
|
|
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 = {"${pkgs.zsh}/bin/zsh"}
|
|
},
|
|
sql = {
|
|
command = function(meta)
|
|
local db = os.getenv("DATABASE_PATH")
|
|
if db == nil then
|
|
return { '${pkgs.sqlite}/bin/sqlite3', ':memory:' }
|
|
else
|
|
return { '${pkgs.sqlite}/bin/sqlite3', db }
|
|
end
|
|
|
|
end
|
|
},
|
|
rust = {
|
|
command = {"${pkgs.evcxr}/bin/evcxr"}
|
|
},
|
|
},
|
|
-- How the repl window will be displayed
|
|
-- See below for more information
|
|
repl_open_cmd = require('iron.view').right(60),
|
|
},
|
|
-- 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_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
|
|
})
|
|
|
|
vim.filetype.add({
|
|
extension = {
|
|
http = "http",
|
|
},
|
|
})
|
|
|
|
vim.filetype.add({
|
|
filename = {
|
|
['nurfile'] = "nu",
|
|
},
|
|
})
|
|
|
|
'';
|
|
# package = pkgs.neovim-unwrapped;
|
|
# pkgs.neovim;
|
|
opts = {
|
|
shell = "sh";
|
|
number = true;
|
|
relativenumber = true;
|
|
tabstop = 4;
|
|
softtabstop = 4;
|
|
shiftwidth = 4;
|
|
expandtab = true;
|
|
hidden = true;
|
|
smartcase = true;
|
|
termguicolors = true;
|
|
signcolumn = "yes";
|
|
wrap = true;
|
|
completeopt = "menu,menuone,popup,noselect";
|
|
# undodir = "${config.xdg.cacheHome}/undodir";
|
|
undofile = true;
|
|
viewoptions = "cursor,folds";
|
|
# concealcursor = "n";
|
|
foldlevelstart = 99;
|
|
};
|
|
extraPlugins = with pkgs.vimPlugins; [
|
|
# neorg
|
|
neorg
|
|
neorg-telescope
|
|
|
|
# Wut
|
|
image-nvim
|
|
ChatGPT-nvim
|
|
|
|
# UI and UX
|
|
vim-abolish
|
|
octo-nvim
|
|
neoscroll-nvim
|
|
|
|
# Debuggging
|
|
nvim-dap-rr
|
|
|
|
# Treesitter stuff
|
|
outline-nvim
|
|
|
|
# lsp stuff
|
|
copilot-lua
|
|
crates-nvim
|
|
luasnip
|
|
|
|
# No more postman
|
|
# rest-nvim
|
|
|
|
# UI
|
|
nvim-web-devicons
|
|
|
|
# Utils
|
|
FTerm-nvim
|
|
plenary-nvim
|
|
vim-speeddating
|
|
|
|
# Testing
|
|
neotest
|
|
|
|
# Helper libs
|
|
webapi-vim
|
|
|
|
# Treesitter
|
|
nvim_context_vt
|
|
nvim-devdocs
|
|
|
|
# navigator
|
|
|
|
iron-nvim
|
|
d2
|
|
|
|
pkgs.tree-sitter-grammars.tree-sitter-just
|
|
pkgs.tree-sitter-grammars.tree-sitter-nu
|
|
];
|
|
};
|
|
}
|