init wrapper-module config

This commit is contained in:
Daniel Winkler 2026-01-30 14:22:39 +11:00
commit 91755583fd
46 changed files with 4277 additions and 0 deletions

1
.envrc Normal file
View file

@ -0,0 +1 @@
use flake

2
.gitignore vendored Normal file
View file

@ -0,0 +1,2 @@
.DS_Store
.direnv

133
flake.lock generated Normal file
View file

@ -0,0 +1,133 @@
{
"nodes": {
"fran": {
"inputs": {
"nixpkgs": [
"rixpkgs"
]
},
"locked": {
"lastModified": 1768802006,
"narHash": "sha256-czGb4RwTBahNNK9S7ySXeTWIrn/jKH+74hN/uIS2XrM=",
"owner": "dwinkler1",
"repo": "fran",
"rev": "a3879317519fd3685f3b7679a1de4c5ae65a7cb9",
"type": "github"
},
"original": {
"owner": "dwinkler1",
"repo": "fran",
"type": "github"
}
},
"nixpkgs": {
"locked": {
"lastModified": 1769598131,
"narHash": "sha256-e7VO/kGLgRMbWtpBqdWl0uFg8Y2XWFMdz0uUJvlML8o=",
"owner": "nixos",
"repo": "nixpkgs",
"rev": "fa83fd837f3098e3e678e6cf017b2b36102c7211",
"type": "github"
},
"original": {
"owner": "nixos",
"ref": "nixos-25.11",
"repo": "nixpkgs",
"type": "github"
}
},
"plugins-cmp-pandoc-references": {
"flake": false,
"locked": {
"lastModified": 1743491695,
"narHash": "sha256-XsdneGNJzmRBggk8lz9JNDQYk7wbYfUAF2oZLXzFb9c=",
"owner": "jmbuhr",
"repo": "cmp-pandoc-references",
"rev": "130eae4f75029d6495808e0ea4b769fa1ce4c9ac",
"type": "github"
},
"original": {
"owner": "jmbuhr",
"repo": "cmp-pandoc-references",
"type": "github"
}
},
"plugins-cmp-r": {
"flake": false,
"locked": {
"lastModified": 1764700377,
"narHash": "sha256-xb7VFWM/BKAkN7fg62y8n618t2qkQjdYbPwhBhLJwtk=",
"owner": "R-nvim",
"repo": "cmp-r",
"rev": "70bfe8f4c062acc10266e24825439c009a0b1b89",
"type": "github"
},
"original": {
"owner": "R-nvim",
"repo": "cmp-r",
"type": "github"
}
},
"plugins-r": {
"flake": false,
"locked": {
"lastModified": 1769736135,
"narHash": "sha256-T4QgcBL+LCXvrEiRE2JW4jtUKl8DKzFHk8czGUO1jgY=",
"owner": "R-nvim",
"repo": "R.nvim",
"rev": "2701ec64f5485e17c0e057081a9ae2058d776464",
"type": "github"
},
"original": {
"owner": "R-nvim",
"repo": "R.nvim",
"type": "github"
}
},
"rixpkgs": {
"locked": {
"lastModified": 1768825970,
"narHash": "sha256-m/BI9IO7tMuOSdVNSqr0knQ4V9R6rgSXyGQOp3FovSA=",
"type": "tarball",
"url": "https://github.com/rstats-on-nix/nixpkgs/archive/2026-01-19.tar.gz"
},
"original": {
"type": "tarball",
"url": "https://github.com/rstats-on-nix/nixpkgs/archive/2026-01-19.tar.gz"
}
},
"root": {
"inputs": {
"fran": "fran",
"nixpkgs": "nixpkgs",
"plugins-cmp-pandoc-references": "plugins-cmp-pandoc-references",
"plugins-cmp-r": "plugins-cmp-r",
"plugins-r": "plugins-r",
"rixpkgs": "rixpkgs",
"wrappers": "wrappers"
}
},
"wrappers": {
"inputs": {
"nixpkgs": [
"nixpkgs"
]
},
"locked": {
"lastModified": 1769731670,
"narHash": "sha256-iHq0bwOsDI5IkJuxVsljdztZdVKIBb8yO0RBRMrco68=",
"owner": "BirdeeHub",
"repo": "nix-wrapper-modules",
"rev": "4622dd5ef8e152475fce48307d3bc77211249c6a",
"type": "github"
},
"original": {
"owner": "BirdeeHub",
"repo": "nix-wrapper-modules",
"type": "github"
}
}
},
"root": "root",
"version": 7
}

202
flake.nix Normal file
View file

@ -0,0 +1,202 @@
# Copyright (c) 2026 BirdeeHub
# Licensed under the MIT license
{
description = "Daniel's NixCats";
inputs = {
nixpkgs.url = "github:nixos/nixpkgs/nixos-25.11";
wrappers = {
url = "github:BirdeeHub/nix-wrapper-modules";
inputs.nixpkgs.follows = "nixpkgs";
};
rixpkgs.url = "https://github.com/rstats-on-nix/nixpkgs/archive/2026-01-19.tar.gz";
fran = {
url = "github:dwinkler1/fran";
inputs = {
nixpkgs.follows = "rixpkgs";
};
};
"plugins-r" = {
url = "github:R-nvim/R.nvim";
flake = false;
};
"plugins-cmp-r" = {
url = "github:R-nvim/cmp-r";
flake = false;
};
"plugins-cmp-pandoc-references" = {
url = "github:jmbuhr/cmp-pandoc-references";
flake = false;
};
};
outputs = {
self,
nixpkgs,
wrappers,
...
} @ inputs: let
wrapperSettings = pkgs:
wrapper.config.wrap {
inherit pkgs;
cats = {
clickhouse = false;
gitPlugins = false;
julia = false;
lua = false;
markdown = false;
nix = true;
optional = false;
python = false;
r = true;
};
settings.lang_packages = {
python = with pkgs.python3Packages; [
duckdb
polars
];
r = with pkgs.rpkgs.rPackages; [
arrow
broom
data_table
duckdb
janitor
styler
tidyverse
];
julia = ["DataFramesMeta" "QuackIO"];
};
};
systems = [
"aarch64-darwin"
"x86_64-linux"
"aarch64-linux"
];
forAllSystems = nixpkgs.lib.genAttrs systems;
extra_pkg_config = {
# allowUnfree = true;
};
overlayDefs = import ./overlays inputs;
dependencyOverlays = overlayDefs.dependencyOverlays;
dependencyOverlay = overlayDefs.dependencyOverlay;
mkPkgs = system:
import nixpkgs {
inherit system;
config = extra_pkg_config;
overlays = [dependencyOverlay];
};
module = nixpkgs.lib.modules.importApply ./modules/neovim.nix inputs;
wrapper = wrappers.lib.evalModule module;
in {
overlays = {
default = nixpkgs.lib.composeManyExtensions [
dependencyOverlay
(final: prev: {
n = wrapper.config.wrap {pkgs = final;};
})
];
dependencies = dependencyOverlay;
n = self.overlays.default;
};
wrapperModules = {
default = module;
neovim = self.wrapperModules.default;
};
wrappers = {
default = wrapper.config;
neovim = self.wrappers.default;
};
packages = forAllSystems (
system: let
pkgs = mkPkgs system;
nvimPkg = wrapperSettings pkgs;
in {
default = nvimPkg;
n = nvimPkg;
vim = nvimPkg;
nvim = nvimPkg;
}
);
formatter = forAllSystems (
system: let
pkgs = mkPkgs system;
in
pkgs.nixfmt-tree
);
devShells = forAllSystems (
system: let
pkgs = mkPkgs system;
nvimPkg = wrapperSettings pkgs;
in {
default = pkgs.mkShell {
name = "n";
packages = [nvimPkg];
nativeBuildInputs = with pkgs; [] ++ (pkgs.lib.optionals self.wrappers.default.cats.optional [devenv]);
inputsFrom = [];
shellHook = "";
};
}
);
checks = forAllSystems (
system: let
pkgs = mkPkgs system;
nvimPkg = wrapperSettings pkgs;
in {
default = nvimPkg;
module-eval = let
_ = wrapper.config;
in
pkgs.runCommand "check-module-eval" {} ''
echo "Module evaluation successful" > $out
'';
package-build = pkgs.runCommand "check-n" {} ''
BINARY_PATH="${nvimPkg}/bin/n"
if [ ! -x "$BINARY_PATH" ]; then
echo "Error: Binary n not found or not executable"
exit 1
fi
"$BINARY_PATH" --version > version_output.txt 2>&1 || true
echo "Package validation successful" > $out
echo "Binary location: $BINARY_PATH" >> $out
if [ -s version_output.txt ]; then
echo "Version output:" >> $out
cat version_output.txt >> $out
fi
'';
}
);
nixosModules.default = wrappers.lib.mkInstallModule {
name = "n";
value = module;
};
homeModules.default = wrappers.lib.mkInstallModule {
name = "n";
value = module;
loc = ["home" "packages"];
};
};
}

6
ftplugin/julia.lua Normal file
View file

@ -0,0 +1,6 @@
vim.b.slime_cell_delimiter = vim.b.slime_cell_delimiter or "# %%"
local ts_lib = Config.treesitter_helpers
local global_nodes_julia = { 'source_file', 'module_definition' }
ts_lib.setup_keybindings(global_nodes_julia)

32
ftplugin/markdown.lua Normal file
View file

@ -0,0 +1,32 @@
-- Add the key mappings only for Markdown files in a zk notebook.
if require("zk.util").notebook_root(vim.fn.expand('%:p')) ~= nil then
local map = vim.keymap.set
-- Open the link under the caret.
map("n", "<CR>", "<Cmd>lua vim.lsp.buf.definition()<CR>", { noremap = true, silent = false, buffer = true })
-- Create a new note after asking for its title.
-- This overrides the global `<leader>zn` mapping to create the note in the same directory as the current buffer.
map("n", "<leader>zhn", "<Cmd>ZkNew { dir = vim.fn.expand('%:p:h'), title = vim.fn.input('Title: ') }<CR>",
{ noremap = true, silent = false, buffer = true, desc = "Note (here)" })
-- Create a new note in the same directory as the current buffer, using the current selection for title.
map("v", "<leader>zhnt", ":'<,'>ZkNewFromTitleSelection { dir = vim.fn.expand('%:p:h') }<CR>",
{ noremap = true, silent = false, buffer = true, desc = "Note from selection (title)" })
-- Create a new note in the same directory as the current buffer, using the current selection for note content and asking for its title.
map("v", "<leader>zhnc",
":'<,'>ZkNewFromContentSelection { dir = vim.fn.expand('%:p:h'), title = vim.fn.input('Title: ') }<CR>",
{ noremap = true, silent = false, buffer = true, desc = "Note from selection (content)" })
-- Open notes linking to the current buffer.
map("n", "<leader>zb", "<Cmd>ZkBacklinks<CR>", { noremap = true, silent = false, buffer = true, desc = "Backlinks" })
-- Alternative for backlinks using pure LSP and showing the source context.
--map('n', '<leader>zb', '<Cmd>lua vim.lsp.buf.references()<CR>', opts)
-- Open notes linked by the current buffer.
map("n", "<leader>zL", "<Cmd>ZkLinks<CR>", { noremap = true, silent = false, buffer = true, desc = "Links" })
map("n", "<leader>zi", "<Cmd>ZkInsertLink<CR>", { noremap = true, silent = false, buffer = true, desc = "Insert link" })
-- Preview a linked note.
-- Open the code actions for a visual selection.
map("v", "<leader>za", ":'<,'>lua vim.lsp.buf.range_code_action()<CR>",
{ noremap = true, silent = false, buffer = true, desc = "Code actions" })
end

20
ftplugin/python.lua Normal file
View file

@ -0,0 +1,20 @@
vim.g.slime_python_ipython = 1
vim.b.slime_cell_delimiter = vim.b.slime_cell_delimiter or "# %%"
local ts_lib = Config.treesitter_helpers
local global_nodes_python = { 'module' }
ts_lib.setup_keybindings(global_nodes_python)
local conform_format_group =
vim.api.nvim_create_augroup("PythonConformFormat_" .. vim.api.nvim_get_current_buf(), { clear = true })
vim.api.nvim_create_autocmd("BufWritePre", {
group = conform_format_group,
buffer = 0,
callback = function()
require("conform").format({
timeout_ms = 1000,
lsp_format = "prefer",
})
end,
})

56
ftplugin/r.lua Normal file
View file

@ -0,0 +1,56 @@
vim.b.slime_cell_delimiter = vim.b.slime_cell_delimiter or "## ----"
local assign_action = function()
if vim.bo.filetype ~= "r" then
return
end
local ok, r_edit = pcall(require, "r.edit")
if not ok then
return
end
if MiniTrailspace and MiniTrailspace.trim then
MiniTrailspace.trim()
end
r_edit.assign()
end
vim.api.nvim_buf_create_user_command(0, "RAssign", assign_action, { desc = "Trim trailing space and insert <-" })
-- Settings
vim.bo.comments = [[:#',:####,:###,:##,:#]]
-- Keymaps
-- Note: These use <Plug> mappings provided by R.nvim
vim.keymap.set("n", "<Enter>", "<Plug>RDSendLine", { buffer = true })
vim.keymap.set("v", "<Enter>", "<Plug>RSendSelection", { buffer = true })
-- Assignment operator (--)
vim.keymap.set("i", "--", "<Cmd>lua MiniTrailspace.trim()<CR><Plug>RInsertAssign", { buffer = true, noremap = true })
-- Pipe operator (;;)
vim.keymap.set("i", ";;", "<Cmd>lua MiniTrailspace.trim()<CR><Plug>RInsertPipe<CR>", { buffer = true, noremap = true })
-- MiniClue / WhichKey hints
local r_clues = {
{ mode = "n", keys = "<localleader>a", desc = "+batch" },
{ mode = "n", keys = "<localleader>b", desc = "+between/debug" },
{ mode = "n", keys = "<localleader>c", desc = "+substitute" },
{ mode = "n", keys = "<localleader>f", desc = "+functions" },
{ mode = "n", keys = "<localleader>i", desc = "+install" },
{ mode = "n", keys = "<localleader>k", desc = "+knit" },
{ mode = "n", keys = "<localleader>p", desc = "+paragraph" },
{ mode = "n", keys = "<localleader>r", desc = "+regular" },
{ mode = "n", keys = "<localleader>s", desc = "+selection" },
{ mode = "n", keys = "<localleader>t", desc = "+dput" },
{ mode = "n", keys = "<localleader>u", desc = "+undebug" },
}
vim.b.miniclue_config = {
clues = {
r_clues,
},
triggers = {
{ mode = "n", keys = "<localleader>", desc = "+R" },
},
}

11
ftplugin/sql.lua Normal file
View file

@ -0,0 +1,11 @@
vim.g.omni_sql_default_compl_type = "syntax"
local ts_lib = Config.treesitter_helpers
local global_nodes_sql = { 'program', 'cte' }
ts_lib.setup_keybindings(global_nodes_sql)
-- SQL specific keybindings
vim.keymap.set({ 'n' }, '<localleader>;', function()
vim.api.nvim_call_function('slime#send', { ";\n" })
end,
{ noremap = true, silent = true, desc = "SQL statment return", buffer = true })

28
init.lua Normal file
View file

@ -0,0 +1,28 @@
_G.Config = {}
local nix = require('config.nix').init { non_nix_value = true }
Config.isNixCats = nix.is_nix
require('lze').register_handlers(require('nixCatsUtils.lzUtils').for_cat)
local mini_deps = require('mini.deps')
if not Config.isNixCats then
local path_package = vim.fn.stdpath('data') .. '/site/'
local mini_path = path_package .. 'pack/deps/start/mini.nvim'
if not vim.uv.fs_stat(mini_path) then
vim.cmd('echo "Installing `mini.nvim`" | redraw')
local clone_cmd = {
'git', 'clone', '--filter=blob:none',
'https://github.com/echasnovski/mini.nvim', mini_path
}
vim.fn.system(clone_cmd)
vim.cmd('packadd mini.nvim | helptags ALL')
vim.cmd('echo "Installed `mini.nvim`" | redraw')
end
-- Set up 'mini.deps' (customize to your liking)
mini_deps.setup({ path = { package = path_package } })
else
mini_deps.setup()
end

166
lua/config/nix.lua Normal file
View file

@ -0,0 +1,166 @@
local M = {}
local function detect_nix()
if vim.g.nix_info_plugin_name ~= nil then
return true
end
if vim.g[ [[nixCats-special-rtp-entry-nixCats]] ] ~= nil then
return true
end
return false
end
M.is_nix = detect_nix()
M.non_nix_default = true
local function setup_nixcats(non_nix_value)
if M.is_nix then
return
end
local ok, utils = pcall(require, "nixCatsUtils")
if ok and utils and utils.setup then
utils.setup { non_nix_value = non_nix_value }
end
end
local function init_from_nix_info()
if vim.g.nix_info_plugin_name == nil then
return nil
end
local ok, nix_info = pcall(require, vim.g.nix_info_plugin_name)
if not ok or not nix_info then
return nil
end
local function cat_lookup(cat)
if type(cat) == "table" then
for _, name in ipairs(cat) do
if nix_info(false, "settings", "cats", name) or nix_info(false, "info", "cats", name) then
return true
end
end
return false
end
return nix_info(false, "settings", "cats", cat) or nix_info(false, "info", "cats", cat)
end
local nc = setmetatable({
cats = nix_info.settings and nix_info.settings.cats or {},
settings = nix_info.settings or {},
get = function(_, default, ...) return nix_info(default, ...) end,
}, {
__call = function(_, default, ...)
if select("#", ...) == 0 then
return cat_lookup(default)
end
return nix_info(default, ...)
end,
__index = nix_info,
})
_G.nixCats = nc
package.preload['nixCats.cats'] = function()
return setmetatable(_G.nixCats.cats or {}, getmetatable(_G.nixCats))
end
return nc
end
local function get_nixcats()
if _G.nixCats then
return _G.nixCats
end
local nc = init_from_nix_info()
if nc then
return nc
end
local ok, nc_module = pcall(require, "nixCats")
if ok and nc_module then
return nc_module
end
return nil
end
function M.init(opts)
local non_nix_value = true
if type(opts) == "table" and type(opts.non_nix_value) == "boolean" then
non_nix_value = opts.non_nix_value
end
M.non_nix_default = non_nix_value
setup_nixcats(non_nix_value)
get_nixcats()
M.is_nix = detect_nix()
return M
end
local function cat_enabled(nc, cat, default)
if not nc then
return default
end
if type(cat) == "table" then
for _, name in ipairs(cat) do
if nc(name) then
return true
end
end
return default
end
local val = nc(cat)
if val == nil then
return default
end
return val
end
function M.get_cat(cat, default)
if default == nil then
default = M.non_nix_default
end
if not M.is_nix then
return default
end
local nc = get_nixcats()
return cat_enabled(nc, cat, default)
end
function M.get_setting(default, ...)
if not M.is_nix then
return default
end
local nc = get_nixcats()
if not nc then
return default
end
local value = nc(default, "settings", ...)
if value == nil then
return default
end
return value
end
function M.get_info(default, ...)
if not M.is_nix then
return default
end
local nc = get_nixcats()
if not nc then
return default
end
local value = nc(default, "info", ...)
if value == nil then
return default
end
return value
end
return M

129
lua/nixCatsUtils/init.lua Normal file
View file

@ -0,0 +1,129 @@
--[[
This directory is the luaUtils template.
You can choose what things from it that you would like to use.
And then delete the rest.
Everything in this directory is optional.
--]]
local M = {}
--[[
This file is for making your config still work WITHOUT nixCats.
When you don't use nixCats to load your config,
you wont have the nixCats plugin.
The setup function defined here defines a mock nixCats plugin when nixCats wasnt used to load the config.
This will help avoid indexing errors when the nixCats plugin doesnt exist.
NOTE: If you only ever use nixCats to load your config, you don't need this file.
--]]
---@type boolean
M.isNixCats = vim.g.nix_info_plugin_name ~= nil or vim.g[ [[nixCats-special-rtp-entry-nixCats]] ] ~= nil
---@class nixCatsSetupOpts
---@field non_nix_value boolean|nil
---This function will setup a mock nixCats plugin when not using nix
---It will help prevent you from running into indexing errors without a nixCats plugin from nix.
---If you loaded the config via nix, it does nothing
---non_nix_value defaults to true if not provided or is not a boolean.
---@param v nixCatsSetupOpts
function M.setup(v)
if not M.isNixCats then
local nixCats_default_value
if type(v) == "table" and type(v.non_nix_value) == "boolean" then
nixCats_default_value = v.non_nix_value
else
nixCats_default_value = true
end
local mk_with_meta = function (tbl)
return setmetatable(tbl, {
__call = function(_, attrpath)
local strtable = {}
if type(attrpath) == "table" then
strtable = attrpath
elseif type(attrpath) == "string" then
for key in attrpath:gmatch("([^%.]+)") do
table.insert(strtable, key)
end
else
print("function requires a table of strings or a dot separated string")
return
end
return vim.tbl_get(tbl, unpack(strtable));
end
})
end
package.preload['nixCats'] = function ()
local ncsub = {
get = function(_) return nixCats_default_value end,
cats = mk_with_meta({
nixCats_config_location = vim.fn.stdpath('config'),
wrapRc = false,
}),
settings = mk_with_meta({
nixCats_config_location = vim.fn.stdpath('config'),
configDirName = os.getenv("NVIM_APPNAME") or "nvim",
wrapRc = false,
}),
petShop = mk_with_meta({}),
extra = mk_with_meta({}),
pawsible = mk_with_meta({
allPlugins = {
start = {},
opt = {},
},
}),
configDir = vim.fn.stdpath('config'),
packageBinPath = os.getenv('NVIM_WRAPPER_PATH_NIX') or vim.v.progpath
}
return setmetatable(ncsub, {__call = function(_, cat) return ncsub.get(cat) end})
end
_G.nixCats = require('nixCats')
end
end
---allows you to guarantee a boolean is returned, and also declare a different
---default value than specified in setup when not using nix to load the config
---@overload fun(v: string|string[]): boolean
---@overload fun(v: string|string[], default: boolean): boolean
function M.enableForCategory(v, default)
if M.isNixCats or default == nil then
if nixCats(v) then
return true
else
return false
end
else
return default
end
end
---if nix, return value of nixCats(v) else return default
---Exists to specify a different non_nix_value than the one in setup()
---@param v string|string[]
---@param default any
---@return any
function M.getCatOrDefault(v, default)
if M.isNixCats then
return nixCats(v)
else
return default
end
end
---for conditionally disabling build steps on nix, as they are done via nix
---I should probably have named it dontAddIfCats or something.
---@overload fun(v: any): any|nil
---Will return the second value if nix, otherwise the first
---@overload fun(v: any, o: any): any
function M.lazyAdd(v, o)
if M.isNixCats then
return o
else
return v
end
end
return M

View file

@ -0,0 +1,37 @@
--[[
This directory is the luaUtils template.
You can choose what things from it that you would like to use.
And then delete the rest.
Everything in this directory is optional.
--]]
local M = {}
local nix = require('config.nix')
-- A nixCats specific lze handler that you can use to conditionally enable by category easier.
-- at the start of your config, register with
-- require('lze').register_handlers(require('nixCatsUtils.lzUtils').for_cat)
-- before any calls to require('lze').load using the handler have been made.
-- accepts:
-- for_cat = { "your" "cat" };
-- for_cat = { cat = { "your" "cat" }, default = bool }
-- for_cat = "your.cat";
-- for_cat = { cat = "your.cat", default = bool }
-- where default is an alternate value for when nixCats was NOT used to install the config
M.for_cat = {
spec_field = "for_cat",
set_lazy = false,
modify = function(plugin)
if type(plugin.for_cat) == "table" and plugin.for_cat.cat ~= nil then
local default = plugin.for_cat.default
if default == nil then
default = false
end
plugin.enabled = nix.get_cat(plugin.for_cat.cat, default)
else
plugin.enabled = nix.get_cat(plugin.for_cat, false)
end
return plugin
end,
}
return M

196
lua/nix_smart_send.lua Normal file
View file

@ -0,0 +1,196 @@
local M = {}
-- Helper function to check if value exists in list (optimized with early return)
local function is_in_list(list, value)
if not list or not value then
return false
end
for _, v in ipairs(list) do
if v == value then
return true
end
end
return false
end
-- Define comment node types as constants
local COMMENT_TYPES = {
comment = true,
block_comment = true,
line_comment = true,
}
function M.get_current_node()
local ts_utils = require('nvim-treesitter.ts_utils')
local cur_win = vim.api.nvim_get_current_win()
return ts_utils.get_node_at_cursor(cur_win, true)
end
function M.detect_global_node()
local cur_node = M.get_current_node()
local root
if not cur_node then
-- print("No node detected")
local parser = vim.treesitter.get_parser()
if not parser then
return nil
end
root = parser:parse()[1]:root()
else
root = cur_node:root()
end
if not root then
return nil
end
return root:type()
end
function M.move_to_next_non_empty_line()
local ts_utils = require('nvim-treesitter.ts_utils')
-- Search for the next non-empty line
local line_num = vim.fn.search("[^;\\s]", "W")
if line_num <= 0 then
-- print("No non-empty line found below the current position")
return false
end
-- Get the line content and find first non-whitespace character
local line_content = vim.api.nvim_buf_get_lines(0, line_num - 1, line_num, false)[1]
local first_non_ws = line_content:find("%S") or 1
vim.api.nvim_win_set_cursor(0, { line_num, first_non_ws - 1 })
local node = M.get_current_node()
if not node or not node:type() then
-- print("No node found")
return false
end
local global_node_type = M.detect_global_node()
-- Skip comments and global nodes
while node and (COMMENT_TYPES[node:type()] or node:type() == global_node_type) do
line_num = line_num + 1
local max_lines = vim.api.nvim_buf_line_count(0)
if line_num > max_lines then
-- print("Reached end of buffer")
return false
end
-- Get the line content and find first non-whitespace character
line_content = vim.api.nvim_buf_get_lines(0, line_num - 1, line_num, false)[1]
first_non_ws = line_content:find("%S") or 1
vim.api.nvim_win_set_cursor(0, { line_num, first_non_ws - 1 })
node = ts_utils.get_node_at_cursor()
end
return true
end
function M.vselect_node(node)
local ts_utils = require('nvim-treesitter.ts_utils')
if not node then
return false
end
local cur_buf = vim.api.nvim_get_current_buf()
ts_utils.update_selection(cur_buf, node, "V")
return true
end
function M.select_until_global(global_nodes)
local ts_utils = require('nvim-treesitter.ts_utils')
local root_node = M.detect_global_node()
if not root_node and global_nodes then
root_node = global_nodes[1]
end
-- Use empty table if no global nodes provided
global_nodes = global_nodes or {}
local node = ts_utils.get_node_at_cursor()
if not node then
-- print("No syntax node found at cursor position")
return nil
end
local node_type = node:type()
if node_type == root_node then
-- print("Cursor is on the root " .. root_node .. " node or in an empty area.")
return nil
end
-- Check if current node is a global
if is_in_list(global_nodes, node_type) then
if M.vselect_node(node) then
return node
end
end
-- Traverse up the tree until we find a global node or reach the root
local parent = node:parent()
local parent_type = parent:type() or ""
if parent and is_in_list(global_nodes, parent_type) then
if M.vselect_node(node) then
return node
end
end
while parent and not is_in_list(global_nodes, parent:type()) do
node = parent
parent = node:parent()
end
if M.vselect_node(node) then
return node
end
return nil
end
function M.slime_send_region()
-- Check if slime plugin is available
if not vim.fn.exists('*slime#send_op') then
vim.notify("slime plugin not available", vim.log.levels.ERROR)
return
end
local slime_command = ":<C-u>call slime#send_op(visualmode(), 1)<CR>"
local termcodes = vim.api.nvim_replace_termcodes(slime_command, true, true, true)
vim.api.nvim_feedkeys(termcodes, "x", true)
end
function M.send_repl(global_nodes)
local ts_utils = require('nvim-treesitter.ts_utils')
local cur_node = M.get_current_node()
if not cur_node then
M.move_to_next_non_empty_line()
else
local cur_type = cur_node:type()
if COMMENT_TYPES[cur_type] or is_in_list(global_nodes, cur_type) then
M.move_to_next_non_empty_line()
end
end
local sel_node = M.select_until_global(global_nodes)
if not sel_node then
-- print("No node selected for REPL")
return
end
-- Send the selected text to the terminal using vim-slime
M.slime_send_region()
-- Move cursor and continue
ts_utils.goto_node(sel_node, true)
M.move_to_next_non_empty_line()
end
return M

View file

@ -0,0 +1,51 @@
{
config,
lib,
...
}:
{
options.cats = lib.mkOption {
type = lib.types.attrsOf lib.types.bool;
description = ''
Category toggles used to enable/disable specs by name.
Keys map directly to specs (e.g., `python` controls `specs.python`).
Set a category to `false` to skip its dependency/plugin specs.
Available categories:
- clickhouse: Clickhouse client and tools
- customPlugins: local plugin specs
- external: external tools and integrations
- general: core Neovim plugins/features
- gitPlugins: git-related plugins
- julia: Julia tooling and packages
- lua: Lua tooling and LSPs
- markdown: markdown tooling and plugins
- nix: Nix tooling and plugins
- optional: optional tools and utilities
- python: Python tooling and plugins
- r: R tooling and plugins
- test: test-only tooling (disabled by default)
- treesitterParsers: Treesitter parsers
- utils: general utilities
'';
};
config.cats = {
clickhouse = lib.mkDefault false;
customPlugins = lib.mkDefault true;
external = lib.mkDefault true;
general = lib.mkDefault true;
gitPlugins = lib.mkDefault true;
julia = lib.mkDefault false;
lua = lib.mkDefault false;
markdown = lib.mkDefault false;
nix = lib.mkDefault false;
optional = lib.mkDefault false;
python = lib.mkDefault false;
r = lib.mkDefault false;
test = lib.mkDefault false;
treesitterParsers = lib.mkDefault true;
utils = lib.mkDefault true;
};
}

View file

@ -0,0 +1,35 @@
{
config,
lib,
...
}:
{
# Point to the directory containing init.lua, plugin/, lua/, etc.
config.settings.config_directory = ../../..;
# Default colorscheme and background
config.settings.colorscheme = "kanagawa";
config.settings.background = "dark";
# Enable RC wrapping (allows neovim to find the config)
config.settings.wrapRc = true;
# Lua packages available to neovim (for :lua require())
config.settings.nvim_lua_env = lp:
lib.optionals (config.cats.general or false) [ lp.tiktoken_core ];
# Binary name for the wrapper
config.binName = "n";
# Prevent neovim from loading system-wide config
config.settings.block_normal_config = true;
# Don't symlink the config (we wrap it instead)
config.settings.dont_link = false;
# Create additional aliases for the binary
config.settings.aliases = [ "vim" ];
# Enable wrapper handling of spec runtimeDeps (template pattern).
config.settings.autowrapRuntimeDeps = true;
}

View file

@ -0,0 +1,27 @@
{
config,
pkgs,
lib,
...
}:
{
# Environment variables set for the wrapper.
# These are available when running neovim.
config.env = lib.mkMerge [
(lib.mkIf (config.cats.r or false) {
R_LIBS_USER = "./.Rlibs";
})
(lib.mkIf (config.cats.python or false) {
UV_PYTHON_DOWNLOADS = "never";
UV_PYTHON = pkgs.python.interpreter;
})
(lib.mkIf (config.cats.test or false) {
TESTVAR = "It worked!";
})
];
# Environment variables with defaults (can be overridden by user)
config.envDefault = lib.mkIf (config.cats.test or false) {
TESTVAR2 = "It worked again!";
};
}

View file

@ -0,0 +1,57 @@
{
config,
pkgs,
lib,
...
}:
{
config.hosts = lib.mkMerge [
{
node.nvim-host.enable = true;
perl.nvim-host.enable = true;
ruby.nvim-host.enable = true;
g = {
nvim-host.enable = true;
nvim-host.package = "${pkgs.neovide}/bin/neovide";
nvim-host.argv0 = "neovide";
nvim-host.flags."--neovim-bin" = "${placeholder "out"}/bin/${config.binName}";
};
m = {
nvim-host.enable = false;
nvim-host.package = "${pkgs.uv}/bin/uv";
nvim-host.argv0 = "uv";
nvim-host.addFlag = [
"run"
"marimo"
"edit"
];
};
}
(lib.mkIf (config.cats.julia or true) {
jl = {
nvim-host.enable = true;
nvim-host.package = "${pkgs.julia-bin}/bin/julia";
nvim-host.argv0 = "julia";
nvim-host.addFlag = [
"--project=@."
];
};
})
(lib.mkIf (config.cats.python or true) {
python3.nvim-host.enable = true;
})
(lib.mkIf (config.cats.r or true) {
r = {
nvim-host.enable = true;
nvim-host.package = "${pkgs.rWrapper}/bin/R";
nvim-host.argv0 = "R";
nvim-host.addFlag = [
"--no-save"
"--no-restore"
];
};
})
];
}

View file

@ -0,0 +1,39 @@
{
config,
lib,
...
}:
{
options.settings.lang_packages = lib.mkOption {
type = lib.types.submodule {
options = {
python = lib.mkOption {
type = lib.types.listOf lib.types.package;
default = [ ];
description = "Additional Python-related packages appended to the python spec (overlay defaults remain).";
};
r = lib.mkOption {
type = lib.types.listOf lib.types.package;
default = [ ];
description = "Additional R-related packages appended to the r spec (overlay defaults remain).";
};
julia = lib.mkOption {
type = lib.types.listOf lib.types.str;
default = [ ];
description = "Additional Julia packages (names) passed to julia-bin.withPackages.";
};
};
};
default = { };
description = ''
Language-specific package overrides appended to each language spec's extraPackages.
Intended for flake.nix overrides via wrapper.config.wrap.
'';
};
config.settings.lang_packages = {
python = lib.mkDefault [ ];
r = lib.mkDefault [ ];
julia = lib.mkDefault [ ];
};
}

View file

@ -0,0 +1,35 @@
{
config,
lib,
...
}:
let
collect_runtime_packages = runtime_deps_type:
config.specCollect
(acc: spec:
let
is_enabled = if spec ? enable then spec.enable else true;
has_runtime_deps = (spec.runtimeDeps or false) == runtime_deps_type;
packages = spec.extraPackages or [ ];
in
acc ++ lib.optionals (is_enabled && has_runtime_deps) packages
)
[ ];
prefix_packages = collect_runtime_packages "prefix";
suffix_packages = collect_runtime_packages "suffix";
to_path_specs = packages: [
{
data = [
"PATH"
":"
"${lib.makeBinPath packages}"
];
}
];
in
{
config.prefixVar = lib.optionals (prefix_packages != [ ]) (to_path_specs prefix_packages);
config.suffixVar = lib.optionals (suffix_packages != [ ]) (to_path_specs suffix_packages);
}

Some files were not shown because too many files have changed in this diff Show more