cred: more internet credentials

.envrc

@@ -1,16 +1,6 @@
-#! /bin/sh
-
-source "$(
-  nix eval \
-  --no-update-lock-file \
-  --no-write-lock-file \
-  --no-warn-dirty \
-  --accept-flake-config \
-  .#__std.direnv_lib 2>/dev/null \
-  || nix eval .#__std.direnv_lib # show the errors
-)"
-# FIXME: This should check if $USER is in userShells, if not,
-# fall back to `use nix`
-use std nix "//repo/userShells:${USER}"
-
+# If nix-shell available, then nix is installed. We're going to use nix-direnv.
+if command -v nix-shell &> /dev/null
+then
+    use flake
+fi
 

.gitignore

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

.sops.yaml

@@ -3,7 +3,6 @@ keys:
   - &htran     age1jw958shpwu7st8sc4z0fufuswmfpxfc9wl3df9g3f3y57m45j92syr0mng
   - &bao       age1umzkd4k0xt6uv5de85fpc4uztrph86nsd79h5f8cpuvtpy8n6adss7q2fv
   - &root_bao  age1vx7e6vz9zptwqd0cakjj8erqv58cstddama8zcrppc36rqqmlvjs53x9u0
-  - &htran1    age1vkd39dmrft3uk5wnfqppharn38dhrh78ev6pl85u005jhcge5e9qz4lt79
 creation_rules:
   - path_regex: .*
     key_groups:
@@ -12,5 +11,4 @@ creation_rules:
       - *htran-mbp
       - *bao
       - *root_bao
-      - *htran1
 

README.md

@@ -5,10 +5,6 @@ Contains my configurations for the software I use.
 I'm looking to move forward to configuration with NixOS, but until I get
 a bit more experiment on NixOS, I'll keep this repository as simple as possible.
 
-- As of 2023-06-07, I have little interest in keeping configurations 
-([`init.lua`](./native_configs/neovim/init.lua), [`sshconfig`](./native_configs/ssh/config),...) 
-to be idempotent for Nix and non-Nix targets.
-
 ## Nix
 
 Monorepo that contains my commonly used personal environments.
@@ -17,7 +13,8 @@ onto this repo for quick env setup (especially devel) on new machines.
 
 ## How do I apply these config
 
-- Clone and nixify
+- I will always first clone this repository, preferably from local source before
+going from the github. `git clone https://github.com/pegasust/dotfiles`
 
 ### neovim
 
@@ -29,6 +26,7 @@ My main text editor. It's based on `vim`, but stays loyal to `lua` ecosystem
 #### Notes
 
 - Ensure that neovim is installed and invocable by `nvim`.
+- My config based on rather experimental version of`nvim` (>=0.7.2)
 - For information on installing neovim, visit their [github page](https://github.com/neovim/neovim/wiki/Installing-Neovim)
 
 ### tmux
@@ -42,7 +40,7 @@ from one terminal.
 
 #### Notes
 
-- Unsure of the minimum version of tmux. I have had an ancient HPC server
+- Unsure if the minimum version of tmux. I have had an ancient HPC server
 that does not respond well to one of the config lines.
 
 ### zk
@@ -59,23 +57,4 @@ text-editor agnostically.
 - Templates: `zk/templates/`
 - Command: `ln -s $PWD/zk/templates ~/.config/zk/templates`
 
-Note (2023-06-07): I'm now using a mix of nvim-zk with Notion. I'm still figuring out
-a centralize place to put my notes and use it to do some knowledge graph magic
-
-## Troubleshoots
-
-### My MacOS just updated, `nix` is no-longer here
-
-- An easy fix is to add the following  to the **bottom** of `/etc/zshrc`
-
-```sh
-# Nix {{{
-if [ -e '/nix/var/nix/profiles/default/etc/profile.d/nix-daemon.sh' ]; then
-  . '/nix/var/nix/profiles/default/etc/profile.d/nix-daemon.sh'
-fi
-# }}} 
-```
-
-- Otherwise, consult [`gh-gist:meeech/a_help-osx-borked-my-nix.md`](https://gist.github.com/meeech/0b97a86f235d10bc4e2a1116eec38e7e)
-
 

c_.nix

@@ -0,0 +1,111 @@
+# a small helper that only builds on top of builtins functions
+_: (builtins // (
+  let
+    formatSecondsSinceEpoch = t:
+      let
+        rem = x: y: x - x / y * y;
+        days = t / 86400;
+        secondsInDay = rem t 86400;
+        hours = secondsInDay / 3600;
+        minutes = (rem secondsInDay 3600) / 60;
+        seconds = rem t 60;
+
+        # Courtesy of https://stackoverflow.com/a/32158604.
+        z = days + 719468;
+        era = (if z >= 0 then z else z - 146096) / 146097;
+        doe = z - era * 146097;
+        yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
+        y = yoe + era * 400;
+        doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+        mp = (5 * doy + 2) / 153;
+        d = doy - (153 * mp + 2) / 5 + 1;
+        m = mp + (if mp < 10 then 3 else -9);
+        y' = y + (if m <= 2 then 1 else 0);
+
+        pad = s: if builtins.stringLength s < 2 then "0" + s else s;
+      in
+      "${toString y'}${pad (toString m)}${pad (toString d)}${pad (toString hours)}"
+        + "${pad (toString minutes)}${pad (toString seconds)}";
+
+    fetchTree =
+      # this is the value of flake.lock#lock.nodes.${input_name}.locked
+      { type
+      , host ? ""
+      , owner ? ""
+      , repo ? ""
+      , rev ? ""
+      , submodules ? ""
+      , path ? ""
+      , narHash ? null
+      , lastModified ? 0
+      , src ? ./.
+      }@info:
+      if info.type == "github" then
+        {
+          outPath =
+            fetchTarball
+              ({
+                url = "https://api.${info.host or "github.com"}/repos/"
+                  + "${info.owner}/${info.repo}/tarball/${info.rev}";
+              }
+              // (if info ? narHash then { sha256 = info.narHash; } else { })
+              );
+          rev = info.rev;
+          shortRev = builtins.substring 0 7 info.rev;
+          lastModified = info.lastModified;
+          lastModifiedDate = formatSecondsSinceEpoch info.lastModified;
+          narHash = info.narHash;
+        }
+      else if info.type == "git" then
+        {
+          outPath =
+            builtins.fetchGit
+              ({ url = info.url; }
+                // (if info ? rev then { inherit (info) rev; } else { })
+                // (if info ? ref then { inherit (info) ref; } else { })
+                // (if info ? submodules then { inherit (info) submodules; } else { })
+              );
+          lastModified = info.lastModified;
+          lastModifiedDate = formatSecondsSinceEpoch info.lastModified;
+          narHash = info.narHash;
+        } // (if info ? rev then {
+          rev = info.rev;
+          shortRev = builtins.substring 0 7 info.rev;
+        } else { })
+      else if info.type == "path" then
+        {
+          outPath = builtins.path {
+            path =
+              if builtins.substring 0 1 info.path != "/"
+              then src + ("/" + info.path)  # make this absolute path by prepending ./
+              else info.path; # it's already an absolute path
+          };
+          narHash = info.narHash;
+        }
+      else if info.type == "tarball" then
+        {
+          outPath =
+            fetchTarball
+              ({ inherit (info) url; }
+                // (if info ? narHash then { sha256 = info.narHash; } else { })
+              );
+        }
+      else if info.type == "gitlab" then
+        {
+          inherit (info) rev narHash lastModified;
+          outPath =
+            fetchTarball
+              ({ url = "https://${info.host or "gitlab.com"}/api/v4/projects/${info.owner}%2F${info.repo}/repository/archive.tar.gz?sha=${info.rev}"; }
+                // (if info ? narHash then { sha256 = info.narHash; } else { })
+              );
+          shortRev = builtins.substring 0 7 info.rev;
+        }
+      else
+      # FIXME: add Mercurial, tarball inputs.
+        throw "flake input has unsupported input type '${info.type}'";
+  in
+  {
+    inherit fetchTree;
+  }
+)) nil
+

credentials.yml

@@ -1,9 +1,4 @@
 credentials:
-    - kind:
-        name_unencrypted: kv
-      name_unencrypted: ci@dev1.htran.egihosting.com
-      user_unencrypted: ci
-      password: ENC[AES256_GCM,data:4AIDKxX9dQncyhHe,iv:+YbvHz6GLD9unbTwE/KwcdpU/yMygFurxelOjkrFJRU=,tag:VHnzt66W2pWwcxjTH9LreQ==,type:str]
     - kind:
         name_unencrypted: kv
       name_unencrypted: Gitea credentials
@@ -45,9 +40,14 @@ credentials:
       password: ENC[AES256_GCM,data:YOL5Sw6zaA==,iv:Cs8gySfGIQUBPivkM5N6kflZsRhp2w9xmPwtl7RrEZE=,tag:LXYKdsX++IP+jQyjL6JBrg==,type:str]
     - kind:
         name_unencrypted: kv
-      name_unencrypted: gl-deploy-token
-      user_unencrypted: gitlab+deploy-token-2
-      pass_unencrpyted: ENC[AES256_GCM,data:GcPu8JFy8JuPb3xrHKBpP196h0k=,iv:2N69xdTtnpjDLvRAbSpDWGh6+IFWpIZgHo6yVf2kE/4=,tag:L7UA7Oj/ZtekO3Cmvp2lvA==,type:str]
+      name_unencrypted: CloudFlare (pegasust.com)
+      user_unencrypted: htrslwr@gmail.com
+      password: ENC[AES256_GCM,data:Qr7U6nWLdF1NRdpB,iv:2HWfY6pJqY3qYooiiUdTe0DLQMjj+bjqeAnlIzjewmI=,tag:PC8yDyCkGsBFX6eGMY4V4A==,type:str]
+    - kind:
+        name_unencrypted: kv
+      name_unencrypted: iDrive
+      user_unencrypted: pegasucksgg@gmail.com
+      password: ENC[AES256_GCM,data:cxCmkYhIIukuNg==,iv:uGx87aPxA9CaIFwefA0+o4zio1FdghUi6n1Rfn1Yudk=,tag:h1kWxBjSrmDocasdQrOkfg==,type:str]
 sops:
     kms: []
     gcp_kms: []
@@ -90,8 +90,8 @@ sops:
             cWxIRyszNmlpN2twMElIL3JCcHdOcHMKMT7Xq+XsSAdkJ1CAWRqdQTrr1NhPeTUc
             UT0Fa8zUCBTUZEhcmVAnZ4Crr6N2GQbtNOU2S9Jt++od1dxQ+9TjHA==
             -----END AGE ENCRYPTED FILE-----
-    lastmodified: "2023-02-28T17:54:36Z"
-    mac: ENC[AES256_GCM,data:uI84H7eyWsauw2RMysa8w/OHP4QXN+FvO/GW+orj86cTlfL521MdPgZZamtSxOeyb4+893jn09GSFUBmOdQHUOX3kGNdWNwpu7eXM1ext/cpZwCsaIDBWDyCCE6LcF69LQEKsbRlC1nDAeMW3Wn510teS/TFxgbRucNdGTnrRE0=,iv:PbjX7VTDkAi0O/pipgV70KbJD/LLJAmD/U7d2kn58DM=,tag:dMsU71CPnO8JHyXoWPcFaQ==,type:str]
+    lastmodified: "2023-02-22T18:27:32Z"
+    mac: ENC[AES256_GCM,data:KkcXQ19Xy3GJRo+Khga9ncR02SaZQVJsNnOiVSZQv8oXvVTl8+JG9xXVc+DgbDr00F9pcON14Bs3xCkiK9feADGOF7eB8gmWn1G6DfbXXPEhiB/hGwKkfhphQc89IuW9CZtgw5XHwnvW5NZgJxoCPky/YBrfp3mmVE30GxnfVHM=,iv:HZYUclOvBUHT5WTRS2TgM8OzbnXzYLhlvWKJfVZC7lY=,tag:pibeyFd5bfGk3w1EFg2HYg==,type:str]
     pgp: []
     unencrypted_suffix: _unencrypted
     version: 3.7.3

default.nix

@@ -1,6 +1,5 @@
 # We use top-level nix-flake, so default.nix is basically just a wrapper around ./flake.nix
-(
-  import
+(import
   (
     let 
       lock = builtins.fromJSON (builtins.readFile ./flake.lock);
@@ -9,5 +8,4 @@
     c_.fetchTree lock.nodes.flake-compat.locked
   )
   { src = ./.; }
-)
-.defaultNix
+).defaultNix

dev-shell.nix

@@ -4,27 +4,22 @@
 # Should also incorporate shortcuts like scripts/{hm-switch,conf-sysnix}.sh in here instead
 #
 # It should not contain PDE
-{
-  pkgs ? import <nixpkgs> {},
-  lib,
-  ...
-}:
-pkgs.mkShell {
+{ pkgs ? import <nixpkgs> { }
+, lib
+, ...
+}: pkgs.mkShell {
   # mkShell doesn't care about the differences across nativeBuildInputs,
   # buildInputs, or packages
   buildInputs = [
     # shell scripts
+    (lib.shellAsDrv { script = ''echo "hello world"''; pname = "hello"; })
+    # TODO: decompose hm-switch.sh with a base version (where HOME_MANAGER_BIN is injected)
+    # (lib.shellAsDrv {script = builtins.readFile ./scripts/hm-switch.sh; pname = "hm-switch";})
     pkgs.rust4cargo
     pkgs.sops
-    pkgs.ssh-to-age
-    pkgs.go
-    pkgs.gopls
   ];
 
-  shellHook = ''
-    # Since we need late dispatch of ~, we have to put this in shellHook.
-    export SOPS_AGE_KEY_FILE=~/.config/sops/age/keys.txt
-  '';
   # env vars
   lol = "hello world";
 }
+

docs/DEV.md

@@ -28,7 +28,7 @@ documentations and defaults
 
 - `nativeBuildInputs` is supposed to be built by a deployment machine (not target)
 
-- `buildInputs` gives you access during runtime (if the package goes path build filter)
+- `buildInputs` gives you access during runtime
 
 - `nativeBulidInputs` gives you access to packages during build time
 

docs/manual-test/tailwind-color-cmp.md

@@ -1,12 +0,0 @@
-# Neovim: Testing cmp for color with Tailwind
-
-- [ ] It should detect a project uses tailwind, maybe via some kind of config file 
-(`tailwind.config.{cjs,mjs,js,ts,json,tsx,toml,yaml}`), or just based on the 
-string content or via tree-stiter. Check this by `:LspInfo` and `tailwindcss-lsp`
-should attach to the current buffer that has tailwind-css string
-- [ ] Type in a classname `text-red-500`, just stop at somewhere and start
-browsing the cmp-lsp window. It should show a color in place of `lspkind`.
-This validates `tailwindcss-colorizer-cmp.nvim` is good
-- [ ] Hit that autocomplete, the string should show the color red. This validates
-`nvim-colorizer.lua` is properly setup.
-

docs/vim-plugins.md

@@ -1,169 +0,0 @@
-# Offset Vim Plugins onto nix packer
-
-The current [`scripts/vim.dsl`](../scripts/vim.dsl) grabs the upstream supported vim plugins
-onto a sqlite database to be stored in memory. We could perform some data exploration via this database 
-
-## Explore which plugins should be added to `neovim.nix`
-
-Gather list of plugins need to be added. This can be done simply by adding 
-a print statement on `WPlug` in `../native_configs/neovim/init.lua` then run neovim
-to collect it.
-
-```lua
--- as of git://./dotfiles.git#a6c979c6
-local function WPlug(plugin_path, ...)
-  local plugin_name = string.lower(plugin_path:match("/([^/]+)$"))
-  if not installed_plugins[plugin_name] then
-    -- NOTE: Add print statement to get which plugin is still being
-    -- plugged at runtime
-    print("Plugging "..plugin_path)
-    Plug(plugin_path, ...)
-  end
-end
-```
-
-We can then use `vim_dsl.py`
-
-```py
-  vp = VimPlugins(UPSTREAM_CSV)
-  need_install_plugins = """
-tjdevries/nlua.nvim
-yioneko/nvim-yati
-nathanalderson/yang.vim
-numToStr/Comment.nvim
-lewis6991/gitsigns.nvim
-tpope/vim-fugitive
-williamboman/mason.nvim
-williamboman/mason-lspconfig.nvim
-TimUntersberger/neogit
-folke/trouble.nvim
-tpope/vim-dispatch
-clojure-vim/vim-jack-in
-radenling/vim-dispatch-neovim
-gennaro-tedesco/nvim-jqx
-kylechui/nvim-surround
-simrat39/inlay-hints.nvim
-gruvbox-community/gruvbox
-nvim-lualine/lualine.nvim
-lukas-reineke/indent-blankline.nvim
-kyazdani42/nvim-web-devicons
-m-demare/hlargs.nvim
-folke/todo-comments.nvim
-nvim-treesitter/playground
-saadparwaiz1/cmp_luasnip
-L3MON4D3/LuaSnip
-arthurxavierx/vim-caser
-~/local_repos/ts-ql
-  """.split()
-  need_install_plugins = [plugin.strip() for plugin in plugins_raw if plugin.strip()]
-
-  # Create the GitHub URL list
-  need_install_plugins_gh = [
-    f"https://github.com/{plugin}/".lower() for plugin in need_install_plugins if not plugin.startswith(("~", "."))]
-
-  # Get the values from the database
-  values = vp.query(f"SELECT LOWER(repo), alias from {vp.table_name()}")
-
-  # Check if the repo is in the list of plugins
-  need_install = [
-    vim_plugin_slug(alias) if alias else name_from_repo(repo) for repo, alias in values if repo in need_install_plugins_gh]
-
-  print("need_install", "\n".join(need_install))
-
-  # Check if the repo is not in the list
-  repos = [repo for repo, _ in values]
-  not_in_repo = [name_from_repo(gh) for gh in need_install_plugins_gh if gh not in repos]
-  print("not in repo", not_in_repo) # nvim-yati, yang-vim, Comment-nvim, inlay-hints-nvim, hlargs-nvim, vim-caser, gruvbox-community
-```
-
-This should print out
-```
-need_install
-cmp_luasnip
-comment-nvim
-gitsigns-nvim
-gruvbox-community
-indent-blankline-nvim
-lualine-nvim
-luasnip
-mason-lspconfig-nvim
-mason-nvim
-neogit
-nlua-nvim
-nvim-jqx
-nvim-surround
-nvim-web-devicons
-playground
-todo-comments-nvim
-trouble-nvim
-vim-dispatch
-vim-dispatch-neovim
-vim-fugitive
-vim-jack-in
-not in repo ['nvim-yati', 'yang-vim', 'inlay-hints-nvim', 'hlargs-nvim', 'vim-caser']
-```
-
-Given this list, we could safely add to `neovim.nix`
-
-```nix
-programs.neovim.plugins = 
- let inherit (pkgs.vimPlugins)
-    need_install
-    cmp_luasnip
-    comment-nvim
-    gitsigns-nvim
-    gruvbox-community
-    indent-blankline-nvim
-    lualine-nvim
-    luasnip
-    mason-lspconfig-nvim
-    mason-nvim
-    neogit
-    nlua-nvim
-    nvim-jqx
-    nvim-surround
-    nvim-web-devicons
-    playground
-    todo-comments-nvim
-    trouble-nvim
-    vim-dispatch
-    vim-dispatch-neovim
-    vim-fugitive
-    vim-jack-in
- ;in [
-    need_install
-    cmp_luasnip
-    comment-nvim
-    gitsigns-nvim
-    gruvbox-community
-    indent-blankline-nvim
-    lualine-nvim
-    luasnip
-    mason-lspconfig-nvim
-    mason-nvim
-    neogit
-    nlua-nvim
-    nvim-jqx
-    nvim-surround
-    nvim-web-devicons
-    playground
-    todo-comments-nvim
-    trouble-nvim
-    vim-dispatch
-    vim-dispatch-neovim
-    vim-fugitive
-    vim-jack-in
-  
- ];
-```
-
-
-TODO:
-- [ ] Source the plugins directly
-- [ ] Add 'frozen' to each of these plugin
-- [ ] Pin plugins separately from `neovim.nix`
-- [ ] Find a better way to `inherit` with list comprehension
-- [ ] Create alert & notification channel for this, ideally via Discord channel
-- [ ] Even better, just put it in email with some labels
-- [ ] Better end-to-end design that take even deeper account to gruvbox-community and such
-

flake.nix

@@ -2,69 +2,180 @@
   nixConfig = {
     accept-flake-config = true;
     experimental-features = "nix-command flakes";
-    max-jobs = 12;
+    # for darwin's browser
+    allowUnsupportedSystem = true;
   };
   description = "My personal configuration in Nix (and some native configurations)";
   inputs = {
-    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
-    nixpkgs-latest.url = "github:nixos/nixpkgs";
-    deploy-rs.url = "github:serokell/deploy-rs";
-    std.url = "github:divnix/std";
+    nixpkgs.url = "nixpkgs/nixos-unstable";
+    # continously merged & rebased lightweight .lib. Basically a huge extension to c_.
+    nixlib.url = "github:nix-community/nixpkgs.lib";
+    agenix = {
+      url = "github:ryantm/agenix";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
     home-manager = {
       url = "github:nix-community/home-manager";
       inputs.nixpkgs.follows = "nixpkgs";
     };
-    neovim-nightly-overlay = {
-      # need to pin this until darwin build is successful again.
-      url = "github:nix-community/neovim-nightly-overlay?rev=88a6c749a7d126c49f3374f9f28ca452ea9419b8";
-      inputs.nixpkgs.follows = "nixpkgs";
-    };
-    nix-boost = {
-      url = "git+https://git.pegasust.com/pegasust/nix-boost?ref=bleed";
+    flake-utils.url = "github:numtide/flake-utils";
+    nixgl.url = "path:out-of-tree/nixGL";
+    rust-overlay.url = "github:oxalica/rust-overlay";
+    # Allows default.nix to call onto flake.nix. Useful for nix eval and automations
+    flake-compat = {
+      url = "path:out-of-tree/flake-compat";
+      flake = false;
     };
     kpcli-py = {
       url = "github:rebkwok/kpcli";
       flake = false;
     };
+    neovim-nightly-overlay = {
+      url = "github:nix-community/neovim-nightly-overlay";
+      inputs.nixpkgs.url = "github:nixos/nixpkgs?rev=fad51abd42ca17a60fc1d4cb9382e2d79ae31836";
+    };
     nix-index-database = {
       url = "github:mic92/nix-index-database";
-      # Should show the latest nixpkgs whenever possible
-      inputs.nixpkgs.follows = "nixpkgs-latest";
+      inputs.nixpkgs.follows = "nixpkgs";
     };
+    nickel.url = "github:tweag/nickel";
   };
 
-  outputs = {self, std, ...} @ inputs:
-    std.growOn
+  outputs =
+    { nixpkgs
+    , agenix
+    , home-manager
+    , flake-utils
+    , nixgl
+    , rust-overlay
+    , flake-compat
+    , neovim-nightly-overlay
+    , nix-index-database
+    , nixlib
+    , nickel
+    , ...
+    }@_inputs:
+    let
+      # config_fn:: system -> config
+      # this function should take simple exports of homeConfigurations.${profile}, 
+      # nixosConfigurations.${profile}, devShells.${profile}, packages.${profile}
+      # and correctly produce 
+      supported_systems = flake-utils.lib.defaultSystems;
+      cross_platform = config_fn: let 
+        # nixosConfigurations.${profile} -> nixosConfigurations.${system}.${profile}
+        # pass in: path.to.exports.nixosConfigurations
+        # get out: nixosConfigurations.${system} = {...}
+        strat_sandwich = field_name: config_field: system: {
+          "${field_name}"."${system}" = config_field;
+        };
+        # homeConfigurations.${profile} -> packages.${system}.homeConfigurations.${profile}
+        # pass in: path.to.exports.homeConfigurations
+        # get: packages.${system}.homeConfigurations
+        strat_wrap_packages = field_name: config_field: system: {
+          packages."${system}"."${field_name}" = config_field;
+        };
+        strat_noop = field_name: config_field: system: {"${field_name}" = config_field;};
+        strategyMap = {
+          nixosConfigurations = strat_sandwich;
+          templates =           strat_noop;
+          devShells =           strat_sandwich;
+          devShell =            strat_sandwich;
+          formatter =           strat_sandwich;
+          homeConfigurations =  strat_wrap_packages;
+          lib =                 strat_noop;
+          proj_root =           strat_noop;
+          unit_tests =          strat_noop;
+          secrets =             strat_noop;
+          debug =               strat_noop;
+        };
+        # takes in {homeConfigurations = ...; nixosConfigurations = ...}
+        # -> {packages.$system.homeConfigurations}
+        mapConfig = config: system: (builtins.foldl' 
+          (acc: confName: (strategyMap."${confName}" confName config."${confName}" system))
+          {} (builtins.attrNames config));
+      in builtins.foldl' nixlib.lib.recursiveUpdate {} (
+        builtins.map (system: (mapConfig (config_fn system) system)) supported_systems
+      );
+    in cross_platform (system:
+    let
+      # Context/global stuffs to be passed down
+      # NOTE: this will only read files that are within git tree
+      # all secrets should go into secrets.nix and secrets/*.age
+      proj_root =
+        let
+          path = builtins.toString ./.;
+        in
         {
-      # boilerplate
-      inherit inputs;
-      # All cell blocks are under ./nix/cells/<cell>/<cellblock> as `<cellblock>.nix`
-      # or `<cellblock/default.nix`
-      cellsFrom = ./nix/cells;
-      # modules = ./nix/modules;
-
-      cellBlocks = let
-        inherit (std.blockTypes) devshells functions anything installables;
-      in [
-        (devshells "devshells")
-        (devshells "userShells")
-        (functions "home-profiles")
-        (functions "home-modules")
-        (anything  "home-configs")
-        (installables "packages")
-        (anything "lib")
-      ];
-    }
-    {
-      devShells = std.harvest self [["dotfiles" "devshells"]];
-      # nixosConfigurations = std.pick [ [ "dotfiles" "nixos" ] ];
-      # homeConfigurations = std.pick [ [ "dotfiles" "home" ] ];
-      homeModules = std.pick self [["repo" "home-modules"]];
-      packages = std.harvest self [["repo" "packages"]];
-      legacyPackages = std.harvest self [["repo" "home-configs"]];
-      lib = std.pick self [["repo" "lib"]];
-
-      # TODO: Debug only
-      homeProfiles = std.pick self [["repo" "home-profiles"]];
+          inherit path;
+          configs.path = "${path}/native_configs";
+          scripts.path = "${path}/scripts";
+          secrets.path = "${path}/secrets";
+          testdata.path = "${path}/tests";
+          modules.path = "${path}/modules";
+          hosts.path = "${path}/hosts";
+          users.path = "${path}/users";
         };
+      overlays = import ./overlays.nix (_inputs // {inherit system;});
+      pkgs = import nixpkgs {
+        inherit system overlays;
+        config = {
+          allowUnfree = true;
+        };
+      };
+      # now, this lib is extremely powerful as it also engulfs nixpkgs.lib
+      # lib = nixpkgs.lib // pkgs.lib;
+      lib = (builtins.foldl' (lhs: rhs: (nixpkgs.lib.recursiveUpdate lhs rhs)) { } [
+        nixpkgs.lib
+        pkgs.lib
+        (import ./lib {
+          inherit proj_root pkgs overlays system;
+          inherit (pkgs) lib;
+        })
+      ]);
+      inputs_w_lib = (pkgs.lib.recursiveUpdate _inputs {
+        inherit system proj_root pkgs lib;
+      });
+
+      modules = (import ./modules inputs_w_lib);
+      hosts = (import ./hosts inputs_w_lib);
+      users = (import ./users inputs_w_lib);
+
+      # {nixpkgs, agenix, home-manager, flake-utils, nixgl, rust-overlay, flake-compat
+      # ,pkgs, lib (extended), proj_root}
+      final_inputs = inputs_w_lib;
+
+      # Tests: unit + integration
+      unit_tests = (import ./lib/test.nix final_inputs) //
+        {
+          test_example = {
+            expr = "names must start with 'test'";
+            expected = "or won't show up";
+          };
+          not_show = {
+            expr = "this will be ignored by lib.runTests";
+            expected = "for sure";
+          };
+        };
+      secrets = import ./secrets final_inputs;
+
+    in
+    {
+      inherit (hosts) nixosConfigurations;
+      inherit (users) homeConfigurations;
+      inherit lib proj_root;
+      devShells = import ./dev-shell.nix final_inputs;
+      templates = import ./templates final_inputs;
+      secrets = {
+        pubKeys = {
+          hosts = hosts.pubKeys;
+          users = users.pubKeys;
+        };
+      };
+
+      # unit_tests = lib.runTests unit_tests;
+      debug = {
+        inherit final_inputs hosts users modules lib inputs_w_lib unit_tests pkgs nixpkgs nixlib;
+      };
+      # formatter."${system}" = pkgs.nixpkgs-fmt;
+    });
 }

hosts/Felia/hardware-configuration.nix

@@ -1,13 +1,9 @@
 # Do not modify this file!  It was generated by ‘nixos-generate-config’
 # and may be overwritten by future invocations.  Please make changes
 # to /etc/nixos/configuration.nix instead.
+{ config, lib, pkgs, modulesPath, ... }:
+
 {
-  config,
-  lib,
-  pkgs,
-  modulesPath,
-  ...
-}: {
   imports = [ ];
 
   boot.initrd.availableKernelModules = [ ];
@@ -47,17 +43,20 @@
   #     fsType = "drvfs";
   #   };
 
-  fileSystems."/mnt/c" = {
+  fileSystems."/mnt/c" =
+    {
       device = "C:";
       fsType = "drvfs";
     };
 
-  fileSystems."/mnt/d" = {
+  fileSystems."/mnt/d" =
+    {
       device = "D:";
       fsType = "drvfs";
     };
 
-  fileSystems."/mnt/f" = {
+  fileSystems."/mnt/f" =
+    {
       device = "F:";
       fsType = "drvfs";
     };

hosts/bao/default.nix

@@ -1,12 +1,12 @@
-{
-  nixpkgs,
-  agenix,
-  home-manager,
-  flake-utils,
-  nixgl,
-  rust-overlay,
-  flake-compat,
-  pkgs,
-  lib,
-  proj_root,
+{ nixpkgs
+, agenix
+, home-manager
+, flake-utils
+, nixgl
+, rust-overlay
+, flake-compat
+, pkgs
+, lib
+, proj_root
 }: { }
+

hosts/bao/hardware-configuration.nix

@@ -1,14 +1,11 @@
 # Do not modify this file!  It was generated by ‘nixos-generate-config’
 # and may be overwritten by future invocations.  Please make changes
 # to /etc/nixos/configuration.nix instead.
+{ config, lib, pkgs, modulesPath, ... }:
+
 {
-  config,
-  lib,
-  pkgs,
-  modulesPath,
-  ...
-}: {
-  imports = [
+  imports =
+    [
       (modulesPath + "/installer/scan/not-detected.nix")
     ];
 

hosts/default.nix

@@ -1,18 +1,18 @@
-{
-  nixpkgs,
-  agenix,
-  home-manager,
-  flake-utils,
-  nixgl,
-  rust-overlay,
-  flake-compat,
-  pkgs,
-  lib,
-  proj_root,
-  nixosDefaultVersion ? "22.05",
-  defaultSystem ? "x86_64-linux",
-  ...
-} @ finalInputs: let
+{ nixpkgs
+, agenix
+, home-manager
+, flake-utils
+, nixgl
+, rust-overlay
+, flake-compat
+, pkgs
+, lib
+, proj_root
+, nixosDefaultVersion ? "22.05"
+, defaultSystem ? "x86_64-linux"
+, ...
+}@finalInputs:
+let
   config = {
     bao.metadata = {
       # req
@@ -33,10 +33,8 @@
       ];
     };
   };
-  propagate = hostConfig @ {
-    metadata,
-    nixosConfig,
-  }: let
+  propagate = hostConfig@{ metadata, nixosConfig }:
+    let
       # req
       inherit (metadata) hostName;
       # opts
@@ -49,14 +47,12 @@
       hardwareConfig = import "${proj_root.hosts.path}/${hostName}/hardware-configuration.nix";
       # alias to prevent infinite recursion
       _nixosConfig = nixosConfig;
-  in {
+    in
+    {
       inherit hostName ssh_pubkey users nixosVersion system preset hardwareConfig;
-    nixosConfig =
-      _nixosConfig
-      // {
+      nixosConfig = _nixosConfig // {
         inherit system;
-        modules =
-          [
+        modules = [
           {
             config._module.args = {
               inherit proj_root;
@@ -75,8 +71,7 @@
           }
           (import "${proj_root.modules.path}/secrets.nix")
           (import "${proj_root.modules.path}/${preset}.sys.nix")
-          ]
-          ++ _nixosConfig.modules;
+        ] ++ _nixosConfig.modules;
       };
     };
   # we are blessed by the fact that we engulfed nixpkgs.lib.* at top level
@@ -84,7 +79,8 @@
   mkHost = hostConfig: (lib.pipe [ propagate mkHostFromPropagated ] hostConfig);
   trimNull = lib.filterAttrsRecursive (name: value: value != null);
   flattenPubkey = lib.mapAttrs (hostName: meta_config: meta_config.metadata.ssh_pubkey);
-in {
+in
+{
   nixosConfigurations = lib.mapAttrs (name: hostConfig: mkHost hostConfig) config;
   # {bao = "ssh-ed25519 ..."; another_host = "ssh-rsa ...";}
   pubKeys = lib.getPubkey config;

hosts/homeless/hardware-configuration.nix

@@ -1,14 +1,11 @@
 # Do not modify this file!  It was generated by ‘nixos-generate-config’
 # and may be overwritten by future invocations.  Please make changes
 # to /etc/nixos/configuration.nix instead.
+{ config, lib, pkgs, modulesPath, ... }:
+
 {
-  config,
-  lib,
-  pkgs,
-  modulesPath,
-  ...
-}: {
-  imports = [
+  imports =
+    [
       (modulesPath + "/profiles/qemu-guest.nix")
     ];
 
@@ -26,12 +23,14 @@
   boot.kernelModules = [ ];
   boot.extraModulePackages = [ ];
 
-  fileSystems."/" = {
+  fileSystems."/" =
+    {
       device = "/dev/sda";
       fsType = "ext4";
     };
 
-  swapDevices = [{device = "/dev/sdb";}];
+  swapDevices =
+    [{ device = "/dev/sdb"; }];
 
   # Enables DHCP on each ethernet and wireless interface. In case of scripted networking
   # (the default) this is the recommended approach. When using systemd-networkd it's

hosts/lester/hardware-configuration.nix

@@ -1,14 +1,11 @@
 # Do not modify this file!  It was generated by ‘nixos-generate-config’
 # and may be overwritten by future invocations.  Please make changes
 # to /etc/nixos/configuration.nix instead.
+{ config, lib, pkgs, modulesPath, ... }:
+
 {
-  config,
-  lib,
-  pkgs,
-  modulesPath,
-  ...
-}: {
-  imports = [
+  imports =
+    [
       (modulesPath + "/profiles/qemu-guest.nix")
     ];
 
@@ -26,12 +23,14 @@
   boot.kernelModules = [ ];
   boot.extraModulePackages = [ ];
 
-  fileSystems."/" = {
+  fileSystems."/" =
+    {
       device = "/dev/sda";
       fsType = "ext4";
     };
 
-  swapDevices = [{device = "/dev/sdb";}];
+  swapDevices =
+    [{ device = "/dev/sdb"; }];
 
   # Enables DHCP on each ethernet and wireless interface. In case of scripted networking
   # (the default) this is the recommended approach. When using systemd-networkd it's

hosts/lizzi/default.nix

@@ -1,12 +1,11 @@
-{
-  nixpkgs,
-  agenix,
-  home-manager,
-  flake-utils,
-  nixgl,
-  rust-overlay,
-  flake-compat,
-  pkgs,
-  lib,
-  proj_root,
+{ nixpkgs
+, agenix
+, home-manager
+, flake-utils
+, nixgl
+, rust-overlay
+, flake-compat
+, pkgs
+, lib
+, proj_root
 }: { }

hosts/lizzi/hardware-configuration.nix

@@ -1,14 +1,11 @@
 # Do not modify this file!  It was generated by ‘nixos-generate-config’
 # and may be overwritten by future invocations.  Please make changes
 # to /etc/nixos/configuration.nix instead.
+{ config, lib, pkgs, modulesPath, ... }:
+
 {
-  config,
-  lib,
-  pkgs,
-  modulesPath,
-  ...
-}: {
-  imports = [
+  imports =
+    [
       (modulesPath + "/profiles/qemu-guest.nix")
     ];
 
@@ -38,7 +35,8 @@
     };
   };
 
-  swapDevices = [{device = "/dev/sdb";}];
+  swapDevices =
+    [{ device = "/dev/sdb"; }];
 
   # Enables DHCP on each ethernet and wireless interface. In case of scripted networking
   # (the default) this is the recommended approach. When using systemd-networkd it's

hosts/nyx/hardware-configuration.nix

@@ -1,14 +1,11 @@
 # Do not modify this file!  It was generated by ‘nixos-generate-config’
 # and may be overwritten by future invocations.  Please make changes
 # to /etc/nixos/configuration.nix instead.
+{ config, lib, pkgs, modulesPath, ... }:
+
 {
-  config,
-  lib,
-  pkgs,
-  modulesPath,
-  ...
-}: {
-  imports = [
+  imports =
+    [
       (modulesPath + "/profiles/qemu-guest.nix")
     ];
 
@@ -26,12 +23,14 @@
   boot.loader.grub.forceInstall = true;
   boot.loader.grub.device = "nodev";
   boot.loader.timeout = 10;
-  fileSystems."/" = {
+  fileSystems."/" =
+    {
       device = "/dev/sda";
       fsType = "ext4";
     };
 
-  swapDevices = [{device = "/dev/sdb";}];
+  swapDevices =
+    [{ device = "/dev/sdb"; }];
 
   # Enables DHCP on each ethernet and wireless interface. In case of scripted networking
   # (the default) this is the recommended approach. When using systemd-networkd it's

lib/default.nix

@@ -0,0 +1,61 @@
+{ pkgs
+  # ,nixpkgs
+, proj_root
+  # ,agenix
+, nixosDefaultVersion ? "22.05"
+, defaultSystem ? "x86_64-linux"
+, ...
+}@inputs:
+let
+  lib = pkgs.lib;
+  inputs_w_lib = (inputs // { inherit lib; });
+  serde = import ./serde.nix inputs_w_lib;
+  shellAsDrv = { script, pname }: (pkgs.callPackage
+    (
+      # just a pattern that we must remember: args to this are children of pkgs.
+      { writeShellScriptBin }: writeShellScriptBin pname script
+    )
+    { });
+  trimNull = lib.filterAttrs (name: value: value != null);
+  # ssh
+  flattenPubkey = lib.mapAttrs (_identity: meta_config: lib.attrByPath [ "metadata" "ssh_pubkey" ] null meta_config);
+  getPubkey = config: (lib.pipe config [ flattenPubkey trimNull ]);
+  # procedure = 
+in
+{
+  # short-hand to create a shell derivation
+  # NOTE: this is pure. This means, env vars from devShells might not
+  # be accessible unless MAYBE they are `export`ed
+  inherit shellAsDrv trimNull flattenPubkey getPubkey;
+  ssh = {
+    inherit flattenPubkey getPubkey;
+  };
+  # Configures hosts as nixosConfiguration
+  # mkHost = {hostName
+  # , nixosBareConfiguration
+  # , finalInputs
+  # , users ? {}
+  # , nixosVersion? nixosDefaultVersion
+  # , system? defaultSystem
+  # , preset? "base"}:  # base | minimal 
+  # let 
+  #   hardwareConfig = hostname: import "${proj_root.hosts.path}/${hostName}/hardware-configuration.nix";
+  # in nixpkgs.lib.nixosSystem (nixosBareConfiguration // {
+  #   inherit system;
+  #   modules = [
+  #     {
+  #       system.stateVersion = nixosVersion;
+  #       networking.hostName = hostName;
+  #       users.users = users;
+  #     }
+  #     {
+  #       _module.args = finalInputs;
+  #     }
+  #     import "${proj_root.modules.path}/secrets.nix"
+  #     import "${proj_root.modules.path}/${preset}.sys.nix"
+  #   ] ++ nixosBareConfiguration.modules;
+  #   lib = finalInputs.lib;
+  # });
+  inherit serde;
+  inherit (serde) fromYaml fromYamlPath;
+}

lib/serde.nix

@@ -0,0 +1,31 @@
+# Takes care of serializing and deserializing to some formats
+# Blame: Pegasust<pegasucksgg@gmail.com>
+# TODO: Add to* formats from pkgs.formats.*
+{ pkgs
+, lib
+, ...
+} @ inputs:
+let
+  yamlToJsonDrv = yamlContent: outputPath: pkgs.callPackage
+    ({ runCommand }:
+      # runCommand source: https://github.com/NixOS/nixpkgs/blob/master/pkgs/build-support/trivial-builders.nix#L33
+      runCommand outputPath { inherit yamlContent; nativeBuildInputs = [ pkgs.yq ]; }
+        # run yq which outputs '.' (no filter) on file at yamlPath
+        # note that $out is passed onto the bash/sh script for execution
+        ''
+          echo "$yamlContent" | yq >$out
+        '')
+    { };
+in
+{
+  # Takes in a yaml string and produces a derivation with translated JSON at $outputPath
+  # similar to builtins.fromJSON, turns a YAML string to nix attrset
+  fromYaml = yamlContent: builtins.fromJSON (builtins.readFile (yamlToJsonDrv yamlContent "any_output.json"));
+  fromYamlPath = yamlPath: builtins.fromJSON (
+    builtins.readFile (
+      yamlToJsonDrv
+        (
+          builtins.readFile yamlPath)
+        "any-output.json"));
+  # TODO: fromToml?
+}

lib/test.nix

@@ -0,0 +1 @@
+{ lib, ... }: { }

modules/base.sys.nix

@@ -1,8 +1,7 @@
-{
-  pkgs,
-  lib,
-  proj_root,
-  ...
+{ pkgs
+, lib
+, proj_root
+, ...
 }: {
   imports = [
     ./minimal.sys.nix
@@ -12,4 +11,5 @@
   ];
   environment.systemPackages = [ pkgs.lm_sensors ];
   time.timeZone = "America/Phoenix";
+
 }

modules/kde.sys.nix

@@ -1,7 +1,6 @@
-{
-  pkgs,
-  my-lib,
-  ...
+{ pkgs
+, my-lib
+, ...
 }: {
   environment.noXlibs = my-lib.mkForce false;
   # TODO: wireless networking
@@ -12,9 +11,8 @@
   services.xserver.displayManager.sddm.enable = true;
   services.xserver.desktopManager.plasma5 = {
     enable = true;
-    excludePackages = let
-      plasma5 = pkgs.libsForQt5;
-    in [
+    excludePackages = let plasma5 = pkgs.libsForQt5; in
+      [
         plasma5.elisa # audio viewer
         plasma5.konsole # I use alacritty instaed
         plasma5.plasma-browser-integration

modules/minimal.sys.nix

@@ -1,9 +1,8 @@
-{
-  pkgs,
-  lib,
-  proj_root,
-  modulesPath,
-  ...
+{ pkgs
+, lib
+, proj_root
+, modulesPath
+, ...
 }: {
   imports = [ "${modulesPath}/profiles/minimal.nix" ];
   # prune old builds after a while

modules/mosh.sys.nix

@@ -1,11 +1,10 @@
+{ pkgs
+, lib
+, config
+, ...
+}:
+let cfg = config.mod.mosh; in
 {
-  pkgs,
-  lib,
-  config,
-  ...
-}: let
-  cfg = config.mod.mosh;
-in {
   options.mod.mosh = {
     enable = lib.mkOption {
       type = lib.types.bool;
@@ -18,11 +17,9 @@ in {
     environment.systemPackages = [ pkgs.mosh ];
     networking.firewall = lib.mkIf config.networking.firewall.enable {
       allowedUDPPortRanges = [
-        {
-          from = 60000;
-          to = 61000;
-        } # mosh
+        { from = 60000; to = 61000; } # mosh
       ];
     };
   };
 }
+

modules/opengl.sys.nix

@@ -1,16 +1,15 @@
-{
-  config,
-  pkgs,
-  lib,
-}: let
+{ config, pkgs, lib }:
+let
   gpu_pkgs = [ pkgs.clinfo pkgs.lshw pkgs.glxinfo pkgs.pciutils pkgs.vulkan-tools ];
   gpu_conf = {
     # openCL
     hardware.opengl = {
       enable = true;
-      extraPackages = let
+      extraPackages =
+        let
           inherit (pkgs) rocm-opencl-icd rocm-opencl-runtime;
-      in [rocm-opencl-icd rocm-opencl-runtime];
+        in
+        [ rocm-opencl-icd rocm-opencl-runtime ];
       # Vulkan
       driSupport = true;
       driSupport32Bit = true;
@@ -19,5 +18,4 @@
     };
     environment.systemPackages = gpu_pkgs;
   };
-in
-  gpu_conf
+in gpu_conf

modules/secrets.nix

@@ -1,4 +1,6 @@
-{proj_root, ...}: {
+{ proj_root
+, ...
+}: {
   age.secrets.s3fs = {
     file = "${proj_root.secrets.path}/s3fs.age";
     # mode = "600";  # owner + group only

modules/storage.perso.sys.nix

@@ -1,10 +1,5 @@
 # Personal configuration on storage solution
-{
-  pkgs,
-  config,
-  lib,
-  ...
-}: {
+{ pkgs, config, lib, ... }: {
   environment.systemPackages = [
     pkgs.s3fs
     pkgs.cifs-utils
@@ -14,7 +9,8 @@
   # HACK: need to store secret somewhere so that root can access this
   # because autofs may run as root for now, we enforce putting the secret in this monorepo
   # TODO: make this configuration nix-less to show that it's 100% data
-  services.autofs = let
+  services.autofs =
+    let
       # confToBackendArg {lol="what"; empty=""; name_only=null;} -> "lol=what,empty=,name_only"
       # TODO: change null -> true/false. This allows overriding & better self-documentation
       confToBackendArg = conf: (lib.concatStringsSep ","
@@ -28,13 +24,15 @@
       #    backend_args, so just put the bucket name here
       #
       #-> "${mount_dest} ${formatted_args} ${s3fs-bin}#${bucket}"
-    autofs-s3fs_entry = {
-      mount_dest,
-      backend_args ? {"-fstype" = "fuse";},
-      bucket,
-    } @ inputs: let
+      autofs-s3fs_entry =
+        { mount_dest
+        , backend_args ? { "-fstype" = "fuse"; }
+        , bucket
+        }@inputs:
+        let
           s3fs-exec = "${pkgs.s3fs}/bin/s3fs";
-    in "${mount_dest} ${confToBackendArg backend_args} :${s3fs-exec}\#${bucket}";
+        in
+        "${mount_dest} ${confToBackendArg backend_args} :${s3fs-exec}\#${bucket}";
       personalStorage = [
         (autofs-s3fs_entry {
           mount_dest = "garden";
@@ -63,7 +61,8 @@
               dir_mode = "0777";
               file_mode = "0777";
             };
-        in "felia_d ${confToBackendArg args} ://felia.coati-celsius.ts.net/d"
+          in
+          "felia_d ${confToBackendArg args} ://felia.coati-celsius.ts.net/d"
         )
         (
           let
@@ -76,11 +75,13 @@
               dir_mode = "0777";
               file_mode = "0777";
             };
-        in "felia_f ${confToBackendArg args} ://felia.coati-celsius.ts.net/f"
+          in
+          "felia_f ${confToBackendArg args} ://felia.coati-celsius.ts.net/f"
         )
       ];
       persoConf = pkgs.writeText "auto.personal" (builtins.concatStringsSep "\n" personalStorage);
-  in {
+    in
+    {
       enable = true;
       # Creates /perso directory with every subdirectory declared by ${personalStorage}
       # as of now (might be stale), /perso/hot is the only mount accessible

modules/tailscale.sys.nix

@@ -1,11 +1,8 @@
-{
-  pkgs,
-  config,
-  lib,
-  ...
-}: let
-  cfg = config.mod.tailscale;
-in {
+{ pkgs
+, config
+, lib
+, ...
+}: let cfg = config.mod.tailscale; in {
   options.mod.tailscale = { 
     enable = lib.mkEnableOption "tailscale";
   };

native_configs/README.md

@@ -1,17 +1,3 @@
 # Native configs
 
-Contains all configurations that are written in their native configuration language.
-
-## Why native language?
-
-- Easier portability
-- Syntax highlighting and robust checking without needing to realize derivation
-- Nix can read from [JSON](https://nixos.org/manual/nix/stable/language/builtins.html#builtins-fromJSON),
-[TOML](https://nixos.org/manual/nix/stable/release-notes/rl-2.6.html#release-26-2022-01-24).
-- We have also managed to hack together a [fromYaml](./../nix-conf/lib/serde/default.nix),
-though it will not work for strictly pure builds or bootstrapping builds.
-
-## When to use Nix to generate config?
-
-- Original configuraiton language requires too much duplication that can be solved with Nix 
-
+Contains all configurations that are written in their native language

native_configs/neovim/init.fnl

@@ -1,721 +0,0 @@
-(vim.cmd "let data_dir = has('nvim') ? stdpath('data') . '/site' : '~/.vim'
-let plug_path = data_dir . '/autoload/plug.vim'
-if empty(glob(plug_path))
-    execute '!curl -fLo '.plug_path.' --create-dirs https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim'
-    execute 'so '.plug_path
-endif
-")
-(local Plug (. vim.fn "plug#"))
-(local installed-plugins {})
-(each [_ path (ipairs (vim.api.nvim_list_runtime_paths))]
-  (local last-folder-start (path:find "/[^/]*$"))
-  (when last-folder-start
-    (local plugin-name (path:sub (+ last-folder-start 1)))
-    (tset installed-plugins plugin-name true)))
-(fn WPlug [plugin-path ...]
-  (let [plugin-name (string.lower (plugin-path:match "/([^/]+)$"))]
-    (when (not (. installed-plugins plugin-name)) (Plug plugin-path ...))))
-(vim.call "plug#begin")
-(WPlug :tjdevries/nlua.nvim)
-(WPlug :nvim-treesitter/nvim-treesitter)
-(WPlug :nvim-treesitter/nvim-treesitter-textobjects)
-(WPlug :nvim-telescope/telescope.nvim {:branch :0.1.x})
-(WPlug :nvim-telescope/telescope-fzf-native.nvim {:do "make >> /tmp/log 2>&1"})
-(WPlug :nvim-telescope/telescope-file-browser.nvim)
-(WPlug :neovim/nvim-lspconfig)
-(WPlug :hrsh7th/cmp-nvim-lsp)
-(WPlug :hrsh7th/cmp-path)
-(WPlug :hrsh7th/cmp-buffer)
-(WPlug :hrsh7th/cmp-cmdline)
-(WPlug :hrsh7th/nvim-cmp)
-(WPlug :onsails/lspkind-nvim)
-(WPlug :yioneko/nvim-yati {:tag "*"})
-(WPlug :nathanalderson/yang.vim)
-(WPlug :windwp/nvim-autopairs)
-(WPlug :windwp/nvim-ts-autotag)
-(WPlug :NMAC427/guess-indent.nvim)
-(WPlug :j-hui/fidget.nvim)
-(WPlug :numToStr/Comment.nvim)
-(WPlug :lewis6991/gitsigns.nvim)
-(WPlug :tpope/vim-fugitive)
-(WPlug :williamboman/mason.nvim)
-(WPlug :williamboman/mason-lspconfig.nvim)
-(WPlug :ThePrimeagen/harpoon)
-(WPlug :TimUntersberger/neogit)
-(WPlug :folke/trouble.nvim)
-(WPlug :tpope/vim-dispatch)
-(WPlug :clojure-vim/vim-jack-in)
-(WPlug :radenling/vim-dispatch-neovim)
-(WPlug :gennaro-tedesco/nvim-jqx)
-(WPlug :kylechui/nvim-surround)
-(WPlug :simrat39/rust-tools.nvim)
-(WPlug :simrat39/inlay-hints.nvim)
-(WPlug :gruvbox-community/gruvbox)
-(WPlug :nvim-lualine/lualine.nvim)
-(WPlug :lukas-reineke/indent-blankline.nvim)
-(WPlug :kyazdani42/nvim-web-devicons)
-(WPlug :m-demare/hlargs.nvim)
-(WPlug :folke/todo-comments.nvim)
-(WPlug :nvim-treesitter/nvim-treesitter-context)
-(WPlug :nvim-treesitter/playground)
-(WPlug :saadparwaiz1/cmp_luasnip)
-(WPlug :L3MON4D3/LuaSnip)
-(WPlug :mickael-menu/zk-nvim)
-(WPlug :arthurxavierx/vim-caser)
-(WPlug "~/local_repos/ts-ql")
-(vim.call "plug#end")
-(vim.cmd "if len(filter(values(g:plugs), '!isdirectory(v:val.dir)'))
-    PlugInstall --sync | autocmd VimEnter * so $MYVIMRC
-endif
-")
-(vim.api.nvim_create_autocmd [:VimEnter]
-                             {:callback (fn []
-                                          (fn named-term [term-idx term-name]
-                                            ((. (require :harpoon.term)
-                                                :gotoTerminal) term-idx)
-                                            (vim.cmd (.. ":exe \":file "
-                                                         term-name
-                                                         "\" | :bfirst")))
-
-                                          (named-term 4 "term:ctl")
-                                          (named-term 5 "term:dev")
-                                          (named-term 7 "term:repl")
-                                          (named-term 6 "term:repl2"))})
-(set vim.g.gruvbox_contrast_dark :soft)
-(set vim.g.gruvbox_contrast_light :soft)
-(set vim.opt.ignorecase true)
-(set vim.opt.smartcase true)
-(set vim.opt.incsearch true)
-(set vim.opt.number true)
-(set vim.opt.relativenumber true)
-(set vim.opt.autoindent true)
-(set vim.opt.smartindent true)
-(set vim.opt.expandtab true)
-(set vim.opt.exrc true)
-(set vim.opt.tabstop 4)
-(set vim.opt.softtabstop 4)
-(set vim.opt.shiftwidth 4)
-(set vim.opt.scrolloff 30)
-(set vim.opt.signcolumn :yes)
-(set vim.opt.colorcolumn :80)
-(set vim.opt.background :dark)
-(vim.api.nvim_create_user_command :Dark
-                                  (fn [opts]
-                                    (let [contrast (or (and (and opts.args
-                                                                 (> (string.len opts.args)
-                                                                    0))
-                                                            opts.args)
-                                                       vim.g.gruvbox_contrast_dark)]
-                                      (set vim.g.gruvbox_contrast_dark contrast)
-                                      (set vim.opt.background :dark)))
-                                  {:nargs "?"})
-(vim.api.nvim_create_user_command :Light
-                                  (fn [opts]
-                                    (let [contrast (or (and (and opts.args
-                                                                 (> (string.len opts.args)
-                                                                    0))
-                                                            opts.args)
-                                                       vim.g.gruvbox_contrast_light)]
-                                      (set vim.g.gruvbox_contrast_light
-                                           contrast)
-                                      (set vim.opt.background :light)))
-                                  {:nargs "?"})
-(set vim.opt.lazyredraw true)
-(set vim.opt.termguicolors true)
-(set vim.opt.cursorline true)
-(set vim.opt.swapfile false)
-(set vim.opt.backup false)
-(set vim.opt.undodir (.. (vim.fn.stdpath :state) :/.vim/undodir))
-(set vim.opt.undofile true)
-(set vim.opt.completeopt "menuone,noselect")
-(set vim.opt.updatetime 50)
-(set vim.g.mapleader " ")
-(set vim.g.maplocalleader ",")
-(vim.keymap.set [:n :v] :<Space> :<Nop> {:silent true})
-(vim.keymap.set :t :<Esc> "<C-\\><C-n>)")
-(vim.keymap.set [:n :i :v] :<c-l> :<Cmd>mode<Cr> {:desc ""})
-(vim.keymap.set :n "[d" vim.diagnostic.goto_prev)
-(vim.keymap.set :n "]d" vim.diagnostic.goto_next)
-(vim.keymap.set :n :<leader>e vim.diagnostic.open_float)
-(vim.keymap.set :n :<leader>q "<cmd>TroubleToggle loclist<cr>")
-(vim.keymap.set :n :<leader>wq "<cmd>TroubleToggle workspace_diagnostics<cr>")
-(vim.keymap.set :n :<leader>gg :<cmd>GuessIndent<cr>)
-(vim.cmd "colorscheme gruvbox\n")
-((. (require :hlargs) :setup))
-((. (require :nvim-web-devicons) :setup))
-((. (require :trouble) :setup))
-((. (require :todo-comments) :setup))
-(fn remap [mode key-cmd binded-fn opts]
-  (set-forcibly! opts (or opts {:remap true}))
-  (vim.keymap.set mode key-cmd binded-fn opts))
-((. (require :Comment) :setup))
-(set vim.opt.list true)
-(vim.opt.listchars:append "space:⋅")
-(vim.opt.listchars:append "eol:↴")
-((. (require :indent_blankline) :setup) {:show_end_of_line true
-                                         :space_char_blankline " "})
-(vim.api.nvim_create_user_command :HalfSpaces
-                                  (fn [opts]
-                                    (vim.api.nvim_command "set ts=2 sts=2 noet")
-                                    (vim.api.nvim_command :retab!)
-                                    (vim.api.nvim_command "set ts=1 sts=1 et")
-                                    (vim.api.nvim_command :retab)
-                                    (vim.api.nvim_command :GuessIndent))
-                                  {:nargs 0})
-(vim.api.nvim_create_user_command :DoubleSpaces
-                                  (fn [opts]
-                                    (vim.api.nvim_command "set ts=2 sts=2 noet")
-                                    (vim.api.nvim_command :retab!)
-                                    (vim.api.nvim_command "set ts=4 sts=4 et")
-                                    (vim.api.nvim_command :retab)
-                                    (vim.api.nvim_command :GuessIndent))
-                                  {:nargs 0})
-(local fb-actions (. (. (. (require :telescope) :extensions) :file_browser)
-                     :actions))
-((. (require :telescope) :setup) {:defaults {:mappings {:i {:<C-d> false
-                                                            :<C-u> false}}}
-                                  :extensions {:file_browser {:hiject_netrw true
-                                                              :mappings {:i {}
-                                                                         :n {:c fb-actions.create
-                                                                             :d fb-actions.remove
-                                                                             :e fb-actions.goto_home_dir
-                                                                             :f fb-actions.toggle_browser
-                                                                             :g fb-actions.goto_parent_dir
-                                                                             :h fb-actions.toggle_hidden
-                                                                             :m fb-actions.move
-                                                                             :o fb-actions.open
-                                                                             :r fb-actions.rename
-                                                                             :s fb-actions.toggle_all
-                                                                             :t fb-actions.change_cwd
-                                                                             :w fb-actions.goto_cwd
-                                                                             :y fb-actions.copy}}
-                                                              :theme (. ((. (require :telescope.themes)
-                                                                            :get_ivy))
-                                                                        :theme)}
-                                               :fzf {:case_mode :smart_case
-                                                     :fuzzy true
-                                                     :override_file_sorter true
-                                                     :override_generic_sorter true}}})
-(pcall (. (require :telescope) :load_extension) :fzf)
-(pcall (. (require :telescope) :load_extension) :file_browser)
-(remap :n :<C-p> :<cmd>Telescope<cr> {:desc "Open Telescope general search"})
-(remap :n :<leader>fm (fn []
-                        ((. (. (. (require :telescope) :extensions)
-                               :file_browser)
-                            :file_browser) {}))
-       {:desc "[F]ile [M]utation"})
-(remap :n :<leader>ff
-       (fn []
-         ((. (require :telescope.builtin) :find_files) {:follow false
-                                                        :hidden false
-                                                        :no_ignore false}))
-       {:desc "[F]ind [F]ile"})
-(remap :n :<leader>fa
-       (fn []
-         ((. (require :telescope.builtin) :find_files) {:follow true
-                                                        :hidden true
-                                                        :no_ignore true}))
-       {:desc "[F]ind [A]ll files"})
-(remap :n :<leader>fg
-       (fn []
-         ((. (require :telescope.builtin) :live_grep)))
-       {:desc "[F]ind by [G]rep"})
-(remap :n :<leader>fug
-       (fn []
-         ((. (require :telescope.builtin) :live_grep) {:glob_pattern "**/*"}))
-       {:desc "[F]ind by [u]nrestricted [G]rep"})
-(remap :n :<leader>fb
-       (fn []
-         ((. (require :telescope.builtin) :buffers)))
-       {:desc "[F]ind existing [B]uffers"})
-(remap :n :<leader>fh
-       (fn []
-         ((. (require :telescope.builtin) :help_tags)))
-       {:desc "[F]ind [H]elp"})
-(remap :n :<leader>fd
-       (fn []
-         ((. (require :telescope.builtin) :diagnostics)))
-       {:desc "[F]ind [D]iagnostics"})
-(remap :n :<leader>zf
-       (fn []
-         ((. (require :zk) :edit) {} {:multi_select false}))
-       {:desc "[Z]ettelkasten [F]iles"})
-(remap :n :<leader>zg (fn [] (vim.cmd ":ZkGrep"))
-       {:desc "[Z]ettelkasten [G]rep"})
-(for [i 1 9]
-  (vim.api.nvim_set_keymap :n (.. :<C-t> i) (.. ":tabn " i :<CR>)
-                           {:noremap true :silent true}))
-(set vim.o.showtabline 1)
-(set vim.o.tabline "%!v:lua.my_tabline()")
-(fn _G.my_tabline []
-  (var s "")
-  (for [i 1 (vim.fn.tabpagenr "$")]
-    (if (= i (vim.fn.tabpagenr)) (set s (.. s "%" i "T%#TabLineSel#"))
-        (set s (.. s "%" i "T%#TabLine#")))
-    (local tab (. (vim.fn.gettabinfo i) 1))
-    (local tabbuf tab.variables.buffers)
-    (var bufname :<unknown>)
-    (when tabbuf
-      (set bufname (. (. tabbuf tab.curwin) :name)))
-    (set s (.. s " " i " " (vim.fn.fnamemodify bufname ":t")))
-    (when (not= i (vim.fn.tabpagenr "$"))
-      (set s (.. s "%#TabLine#|%#TabLine#"))))
-  (.. s "%T%#TabLineFill#%="))
-(vim.api.nvim_set_keymap :n :<C-t>x
-                         ":tabdo if tabpagenr() > 1 | tabclose | endif<CR>"
-                         {:noremap true :silent true})
-(require :treesitter-context)
-((. (require :nvim-treesitter.configs) :setup) {:autotag {:enable true}
-                                                :highlight {:enable true
-                                                            :enable_vim_regex_highlighting true}
-                                                :incremental_selection {:enable true
-                                                                        :keymaps {:init_selection :<C-space>
-                                                                                  :node_decremental :<C-backspace>
-                                                                                  :node_incremental :<C-space>
-                                                                                  :pscope_incremental :<C-S>}}
-                                                :indent {:enable false}
-                                                :playground {:disable {}
-                                                             :enable true}
-                                                :textobjects {:select {:enable true
-                                                                       :keymaps {:ac "@class.outer"
-                                                                                 :af "@function.outer"
-                                                                                 :ic "@class.inner"
-                                                                                 :if "@function.inner"}
-                                                                       :lookahead true}}
-                                                :yati {:default_fallback :auto
-                                                       :default_lazy true
-                                                       :disable [:nix]
-                                                       :enable true}})
-((. (require :nvim-autopairs) :setup) {:check_ts true})
-(local parser-config
-       ((. (require :nvim-treesitter.parsers) :get_parser_configs)))
-(set parser-config.tsx.filetype_to_parsername [:javascript :typescript.tsx])
-(set parser-config.astro.filetype_to_parsername
-     [:javascript :typescript.tsx :astro])
-((. (require :guess-indent) :setup) {:auto_cmd true
-                                     :filetype_exclude [:netrw :tutor]})
-(remap :n :<leader>m
-       (fn []
-         ((. (require :harpoon.mark) :add_file)))
-       {:desc "[H]arpoon [M]ark"})
-(fn harpoon-nav [key nav-file-index lead-keybind]
-  (set-forcibly! lead-keybind (or lead-keybind :<leader>h))
-  (assert (= (type key) :string) "expect key to be string(keybind)")
-  (assert (and (= (type nav-file-index) :number) (>= nav-file-index 1))
-          "expect 1-indexed number for file index")
-  (remap :n (.. lead-keybind key)
-         (fn []
-           ((. (require :harpoon.ui) :nav_file) nav-file-index))
-         {:desc (.. "[H]arpoon navigate " (tostring nav-file-index))}))
-(harpoon-nav :f 1)
-(harpoon-nav :j 2)
-(harpoon-nav :d 3)
-(harpoon-nav :k 4)
-(remap :n :<leader>hh
-       (fn []
-         ((. (require :harpoon.ui) :toggle_quick_menu))))
-(for [i 1 10]
-  (harpoon-nav (tostring (% i 10)) i)
-  (remap :n (.. :<leader>t (tostring (% i 10)))
-         (fn []
-           ((. (require :harpoon.term) :gotoTerminal) i))))
-((. (require :neogit) :setup) {})
-(remap :n :<leader>gs (fn []
-                        ((. (require :neogit) :open) {}))
-       {:desc "[G]it [S]tatus"})
-((. (require :inlay-hints) :setup) {:eol {:right_align false}
-                                    :only_current_line false})
-(fn on-attach [client bufnr]
-  (fn nmap [keys func desc]
-    (when desc (set-forcibly! desc (.. "LSP: " desc)))
-    (vim.keymap.set :n keys func {:buffer bufnr : desc :noremap true}))
-
-  (nmap :<leader>rn vim.lsp.buf.rename "[R]e[n]ame")
-  (nmap :<leader>ca vim.lsp.buf.code_action "[C]ode [A]ction")
-  (vim.api.nvim_buf_set_option bufnr :omnifunc "v:lua.vim.lsp.omnifunc")
-  (nmap :<leader>df (fn [] (vim.lsp.buf.format {:async true}))
-        "[D]ocument [F]ormat")
-  (nmap :gd vim.lsp.buf.definition "[G]oto [D]efinition")
-  (nmap :gi vim.lsp.buf.implementation "[G]oto [I]mplementation")
-  (nmap :gr (. (require :telescope.builtin) :lsp_references))
-  (nmap :<leader>ds (. (require :telescope.builtin) :lsp_document_symbols)
-        "[D]ocument [S]ymbols")
-  (nmap :<leader>ws (. (require :telescope.builtin)
-                       :lsp_dynamic_workspace_symbols)
-        "[W]orkspace [S]ymbols")
-  (nmap :K vim.lsp.buf.hover "Hover Documentation")
-  (nmap :<C-k> vim.lsp.buf.signature_help "Signature Documentation")
-  (nmap :gD vim.lsp.buf.declaration "[G]oto [D]eclaration")
-  (nmap :gtd vim.lsp.buf.type_definition "[G]oto [T]ype [D]efinition")
-  (nmap :<leader>D vim.lsp.buf.type_definition "Type [D]efinition")
-  (nmap :<leader>wa vim.lsp.buf.add_workspace_folder "[W]orkspace [A]dd Folder")
-  (nmap :<leader>wr vim.lsp.buf.remove_workspace_folder
-        "[W]orkspace [R]emove Folder")
-  (nmap :<leader>wl
-        (fn []
-          (print (vim.inspect (vim.lsp.buf.list_workspace_folders))))
-        "[W]orkspace [L]ist Folders")
-  ((. (require :inlay-hints) :on_attach) client bufnr))
-(local cmp (require :cmp))
-(local luasnip (require :luasnip))
-(local lspkind (require :lspkind))
-(local source-mapping {:buffer "[Buffer]"
-                       :nvim_lsp "[LSP]"
-                       :nvim_lua "[Lua]"
-                       :path "[Path]"})
-(cmp.event:on :confirm_done ((. (require :nvim-autopairs.completion.cmp)
-                                :on_confirm_done)))
-(cmp.setup {:formatting {:format (fn [entry vim-item]
-                                   (set vim-item.kind
-                                        (lspkind.symbolic vim-item.kind
-                                                          {:mode :symbol}))
-                                   (set vim-item.menu
-                                        (. source-mapping entry.source_name))
-                                   (local maxwidth 80)
-                                   (set vim-item.abbr
-                                        (string.sub vim-item.abbr 1 maxwidth))
-                                   vim-item)}
-            :mapping (cmp.mapping.preset.insert {:<C-d> (cmp.mapping.scroll_docs 4)
-                                                 :<C-space> (cmp.mapping.complete)
-                                                 :<C-u> (cmp.mapping.scroll_docs (- 4))
-                                                 :<CR> (cmp.mapping.confirm {:behavior cmp.ConfirmBehavior.Replace
-                                                                             :select true})
-                                                 :<S-Tab> (cmp.mapping (fn [fallback]
-                                                                         (if (cmp.visible)
-                                                                             (cmp.select_prev_item)
-                                                                             (luasnip.jumpable (- 1))
-                                                                             (luasnip.jump (- 1))
-                                                                             (fallback)))
-                                                                       [:i :s])
-                                                 :<Tab> (cmp.mapping (fn [fallback]
-                                                                       (if (cmp.visible)
-                                                                           (cmp.select_next_item)
-                                                                           (luasnip.expand_or_jumpable)
-                                                                           (luasnip.expand_or_jump)
-                                                                           (fallback)))
-                                                                     [:i :s])})
-            :snippet {:expand (fn [args] (luasnip.lsp_expand args.body))}
-            :sources (cmp.config.sources [{:name :nvim_lsp}
-                                          {:name :luasnip}
-                                          {:name :buffer}
-                                          {:name :path}])})
-(local capabilities ((. (require :cmp_nvim_lsp) :default_capabilities)))
-(local servers [:clangd
-                :rust_analyzer
-                :pyright
-                :tsserver
-                :lua_ls
-                :cmake
-                :tailwindcss
-                :prismals
-                :rnix
-                :eslint
-                :terraformls
-                :tflint
-                :svelte
-                :astro
-                :clojure_lsp
-                :bashls
-                :yamlls
-                :ansiblels
-                :jsonls
-                :denols
-                :gopls
-                :nickel_ls
-                :pylsp])
-((. (require :mason) :setup) {:PATH :append
-                              :ui {:check_outdated_packages_on_open true
-                                   :icons {:package_installed "✓"
-                                           :package_pending "➜"
-                                           :package_uninstalled "✗"}}})
-((. (require :mason-lspconfig) :setup) {:automatic_installation false})
-(local inlay-hint-tsjs
-       {:includeInlayEnumMemberValueHints true
-        :includeInlayFunctionLikeReturnTypeHints true
-        :includeInlayFunctionParameterTypeHints true
-        :includeInlayParameterNameHints :all
-        :includeInlayPropertyDeclarationTypeHints true
-        :includeInlayVariableTypeHints true
-        :inlcudeInlayParameterNameHintsWhenArgumentMatchesName false})
-((. (require :mason-lspconfig) :setup_handlers) {1 (fn [server-name]
-                                                     ((. (. (require :lspconfig)
-                                                            server-name)
-                                                         :setup) {: capabilities
-                                                                                                                                                                                                                            :on_attach on-attach}))
-                                                 :denols (fn []
-                                                           ((. (. (require :lspconfig)
-                                                                  :denols)
-                                                               :setup) {: capabilities
-                                                                                                                                                                                                                                          :on_attach on-attach
-                                                                                                                                                                                                                                          :root_dir ((. (require :lspconfig.util)
-                                                                                                                                                                                                                                                        :root_pattern) :deno.json
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         :deno.jsonc)}))
-                                                 :lua_ls (fn []
-                                                           ((. (. (require :lspconfig)
-                                                                  :lua_ls)
-                                                               :setup) {: capabilities
-                                                                                                                                                                                                                                          :on_attach on-attach
-                                                                                                                                                                                                                                          :settings {:Lua {:diagnostics {:globals [:vim]}
-                                                                                                                                                                                                                                                           :format {:defaultConfig {:indent_size 4
-                                                                                                                                                                                                                                                                                    :indent_style :space}
-                                                                                                                                                                                                                                                                    :enable true}
-                                                                                                                                                                                                                                                           :hint {:enable true}
-                                                                                                                                                                                                                                                           :runtime {:path (vim.split package.path
-                                                                                                                                                                                                                                                                                      ";")
-                                                                                                                                                                                                                                                                     :version :LuaJIT}
-                                                                                                                                                                                                                                                           :telemetry {:enable false}
-                                                                                                                                                                                                                                                           :workspace {:library (vim.api.nvim_get_runtime_file ""
-                                                                                                                                                                                                                                                                                                               true)}}}}))
-                                                 :pyright (fn []
-                                                            ((. (. (require :lspconfig)
-                                                                   :pyright)
-                                                                :setup) {: capabilities
-                                                                                                                                                                                                                                              :on_attach on-attach
-                                                                                                                                                                                                                                              :settings {:pyright {:disableLanguageServices false
-                                                                                                                                                                                                                                                                   :disableOrganizeImports false}
-                                                                                                                                                                                                                                                         :python {:analysis {:autoImportCompletions true
-                                                                                                                                                                                                                                                                             :autoSearchPaths true
-                                                                                                                                                                                                                                                                             :diagnosticMode :openFilesOnly
-                                                                                                                                                                                                                                                                             :extraPaths {}
-                                                                                                                                                                                                                                                                             :logLevel :Information
-                                                                                                                                                                                                                                                                             :pythonPath :python
-                                                                                                                                                                                                                                                                             :stubPath :typings
-                                                                                                                                                                                                                                                                             :typeCheckingMode :basic
-                                                                                                                                                                                                                                                                             :typeshedPaths {}
-                                                                                                                                                                                                                                                                             :useLibraryCodeForTypes false
-                                                                                                                                                                                                                                                                             :venvPath ""}
-                                                                                                                                                                                                                                                                  :linting {:mypyEnabled true}}}}))
-                                                 :tsserver (fn []
-                                                             ((. (. (require :lspconfig)
-                                                                    :tsserver)
-                                                                 :setup) {: capabilities
-                                                                                                                                                                                                                                                  :on_attach on-attach
-                                                                                                                                                                                                                                                  :root_dir ((. (require :lspconfig.util)
-                                                                                                                                                                                                                                                                :root_pattern) :package.json)
-                                                                                                                                                                                                                                                  :settings {:javascript inlay-hint-tsjs
-                                                                                                                                                                                                                                                             :typescript inlay-hint-tsjs}}))
-                                                 :yamlls (fn []
-                                                           ((. (. (require :lspconfig)
-                                                                  :yamlls)
-                                                               :setup) {: capabilities
-                                                                                                                                                                                                                                          :on_attach on-attach
-                                                                                                                                                                                                                                          :settings {:yaml {:keyOrdering false}}}))})
-((. (require :rust-tools) :setup) {:dap {:adapter {:command :lldb-vscode
-                                                   :name :rt_lldb
-                                                   :type :executable}}
-                                   :server {: capabilities
-                                            :cmd [:rust-analyzer]
-                                            :on_attach (fn [client bufnr]
-                                                         (fn nmap [keys
-                                                                   func
-                                                                   desc]
-                                                           (when desc
-                                                             (set-forcibly! desc
-                                                                            (.. "LSP: "
-                                                                                desc)))
-                                                           (vim.keymap.set :n
-                                                                           keys
-                                                                           func
-                                                                           {:buffer bufnr
-                                                                            : desc
-                                                                            :noremap true}))
-
-                                                         (on-attach client
-                                                                    bufnr)
-                                                         (nmap :K
-                                                               (. (. (require :rust-tools)
-                                                                     :hover_actions)
-                                                                  :hover_actions)
-                                                               "Hover Documentation"))
-                                            :settings {:rust-analyzer {:cargo {:loadOutDirsFromCheck true}
-                                                                       :checkOnSave {:command :clippy
-                                                                                     :extraArgs [:--all
-                                                                                                 "--"
-                                                                                                 :-W
-                                                                                                 "clippy::all"]}
-                                                                       :procMacro {:enable true}
-                                                                       :rustfmt {:extraArgs [:+nightly]}}}
-                                            :standalone true}
-                                   :tools {:crate_graph {:backend :x11
-                                                         :enabled_graphviz_backends [:bmp
-                                                                                     :cgimage
-                                                                                     :canon
-                                                                                     :dot
-                                                                                     :gv
-                                                                                     :xdot
-                                                                                     :xdot1.2
-                                                                                     :xdot1.4
-                                                                                     :eps
-                                                                                     :exr
-                                                                                     :fig
-                                                                                     :gd
-                                                                                     :gd2
-                                                                                     :gif
-                                                                                     :gtk
-                                                                                     :ico
-                                                                                     :cmap
-                                                                                     :ismap
-                                                                                     :imap
-                                                                                     :cmapx
-                                                                                     :imap_np
-                                                                                     :cmapx_np
-                                                                                     :jpg
-                                                                                     :jpeg
-                                                                                     :jpe
-                                                                                     :jp2
-                                                                                     :json
-                                                                                     :json0
-                                                                                     :dot_json
-                                                                                     :xdot_json
-                                                                                     :pdf
-                                                                                     :pic
-                                                                                     :pct
-                                                                                     :pict
-                                                                                     :plain
-                                                                                     :plain-ext
-                                                                                     :png
-                                                                                     :pov
-                                                                                     :ps
-                                                                                     :ps2
-                                                                                     :psd
-                                                                                     :sgi
-                                                                                     :svg
-                                                                                     :svgz
-                                                                                     :tga
-                                                                                     :tiff
-                                                                                     :tif
-                                                                                     :tk
-                                                                                     :vml
-                                                                                     :vmlz
-                                                                                     :wbmp
-                                                                                     :webp
-                                                                                     :xlib
-                                                                                     :x11]
-                                                         :full true
-                                                         :output nil}
-                                           :executor (. (require :rust-tools/executors)
-                                                        :termopen)
-                                           :hover_actions {:auto_focus false
-                                                           :border [["╭"
-                                                                     :FloatBorder]
-                                                                    ["─"
-                                                                     :FloatBorder]
-                                                                    ["╮"
-                                                                     :FloatBorder]
-                                                                    ["│"
-                                                                     :FloatBorder]
-                                                                    ["╯"
-                                                                     :FloatBorder]
-                                                                    ["─"
-                                                                     :FloatBorder]
-                                                                    ["╰"
-                                                                     :FloatBorder]
-                                                                    ["│"
-                                                                     :FloatBorder]]}
-                                           :inlay_hints {:auto false
-                                                         :highlight :NonText
-                                                         :max_len_align false
-                                                         :max_len_align_padding 1
-                                                         :only_current_line true
-                                                         :other_hints_prefix "=> "
-                                                         :parameter_hints_prefix "<- "
-                                                         :right_align false
-                                                         :right_align_padding 7
-                                                         :show_parameter_hints true}
-                                           :on_initialized (fn []
-                                                             ((. (require :inlay-hints)
-                                                                 :set_all)))
-                                           :reload_workspace_from_cargo_toml true}})
-((. (require :zk) :setup) {:lsp {:auto_attach {:enable true
-                                               :filetypes [:markdown]}
-                                 :config {:cmd [:zk :lsp]
-                                          :name :zk
-                                          :on_attach on-attach}}
-                           :picker :telescope})
-((. (require :zk.commands) :add) :ZkOrphans
-                                 (fn [options]
-                                   (set-forcibly! options
-                                                  (vim.tbl_extend :force
-                                                                  {:orphan true}
-                                                                  (or options
-                                                                      {})))
-                                   ((. (require :zk) :edit) options
-                                                            {:title "Zk Orphans (unlinked notes)"})))
-((. (require :zk.commands) :add) :ZkGrep
-                                 (fn [match-ctor]
-                                   (var grep-str match-ctor)
-                                   (var ___match___ nil)
-                                   (if (or (= match-ctor nil) (= match-ctor ""))
-                                       (do
-                                         (vim.fn.inputsave)
-                                         (set grep-str
-                                              (vim.fn.input "Grep string: >"))
-                                         (vim.fn.inputrestore)
-                                         (set ___match___ {:match grep-str}))
-                                       (= (type match-ctor) :string)
-                                       (set ___match___ {:match grep-str}))
-                                   ((. (require :zk) :edit) ___match___
-                                                            {:mutli_select false
-                                                             :title (.. "Grep: '"
-                                                                        grep-str
-                                                                        "'")})))
-((. (require :gitsigns) :setup) {:signs {:add {:text "+"}
-                                         :change {:text "~"}
-                                         :changedelete {:text "~"}
-                                         :delete {:text "_"}
-                                         :topdelete {:text "‾"}}})
-((. (require :lualine) :setup) {:inactive_sections {:lualine_a {}
-                                                    :lualine_b {}
-                                                    :lualine_c [{1 :filename
-                                                                 :file_status true
-                                                                 :path 1}]
-                                                    :lualine_x [:location]
-                                                    :lualine_y {}
-                                                    :lualine_z {}}
-                                :options {:icons_enabled true}
-                                :sections {:lualine_a [:mode]
-                                           :lualine_b [:branch
-                                                       :diff
-                                                       :diagnostics]
-                                           :lualine_c [{1 :filename
-                                                        :file_status true
-                                                        :newfile_status false
-                                                        :path 1
-                                                        :symbols {:modified "[+]"
-                                                                  :newfile "[New]"
-                                                                  :readonly "[-]"
-                                                                  :unnamed "[Unnamed]"}}]
-                                           :lualine_x [:encoding
-                                                       :fileformat
-                                                       :filetype]
-                                           :lualine_y [:progress]
-                                           :lualine_z [:location]}})
-((. (require :nvim-surround) :setup) {})
-((. (require :tsql) :setup))
-((. (require :fidget) :setup) {:align {:bottom true :right true}
-                               :debug {:logging false :strict false}
-                               :fmt {:fidget (fn [fidget-name spinner]
-                                               (string.format "%s %s" spinner
-                                                              fidget-name))
-                                     :leftpad true
-                                     :max_width 0
-                                     :stack_upwards true
-                                     :task (fn [task-name message percentage]
-                                             (string.format "%s%s [%s]" message
-                                                            (or (and percentage
-                                                                     (string.format " (%s%%)"
-                                                                                    percentage))
-                                                                "")
-                                                            task-name))}
-                               :sources {:* {:ignore false}}
-                               :text {:commenced :Started
-                                      :completed :Completed
-                                      :done "✔"
-                                      :spinner :moon}
-                               :timer {:fidget_decay 2000
-                                       :spinner_rate 125
-                                       :task_decay 1000}
-                               :window {:blend 100
-                                        :border :none
-                                        :relative :editor
-                                        :zindex nil}})	

native_configs/ssh/config

@@ -1,3 +1,7 @@
+Host *
+    IdentityFile ~/.ssh/id_rsa 
+    IdentityFile ~/.ssh/id_ed25519
+
 # felia mirror on windows
 Host felia-win
     HostName felia.coati-celsius.ts.net
@@ -53,51 +57,17 @@ Host sr1
     HostName 10.30.76.46
     User htran
     Port 22
-    StrictHostKeyChecking no
     HostKeyAlgorithms=+ssh-dss,ssh-rsa
     KexAlgorithms +diffie-hellman-group1-sha1,diffie-hellman-group-exchange-sha1,diffie-hellman-group14-sha1
 
-Host bgp1
-    HostName 10.111.100.113
-    User htran
-    Port 22
-    StrictHostKeyChecking no
-    HostKeyAlgorithms=+ssh-dss,ssh-rsa
-    KexAlgorithms +diffie-hellman-group1-sha1,diffie-hellman-group-exchange-sha1,diffie-hellman-group14-sha1
-
-Host bgp2
-    HostName 10.111.100.114
-    User htran
-    Port 22
-    StrictHostKeyChecking no
-    HostKeyAlgorithms=+ssh-dss,ssh-rsa
-    KexAlgorithms +diffie-hellman-group1-sha1,diffie-hellman-group-exchange-sha1,diffie-hellman-group14-sha1
 Host d1-30
     HostName 10.111.103.60
     User htran
     Port 22
-    StrictHostKeyChecking no
-    UserKnownHostsFile /dev/null
-    IdentityFile ~/.ssh/id_ed25519
-    IdentityFile ~/.ssh/id_rsa 
-
-Host d3l-3
-    HostName 10.111.103.65
-    User htran
-    Port 22
-    StrictHostKeyChecking no
-    UserKnownHostsFile /dev/null
-    IdentityFile ~/.ssh/id_ed25519
-    IdentityFile ~/.ssh/id_rsa 
 
 Host dev0
     HostName 10.100.200.230
-    User htran
-    Port 22
-
-Host dev2
-    HostName 10.100.200.210
-    User htran
+    User root
     Port 22
 
 Host dev1
@@ -111,32 +81,13 @@ Host ztp-egi
     User root
     Port 22
     
+Host d3l-3
+    HostName 10.111.103.65
+    User htran
+    Port 22
+
 Host goat
     HostName 10.133.32.100
     User "EGN NOC"
     Port 22
 
-Host portal2
-    HostName portal2.egihosting.com
-    User root
-    Port 22
-
-Host egn-rest-api
-    HostName egn-rest-api.egihosting.com
-    User root
-    Port 22
-
-Host gl-egi
-    HostName gitlab.egihosting.com
-    User git
-    Port 22
-    IdentityFile ~/.ssh/id_ed25519
-
-Host 10.111.103.*
-    StrictHostKeyChecking no
-    UserKnownHostsFile /dev/null
-
-Host *
-    IdentityFile ~/.ssh/id_ed25519
-    IdentityFile ~/.ssh/id_rsa 
-

native_configs/starship/starship.toml

@@ -3,11 +3,6 @@
 [aws]
 symbol = "  "
 
-[c]
-disabled = false
-# commands = [ [ 'cc', '--version' ], [ 'gcc', '--version' ], [ 'clang', '--version' ] ]
-detect_extensions = ["c", "h", "cc", "cpp", "hh", "hpp"]
-
 [conda]
 symbol = " "
 

native_configs/tmux/tmux.conf

@@ -14,19 +14,7 @@ setw -g pane-base-index 1
 set-option -g renumber-windows on
 
 # status bar
-# set -g status-style 'bg=#333333 fg=#5eacd3'
-# set -g status-interval 60
-# set -g status-right-style 'bg=#333333 fg=#5eacd3'
-# set -g status-right-length 50
-# set -g status-left " "
+set -g status-style 'bg=#333333 fg=#5eacd3'
 
 # Keybinds
-# Enter copy mode with 'v' in vi mode
-bind-key -Tcopy-mode-vi v send-keys -X begin-selection
-
-# Copy selection with 'y' in vi mode
-bind-key -Tcopy-mode-vi y send-keys -X copy-selection-and-cancel
 set-window-option -g mode-keys vi
-
-# # Log
-# set-option -g history-file /tmp/.tmux.log

nix-conf/home-manager/base/alacritty.nix

@@ -1,14 +1,16 @@
-{
-  config,
-  proj_root,
-  myLib,
-  ...
-}: let
+{ config
+, proj_root
+, myLib
+, ...
+}:
+let
   inherit (myLib) fromYaml;
   actualConfig = fromYaml (builtins.readFile "${proj_root.config.path}//alacritty/alacritty.yml");
   cfg = config.base.alacritty;
-in {
-  options.base.alacritty = {
+in
+{
+  options.base.alacritty =
+    {
       font.family = myLib.mkOption {
         type = myLib.types.singleLineStr;
         default = actualConfig.font.normal.family;

nix-conf/home-manager/base/darwin-spotlight.nix

@@ -1,54 +0,0 @@
-{
-  lib,
-  pkgs,
-  config,
-  ...
-}: {
-  # This patch exists since Darwin's search bar requires solid apps and not
-  # symlinked
-  # TODO: QA
-  # - [x] works for base case
-  # - [x] works for repeated case
-  # - [ ] works after base case, then removed
-  # - [ ] works for repeated case, then removed
-
-  # Copy GUI apps to "~/Applications/Home Manager Apps"
-  # Based on this comment: https://github.com/nix-community/home-manager/issues/1341#issuecomment-778820334
-  home.activation.patch-spotlight =
-    if pkgs.stdenv.isDarwin
-    then let
-      apps = pkgs.buildEnv {
-        name = "home-manager-applications";
-        paths = config.home.packages;
-        pathsToLink = "/Applications";
-      };
-    in
-      lib.hm.dag.entryAfter ["linkGeneration"] ''
-        # Install MacOS applications to the user environment.
-        HM_APPS="$HOME/Applications/Home Manager Apps"
-        # Reset current state
-        if [ -e "$HM_APPS" ]; then
-          $DRY_RUN_CMD mv "$HM_APPS" "$HM_APPS.$(date +%Y%m%d%H%M%S)"
-        fi
-        $DRY_RUN_CMD mkdir -p "$HM_APPS"
-        # .app dirs need to be actual directories for Finder to detect them as Apps.
-        # In the env of Apps we build, the .apps are symlinks. We pass all of them as
-        # arguments to cp and make it dereference those using -H
-        $DRY_RUN_CMD cp --archive -H --dereference ${apps}/Applications/* "$HM_APPS"
-        $DRY_RUN_CMD chmod +w -R "$HM_APPS"
-      ''
-    else "";
-  # We need this in case upstream home-manager changes the behavior of linking
-  # applications
-  home.activation.remove-patch-spotlight =
-    if pkgs.stdenv.isDarwin
-    then
-      lib.hm.dag.entryBefore ["checkLinkTargets"] ''
-        HM_APPS="$HOME/Applications/Home Manager Apps"
-        # Reset current state
-        if [ -e "$HM_APPS" ]; then
-          $DRY_RUN_CMD mv "$HM_APPS" "$HM_APPS.$(date +%Y%m%d%H%M%S)"
-        fi
-      ''
-    else "";
-}

nix-conf/home-manager/base/default.nix

@@ -1,4 +1,6 @@
-{nix-index-database, ...} @ inputs: {
+{nix-index-database
+,...
+}@inputs:{
   mkModuleArgs = import ./mkModuleArgs.nix;
   modules = [
     ./alacritty.nix

nix-conf/home-manager/base/git.nix

@@ -1,8 +1,8 @@
-{
-  config,
-  myLib,
-  ...
-}: let
+{ config
+, myLib
+, ...
+}:
+let
   cfg = config.base.git;
   baseAliases = {
     a = "add";
@@ -15,7 +15,8 @@
     co = "checkout";
     b = "branch";
   };
-in {
+in
+{
   options.base.git = {
     aliases = myLib.mkOption {
       type = myLib.types.attrs;

nix-conf/home-manager/base/graphics.nix

@@ -1,13 +1,10 @@
-{
-  pkgs,
-  config,
-  lib,
-  ...
-}: let
+{ pkgs, config, lib, ... }:
+let
   cfg = config.base.graphics;
   cfgEnable = cfg.enable or (cfg.useNixGL.defaultPackage != null);
   types = lib.types;
-in {
+in
+{
   imports = [ ./shells.nix ];
   options.base.graphics = {
     enable = lib.mkEnableOption "graphics";
@@ -33,7 +30,7 @@ in {
       };
     };
   };
-  # NOTE: importing shells does not mean we're enabling everything, if we do mkDefault false
+  # importing shells does not mean we're enabling everything, if we do mkDefault false
   # but the dilemma is, if the user import BOTH graphics.nix and shells.nix
   # they will also need to do `config.base.shells.enable`
   # generally, we want the behavior: import means enable

nix-conf/home-manager/base/keepass.nix

@@ -1,13 +1,9 @@
-{
-  config,
-  proj_root,
-  pkgs,
-  lib,
-  ...
-}: let
+{ config, proj_root, pkgs, lib, ... }:
+let
   cfg = config.base.keepass;
   trimNull = lib.filterAttrsRecursive (name: value: value != null);
-in {
+in
+{
   imports = [ ./graphics.nix ];
   options.base.keepass = {
     enable = lib.mkEnableOption "keepass";
@@ -46,17 +42,11 @@ in {
     };
   };
   config = lib.mkIf cfg.enable {
-    home.packages =
-      [
+    home.packages = [
       pkgs.kpcli-py # kp but is in cli
-      ]
-      ++ (
-        if cfg.use_gui or config.base.graphics._enable
-        then [
+    ] ++ (if cfg.use_gui or config.base.graphics._enable then [
       pkgs.keepass # Personal secret management
-        ]
-        else []
-      );
+    ] else [ ]);
     home.file.".kp/config.ini".text = lib.generators.toINI { } (trimNull {
       default = {
         KEEPASSDB = cfg.path;

nix-conf/home-manager/base/mkModuleArgs.nix

@@ -1,10 +1,10 @@
 # Turns given inputs into the standardized shape of the inputs to configure  
 # custom base modules in this directory.
-{
-  pkgs,
-  lib ? pkgs.lib,
-  ...
-} @ inputs: let
+{ pkgs
+, lib ? pkgs.lib
+, ...
+}@inputs:
+let
   recursiveUpdate = lib.recursiveUpdate;
   _lib = recursiveUpdate lib (import ../../lib { inherit pkgs lib; });
   proj_root = builtins.toString ./../../..;

nix-conf/home-manager/base/neovim.nix

@@ -1,31 +1,27 @@
-# TODO: vim-plug and Mason supports laziness. Probably worth it to explore incremental dependencies based on the project TODO: just install these things, then symlink to mason's bin directory
+# TODO: vim-plug and Mason supports laziness. Probably worth it to explore
+# incremental dependencies based on the project
+# TODO: just install these things, then symlink to mason's bin directory
 #
 # One thing to consider, though, /nix/store of `nix-shell` or `nix-develop`
-# might be different from `home-manager`'s (~/.nix_profile/bin/jq)
-{
-  pkgs,
-  lib,
-  config,
-  proj_root,
-  ...
-}: let
+# might be different from `home-manager`'s
+{ pkgs, lib, config, proj_root, ... }:
+let
   # NOTE: Add packages to nvim_pkgs instead, so that it's available at userspace
   # and is added to the path after wrapping.
   # check: nix repl `homeConfigurations.hungtr.config.programs.neovim.finalPackage.buildCommand`
   # see: :/--suffix.*PATH
   # there should be mentions of additional packages
   my_neovim = pkgs.neovim-unwrapped;
-  rust_pkgs =
-    pkgs.rust-bin.selectLatestNightlyWith
+  rust_pkgs = (pkgs.rust-bin.selectLatestNightlyWith
     (
       toolchain:
       toolchain.default.override {
-          extensions = ["rust-src" "rust-analyzer" "rust-docs" "rustfmt" "clippy" "miri"];
+        extensions = [ "rust-src" ];
       }
-    );
-  nvim_pkgs =
-    [
+    ));
+  nvim_pkgs = [
     # pkgs.gccStdenv
+    pkgs.gcc
     pkgs.tree-sitter
     pkgs.fzf # file name fuzzy search
     pkgs.ripgrep # content fuzzy search
@@ -35,9 +31,10 @@
     pkgs.rnix-lsp  # doesn't work, Mason just installs it using cargo
     pkgs.rust4cargo
     pkgs.nickel
-      pkgs.nls
+    pkgs.lsp-nls
+
+    pkgs.go
 
-      pkgs.go # doesn't work, Mason installs from runtime path
 
     # Language-specific stuffs
     pkgs.sumneko-lua-language-server
@@ -45,7 +42,6 @@
     pkgs.nodePackages.pyright
     pkgs.python3Packages.pylint
     pkgs.python3Packages.flake8
-      # FIXME: installing ansible from here just doesn't work :/
     # pkgs.ansible-lint
     # pkgs.python38Packages.ansible
     # pkgs.ansible-language-server
@@ -55,37 +51,18 @@
     # pkgs.rust-analyzer
     # rust_pkgs
     # pkgs.evcxr # Rust REPL for Conjure!
-    ]
-    ++ lib.optionals (pkgs.stdenv.isDarwin) (
-      let
-        inherit (pkgs.darwin.apple_sdk.frameworks) System CoreFoundation;
-      in [
-        System
-        CoreFoundation
-      ]
-    );
-in {
+  ];
+in
+{
   options.base.neovim = {
     enable = lib.mkOption {
       default = true;
       description = "enable personalized neovim as default editor";
       type = lib.types.bool;
       example = false;
-      f = let
-        adder = {
-          __functor = self: arg:
-            if builtins.isInt arg
-            then self // {x = self.x + arg;}
-            else self.x;
-          x = 0;
-        };
-      in {
-        what = adder 1 2 3 {};
-      };
     };
   };
   config = lib.mkIf config.base.neovim.enable {
-    # home-manager
     programs.neovim = {
       enable = true;
       package = my_neovim;
@@ -93,100 +70,23 @@ in {
       vimAlias = true;
       withPython3 = true;
       withNodeJs = true;
+      # Attempt 4: Correct way to make neovim aware of packages
+      # homeConfigurations.config.programs.neovim takes UNWRAPPED neovim
+      # and wraps it. 
+      # Ideally, we build our own neovim and add that to config.home.packages
+      # to share it with nixOS. But we don't really need to share
       extraPackages = nvim_pkgs;
-      extraLuaConfig = builtins.readFile "${proj_root.config.path}//neovim/init.lua";
-      plugins = let
-        inherit
-          (pkgs.vimPlugins)
-          plenary-nvim
-          nvim-treesitter
-          nvim-treesitter-textobjects
-          nvim-treesitter-context
-          telescope-fzf-native-nvim
-          telescope-file-browser-nvim
-          telescope-nvim
-          nvim-lspconfig
-          gruvbox-community
-          neodev-nvim
-          cmp-nvim-lsp
-          cmp-path
-          cmp-buffer
-          cmp-cmdline
-          nvim-cmp
-          lspkind-nvim
-          nvim-autopairs
-          nvim-ts-autotag
-          guess-indent-nvim
-          harpoon
-          zk-nvim
-          luasnip
-          fidget-nvim
-          rust-tools-nvim
-          cmp_luasnip
-          gitsigns-nvim
-          indent-blankline-nvim
-          lualine-nvim
-          mason-lspconfig-nvim
-          mason-nvim
-          neogit
-          nlua-nvim
-          nvim-jqx
-          nvim-surround
-          nvim-web-devicons
-          playground
-          todo-comments-nvim
-          trouble-nvim
-          vim-dispatch
-          vim-dispatch-neovim
-          vim-fugitive
-          vim-jack-in
-          ;
-      in [
-        plenary-nvim
-        nvim-treesitter.withAllGrammars
-        nvim-treesitter-textobjects
-        telescope-fzf-native-nvim
-        telescope-file-browser-nvim
-        telescope-nvim
-        nvim-lspconfig
-        gruvbox-community
-        neodev-nvim
-        cmp-nvim-lsp
-        cmp-path
-        cmp-buffer
-        cmp-cmdline
-        nvim-cmp
-        lspkind-nvim
-        nvim-autopairs
-        nvim-ts-autotag
-        guess-indent-nvim
-        harpoon
-        zk-nvim
-        luasnip
-        nvim-treesitter-context
-        fidget-nvim
-        rust-tools-nvim
-
-        cmp_luasnip
-        gitsigns-nvim
-        indent-blankline-nvim
-        lualine-nvim
-        mason-lspconfig-nvim
-        mason-nvim
-        neogit
-        nlua-nvim
-        nvim-jqx
-        nvim-surround
-        nvim-web-devicons
-        playground
-        todo-comments-nvim
-        trouble-nvim
-        vim-dispatch
-        vim-dispatch-neovim
-        vim-fugitive
-        vim-jack-in
-      ];
+      # only for here for archive-documentation
+      # extraPython3Packages = (pypkgs: [
+      #   # pypkgs.python-lsp-server
+      #   pypkgs.ujson
+      # ]);
+      # I use vim-plug, so I probably don't require packaging
+      # extraConfig actually writes to init-home-manager.vim (not lua)
+      # https://github.com/nix-community/home-manager/pull/3287
+      # extraConfig = builtins.readFile "${proj_root}/neovim/init.lua";
     };
     # home.packages = nvim_pkgs;
+    xdg.configFile."nvim/init.lua".source = "${proj_root.config.path}//neovim/init.lua";
   };
 }

nix-conf/home-manager/base/private_chromium.nix

@@ -1,13 +1,9 @@
 # TODO: maybe throw if base.graphics is not enabled?
 # Though, headless chromium might be possible
+{ config, pkgs, lib, ... }:
+let cfg = config.base.private_chromium;
+in
 {
-  config,
-  pkgs,
-  lib,
-  ...
-}: let
-  cfg = config.base.private_chromium;
-in {
   options.base.private_chromium = {
     enable = lib.mkOption {
       type = lib.types.bool;
@@ -23,29 +19,25 @@ in {
     programs.chromium = {
       enable = true;
       package = pkgs.ungoogled-chromium;
-      extensions = let
-        # TODO: how about a chrome extension registry?
-        mkChromiumExtForVersion = browserVersion: {
-          id,
-          sha256,
-          extVersion,
-          ...
-        }: {
+      extensions =
+        let
+          mkChromiumExtForVersion = browserVersion: { id, sha256, extVersion, ... }:
+            {
               inherit id;
               crxPath = builtins.fetchurl {
-            url =
-              "https://clients2.google.com/service/update2/crx"
-              + "?response=redirect"
-              + "&acceptformat=crx2,crx3"
-              + "&prodversion=${browserVersion}"
-              + "&x=id%3D${id}%26installsource%3Dondemand%26uc";
+                url = "https://clients2.google.com/service/update2/crx" +
+                  "?response=redirect" +
+                  "&acceptformat=crx2,crx3" +
+                  "&prodversion=${browserVersion}" +
+                  "&x=id%3D${id}%26installsource%3Dondemand%26uc";
                 name = "${id}.crx";
                 inherit sha256;
               };
               version = extVersion;
             };
           mkChromiumExt = mkChromiumExtForVersion (lib.versions.major pkgs.ungoogled-chromium.version);
-      in [
+        in
+        [
           # vimium
           (mkChromiumExt {
             id = "dbepggeogbaibhgnhhndojpepiihcmeb";

nix-conf/home-manager/base/shells.nix

@@ -1,14 +1,14 @@
 # Configurations for shell stuffs.
-# Should probably be decoupled even more for each feature
+# Should probably be decoupled even more
+{ config
+, proj_root
+, myLib
+, pkgs
+, ...
+}:
+let cfg = config.base.shells;
+in
 {
-  config,
-  proj_root,
-  myLib,
-  pkgs,
-  ...
-}: let
-  cfg = config.base.shells;
-in {
   options.base.shells = {
     enable = myLib.mkOption {
       type = myLib.types.bool;
@@ -37,6 +37,7 @@ in {
     };
   };
   config = myLib.mkIf cfg.enable {
+    xdg.configFile."starship.toml".source = "${proj_root.config.path}//starship/starship.toml";
     # nix: Propagates the environment with packages and vars when enter (children of)
     # a directory with shell.nix-compatible and .envrc
     programs.direnv = {
@@ -51,37 +52,16 @@ in {
     };
     programs.tmux = {
       enable = true;
-      # extraConfigBeforePlugin = builtins.readFile "${proj_root.config.path}/tmux/tmux.conf";
-      plugins = let inherit (pkgs.tmuxPlugins) cpu net-speed; in [cpu net-speed];
       extraConfig = builtins.readFile "${proj_root.config.path}/tmux/tmux.conf";
     };
-    xdg.configFile."tmux/tmux.conf".text = myLib.mkOrder 600 ''
-      set -g status-right '#{cpu_bg_color} CPU: #{cpu_icon} #{cpu_percentage} | %a %h-%d %H:%M '
-    '';
-    # Colored ls
     programs.exa = {
       enable = true;
       enableAliases = true;
     };
-    # Make the shell look beautiful
     programs.starship = {
       enable = true;
       enableZshIntegration = true;
-      settings = let
-        native = builtins.fromTOML (builtins.readFile "${proj_root.config.path}/starship/starship.toml");
-        patch-nix = pkgs.lib.recursiveUpdate native {
-          # WARNING: home-manager fails on here for some reason. Likely not at the 
-          # validation phase (type-checking), but at evaluation phaase (stringify)
-          # c.commands = [
-          #   ["nix" "run" "nixpkgs#clang" "--" "--version"]
-          #   ["nix" "run" "nixpkgs#gcc" "--" "--version"]
-          # ];
-          c.commands = "fuk";
     };
-      in
-        patch-nix;
-    };
-    # Fuzzy finder. `fzf` for TUI, `fzf -f '<fuzzy query>'` for UNIX piping
     programs.fzf.enable = true;
     programs.bash = {
       enable = true;
@@ -92,12 +72,10 @@ in {
       enable = true;
       enableCompletion = true;
       enableAutosuggestions = true;
-      shellAliases =
-        {
+      shellAliases = {
         nix-rebuild = "sudo nixos-rebuild switch";
         hm-switch = "home-manager switch --flake";
-        }
-        // (cfg.shellAliases or {});
+      } // (cfg.shellAliases or { });
       history = {
         size = 10000;
         path = "${config.xdg.dataHome}/zsh/history";
@@ -116,8 +94,6 @@ in {
         ];
       };
       sessionVariables = {
-        # Vim mode on the terminal
-
         # VI_MODE_RESET_PROMPT_ON_MODE_CHANGE = true;
         # VI_MODE_SET_CURSOR = true;
         # ZVM_VI_ESCAPE_BINDKEY = "";
@@ -125,11 +101,10 @@ in {
         ZVM_KEYTIMEOUT = 0.004; # 40ms, or subtly around 25 FPS. I'm a gamer :)
         ZVM_ESCAPE_KEYTIMEOUT = 0.004; # 40ms, or subtly around 25 FPS. I'm a gamer :)
       };
-      initExtra =
-        (cfg.shellInitExtra or "")
-        + ''
+      initExtra = (cfg.shellInitExtra or "") + ''
         source ${pkgs.zsh-vi-mode}/share/zsh-vi-mode/zsh-vi-mode.plugin.zsh
       '';
+
     };
   };
 }

nix-conf/home-manager/base/ssh.nix

@@ -1,11 +1,11 @@
+{ config
+, proj_root
+, myLib
+, ...
+}:
+let cfg = config.base.ssh;
+in
 {
-  config,
-  proj_root,
-  myLib,
-  ...
-}: let
-  cfg = config.base.ssh;
-in {
   options.base.ssh.enable = myLib.mkOption {
     type = myLib.types.bool;
     default = true;
@@ -17,6 +17,7 @@ in {
   config.programs.ssh = {
     inherit (cfg) enable;
     forwardAgent = true;
-    includes = ["${proj_root.config.path}/ssh/config"];
+    extraConfig = builtins.readFile "${proj_root.config.path}/ssh/config";
   };
 }
+

nix-conf/home-manager/default.nix

@@ -1,6 +1,5 @@
 # We use top-level nix-flake, so default.nix is basically just a wrapper around ./flake.nix
-(
-  import
+(import
   (
     let 
       lock = builtins.fromJSON (builtins.readFile ./flake.lock);
@@ -9,5 +8,4 @@
     c_.fetchTree lock.nodes.flake-compat.locked
   )
   { src = ./.; }
-)
-.defaultNix
+).defaultNix

nix-conf/home-manager/flake.nix

@@ -10,16 +10,13 @@
       "nix-community.cachix.org-1:mB9FSh9qf2dCimDSUo8Zy7bkq5CX+/rkCWyvRCYg3Fs="
       "cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY="
     ];
-    max-jobs = 12;
   };
   description = "simple home-manager config";
   inputs = {
     nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
-    nixpkgs-latest.url = "github:nixos/nixpkgs";
     home-manager = {
       url = "github:nix-community/home-manager";
-      # url = "github:pegasust/home-manager/starship-config-type";
-      follows = "nixpkgs";
+      inputs.nixpkgs.follows = "nixpkgs";
     };
     flake-utils.url = "github:numtide/flake-utils";
     nixgl.url = "path:./../../out-of-tree/nixGL";
@@ -29,47 +26,47 @@
       url = "path:../../out-of-tree/flake-compat";
       flake = false;
     };
-    nix-boost.url = "git+https://git.pegasust.com/pegasust/nix-boost.git";
     kpcli-py = {
       url = "github:rebkwok/kpcli";
       flake = false;
     };
     neovim-nightly-overlay = {
-      url = "github:nix-community/neovim-nightly-overlay?rev=88a6c749a7d126c49f3374f9f28ca452ea9419b8";
+      url = "github:nix-community/neovim-nightly-overlay";
+      # Pin to a nixpkgs revision that doesn't have NixOS/nixpkgs#208103 yet
+      inputs.nixpkgs.url = "github:nixos/nixpkgs?rev=fad51abd42ca17a60fc1d4cb9382e2d79ae31836";
     };
     nix-index-database = {
       url = "github:mic92/nix-index-database";
       inputs.nixpkgs.follows = "nixpkgs";
     };
+    nickel.url = "github:tweag/nickel";
   };
 
-  outputs = flake_inputs @ {
-    nixpkgs,
-    home-manager,
-    nixgl,
-    rust-overlay,
-    flake-utils,
-    kpcli-py,
-    neovim-nightly-overlay,
-    nix-boost,
-    nixpkgs-latest,
-    ...
-  }: let
+  outputs =
+    flake_inputs@{ nixpkgs
+    , home-manager
+    , nixgl
+    , rust-overlay
+    , flake-utils
+    , kpcli-py
+    , neovim-nightly-overlay
+    , nickel
+    , ...
+    }:
+    let
       # config_fn:: system -> config
-    cross_platform = config_fn: {
-      packages =
-        builtins.foldl'
-        (prev: system:
-          prev
-          // {
+      cross_platform = config_fn: ({
+        packages = builtins.foldl'
+          (prev: system: prev // {
             "${system}" = config_fn system;
           })
           { }
           flake-utils.lib.defaultSystems;
-    };
+      });
     in
-    cross_platform (system: let
-      overlays = import ./overlays.nix (flake_inputs // {inherit system;});
+    cross_platform (system:
+    let
+      overlays = import ./../../overlays.nix (flake_inputs // {inherit system;});
       # pkgs = nixpkgs.legacyPackages.${system}.appendOverlays overlays;
       pkgs = import nixpkgs {
         inherit system overlays;
@@ -79,34 +76,32 @@
       base = import ./base flake_inputs;
       inherit (base) mkModuleArgs;
 
-      nerd_font_module = {
-        config,
-        pkgs,
-        ...
-      }: {
+      nerd_font_module = { config, pkgs, ... }: {
         fonts.fontconfig.enable = true;
         home.packages = [
-          # list of fonts are available at https://github.com/NixOS/nixpkgs/blob/nixos-unstable/pkgs/data/fonts/nerdfonts/shas.nix
-          (pkgs.nerdfonts.override {fonts = ["Hack"];})
+          (pkgs.nerdfonts.override { fonts = [ "DroidSansMono" ]; })
         ];
-        base.alacritty.font.family = "Hack Nerd Font Mono";
+        # For some reasons, Windows es in the font name as DroidSansMono NF
+        # so we need to override this
+        base.alacritty.font.family = "DroidSansMono Nerd Font";
       };
-    in {
+    in
+    {
       debug = {
         inherit overlays pkgs base;
       };
-      homeConfigurations = let
+      homeConfigurations =
+        let
           x11_wsl = ''
             # x11 output for WSL
             export DISPLAY=$(ip route list default | awk '{print $3}'):0
             export LIBGL_ALWAYS_INDIRECT=1
           '';
-      in {
+        in
+        {
           "hungtr" = home-manager.lib.homeManagerConfiguration {
             inherit pkgs;
-          modules =
-            base.modules
-            ++ [
+            modules = base.modules ++ [
               ./home.nix
             ];
             # optionally pass inarguments to module
@@ -122,9 +117,7 @@
           };
           "hungtr@bao" = home-manager.lib.homeManagerConfiguration {
             inherit pkgs;
-          modules =
-            base.modules
-            ++ [
+            modules = base.modules ++ [
               ./home.nix
               nerd_font_module
               ./base/productive_desktop.nix
@@ -151,9 +144,7 @@
           # Personal darwin, effectively serves as the Darwin edge channel
           "hungtran" = home-manager.lib.homeManagerConfiguration { 
             inherit pkgs;
-          modules =
-            base.modules
-            ++ [
+            modules = base.modules ++ [
               ./home.nix
               {
                 base.graphics.enable = false;
@@ -168,11 +159,6 @@
               {
                 base.private_chromium.enable = false;
               }
-              {
-                home.packages = [
-                  pkgs.postman
-                ];
-              }
             ];
             extraSpecialArgs = mkModuleArgs {
               inherit pkgs;
@@ -185,30 +171,23 @@
           # Work darwin
           "htran" = home-manager.lib.homeManagerConfiguration { 
             inherit pkgs;
-          modules =
-            base.modules
-            ++ [
+            modules = base.modules ++ [
               ./home.nix
               ./base/productive_desktop.nix
-              ./base/darwin-spotlight.nix
               {
                 base.private_chromium.enable = false;
               }
-              nerd_font_module
               {
                 base.graphics.enable = false;
                 # don't want to deal with GL stuffs on mac yet :/
                 base.graphics.useNixGL.defaultPackage = null;
+                # NOTE: this actually does not exist
+                base.keepass.path = "/Users/htran/keepass.kdbx";
                 base.alacritty.font.size = 11.0;
                 base.git.name = "Hung";
                 base.git.email = "htran@egihosting.com";
               }
-              {
-                home.packages = [
-                  pkgs.postman
-                ];
-              }
-              {base.keepass.enable = pkgs.lib.mkForce false;}
+              nerd_font_module
             ];
             extraSpecialArgs = mkModuleArgs {
               inherit pkgs;
@@ -224,10 +203,8 @@
               ./home.nix
               {
                 base.shells = {
-                shellInitExtra =
-                  ''
-                  ''
-                  + x11_wsl;
+                  shellInitExtra = ''
+                '' + x11_wsl;
                 };
               }
             ];
@@ -242,12 +219,27 @@
               };
             };
           };
+          # NOTE: This is never actually tested. This is for Ubuntu@Felia
+          # "ubuntu_admin" = home-manager.lib.homeManagerConfiguration {
+          #   inherit pkgs;
+          #   modules = [
+          #     ./home.nix
+          #   ];
+          #   extraSpecialArgs = {
+          #     myLib = lib;
+          #     myHome = {
+          #       username = "ubuntu_admin";
+          #       homeDirectory = "/home/ubuntu_admin";
+          #       shellInitExtra = ''
+          #       '' + x11_wsl;
+          #     };
+          #   };
+          # };
+
           # Personal laptop
           hwtr = home-manager.lib.homeManagerConfiguration {
             inherit pkgs;
-          modules =
-            base.modules
-            ++ [
+            modules = base.modules ++ [
               ./home.nix
               ./base/graphics.nix
               {

nix-conf/home-manager/fromYamlSandbox/flake.lock

@@ -0,0 +1,44 @@
+{
+  "nodes": {
+    "from-yaml": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1667993008,
+        "narHash": "sha256-X5RWyebq+j56mUGGCmZTVcJBy6Y/QgFEMHklaz+GOt0=",
+        "owner": "pegasust",
+        "repo": "fromYaml",
+        "rev": "23d2616051f5a781dcfe2915a526925fd9cdd08c",
+        "type": "github"
+      },
+      "original": {
+        "owner": "pegasust",
+        "repo": "fromYaml",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1667811565,
+        "narHash": "sha256-HYml7RdQPQ7X13VNe2CoDMqmifsXbt4ACTKxHRKQE3Q=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "667e5581d16745bcda791300ae7e2d73f49fff25",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "from-yaml": "from-yaml",
+        "nixpkgs": "nixpkgs"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

nix-conf/home-manager/fromYamlSandbox/flake.nix

@@ -0,0 +1,111 @@
+{
+  inputs = {
+    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
+    from-yaml = {
+      url = "github:pegasust/fromYaml";
+      flake = false;
+    };
+  };
+  outputs = { nixpkgs, from-yaml, ... }:
+    let
+      system = "x86_64-linux";
+      pkgs = import nixpkgs { inherit system; };
+      lib = {
+        fromYaml = import "${from-yaml}/fromYaml.nix" { lib = pkgs.lib; };
+      };
+    in
+    {
+      inherit nixpkgs;
+      inherit from-yaml;
+      inherit lib;
+      inherit pkgs;
+      fromYamlFn = lib.fromYaml;
+      yamlCmd = str: (builtins.fromJSON (pkgs.runCommand "echo ${str} | yq"));
+      test_0 = ''
+        key_bindings:
+          - hello:
+              "N"
+      '';
+      key_bind = ''
+        key_bindings:
+          - { key: N, mods: Control, action: CreateNewWindow }
+          # - { key: Paste,                                       action: Paste          }
+          # - { key: Copy,                                        action: Copy           }
+          #- { key: L,         mods: Control,                    action: ClearLogNotice }
+          #- { key: L,         mods: Control, mode: ~Vi|~Search, chars: "\x0c"          }
+          #- { key: PageUp,    mods: Shift,   mode: ~Alt,        action: ScrollPageUp   }
+          #- { key: PageDown,  mods: Shift,   mode: ~Alt,        action: ScrollPageDown }
+          #- { key: Home,      mods: Shift,   mode: ~Alt,        action: ScrollToTop    }
+          #- { key: End,       mods: Shift,   mode: ~Alt,        action: ScrollToBottom }
+
+          # Vi Mode
+          #- { key: Space,  mods: Shift|Control, mode: ~Search,    action: ToggleViMode            }
+          - { key: Escape, mods: Shift, mode: ~Search, action: ToggleViMode }
+          #- { key: Space,  mods: Shift|Control, mode: Vi|~Search, action: ScrollToBottom          }
+          #- { key: Escape,                      mode: Vi|~Search, action: ClearSelection          }
+          #- { key: I,                           mode: Vi|~Search, action: ToggleViMode            }
+          #- { key: I,                           mode: Vi|~Search, action: ScrollToBottom          }
+          #- { key: C,      mods: Control,       mode: Vi|~Search, action: ToggleViMode            }
+          #- { key: Y,      mods: Control,       mode: Vi|~Search, action: ScrollLineUp            }
+          #- { key: E,      mods: Control,       mode: Vi|~Search, action: ScrollLineDown          }
+          #- { key: G,                           mode: Vi|~Search, action: ScrollToTop             }
+          #- { key: G,      mods: Shift,         mode: Vi|~Search, action: ScrollToBottom          }
+          #- { key: B,      mods: Control,       mode: Vi|~Search, action: ScrollPageUp            }
+          #- { key: F,      mods: Control,       mode: Vi|~Search, action: ScrollPageDown          }
+          #- { key: U,      mods: Control,       mode: Vi|~Search, action: ScrollHalfPageUp        }
+          #- { key: D,      mods: Control,       mode: Vi|~Search, action: ScrollHalfPageDown      }
+          #- { key: Y,                           mode: Vi|~Search, action: Copy                    }
+          #- { key: Y,                           mode: Vi|~Search, action: ClearSelection          }
+          #- { key: Copy,                        mode: Vi|~Search, action: ClearSelection          }
+          #- { key: V,                           mode: Vi|~Search, action: ToggleNormalSelection   }
+          #- { key: V,      mods: Shift,         mode: Vi|~Search, action: ToggleLineSelection     }
+          #- { key: V,      mods: Control,       mode: Vi|~Search, action: ToggleBlockSelection    }
+          #- { key: V,      mods: Alt,           mode: Vi|~Search, action: ToggleSemanticSelection }
+          #- { key: Return,                      mode: Vi|~Search, action: Open                    }
+          #- { key: Z,                           mode: Vi|~Search, action: CenterAroundViCursor    }
+          #- { key: K,                           mode: Vi|~Search, action: Up                      }
+          #- { key: J,                           mode: Vi|~Search, action: Down                    }
+          #- { key: H,                           mode: Vi|~Search, action: Left                    }
+          #- { key: L,                           mode: Vi|~Search, action: Right                   }
+          #- { key: Up,                          mode: Vi|~Search, action: Up                      }
+          #- { key: Down,                        mode: Vi|~Search, action: Down                    }
+          #- { key: Left,                        mode: Vi|~Search, action: Left                    }
+          #- { key: Right,                       mode: Vi|~Search, action: Right                   }
+          #- { key: Key0,                        mode: Vi|~Search, action: First                   }
+          #- { key: Key4,   mods: Shift,         mode: Vi|~Search, action: Last                    }
+          #- { key: Key6,   mods: Shift,         mode: Vi|~Search, action: FirstOccupied           }
+          #- { key: H,      mods: Shift,         mode: Vi|~Search, action: High                    }
+          #- { key: M,      mods: Shift,         mode: Vi|~Search, action: Middle                  }
+          #- { key: L,      mods: Shift,         mode: Vi|~Search, action: Low                     }
+          #- { key: B,                           mode: Vi|~Search, action: SemanticLeft            }
+          #- { key: W,                           mode: Vi|~Search, action: SemanticRight           }
+          #- { key: E,                           mode: Vi|~Search, action: SemanticRightEnd        }
+          #- { key: B,      mods: Shift,         mode: Vi|~Search, action: WordLeft                }
+          #- { key: W,      mods: Shift,         mode: Vi|~Search, action: WordRight               }
+          #- { key: E,      mods: Shift,         mode: Vi|~Search, action: WordRightEnd            }
+          #- { key: Key5,   mods: Shift,         mode: Vi|~Search, action: Bracket                 }
+          #- { key: Slash,                       mode: Vi|~Search, action: SearchForward           }
+          #- { key: Slash,  mods: Shift,         mode: Vi|~Search, action: SearchBackward          }
+          #- { key: N,                           mode: Vi|~Search, action: SearchNext              }
+          #- { key: N,      mods: Shift,         mode: Vi|~Search, action: SearchPrevious          }
+
+          # Search Mode
+          #- { key: Return,                mode: Search|Vi,  action: SearchConfirm         }
+          #- { key: Escape,                mode: Search,     action: SearchCancel          }
+          #- { key: C,      mods: Control, mode: Search,     action: SearchCancel          }
+          #- { key: U,      mods: Control, mode: Search,     action: SearchClear           }
+          #- { key: W,      mods: Control, mode: Search,     action: SearchDeleteWord      }
+          #- { key: P,      mods: Control, mode: Search,     action: SearchHistoryPrevious }
+          #- { key: N,      mods: Control, mode: Search,     action: SearchHistoryNext     }
+          #- { key: Up,                    mode: Search,     action: SearchHistoryPrevious }
+          #- { key: Down,                  mode: Search,     action: SearchHistoryNext     }
+          #- { key: Return,                mode: Search|~Vi, action: SearchFocusNext       }
+          #- { key: Return, mods: Shift,   mode: Search|~Vi, action: SearchFocusPrevious   }
+
+          # (Windows, Linux, and BSD only)
+          - { key: V,              mods: Control|Shift, mode: ~Vi,        action: Paste            }
+          - { key: C,              mods: Control|Shift,                   action: Copy             }
+      '';
+    };
+}
+

nix-conf/home-manager/home.nix

@@ -3,20 +3,18 @@
 # This file represents the base settings for each machine
 # Additional configurations goes to profiles/<user>
 # or inlined in flake.nix
-{
-  config,
-  # Represents the realized final configuration
-  pkgs,
-  # This is by default just ``= import <nixpkgs>{}`
-  myHome,
-  myLib,
-  option,
-  # The options we're given, this might be useful for typesafety?
-  proj_root,
-  ...
-}: let
+{ config # Represents the realized final configuration
+, pkgs # This is by default just ``= import <nixpkgs>{}`
+, myHome
+, myLib
+, option # The options we're given, this might be useful for typesafety?
+, proj_root
+, ...
+}:
+let
   inherit (myLib) fromYaml;
-in {
+in
+{
   imports = [
     ./base/neovim.nix
     ./base/keepass.nix
@@ -26,8 +24,7 @@ in {
     homeDirectory = myHome.homeDirectory;
     stateVersion = myHome.stateVersion or "22.05";
   };
-  home.packages = pkgs.lib.unique (
-    [
+  home.packages = pkgs.lib.unique ([
     # pkgs.ncdu
     pkgs.rclone # cloud file operations
     pkgs.htop # system diagnostics in CLI
@@ -40,7 +37,7 @@ in {
     # pkgs.xorg.xclock # TODO: only include if have gui # For testing GL installation
     # pkgs.logseq # TODO: only include if have GL # Obsidian alt
     pkgs.mosh # Parsec for SSH
-      # pkgs.nixops_unstable # nixops v2 # insecure for now
+    pkgs.nixops_unstable # nixops v2 # insecure for now
     pkgs.lynx # Web browser at your local terminal
     pkgs.zk
 
@@ -49,15 +46,9 @@ in {
     # pkgs.python310.numpy
     # pkgs.python310Packages.tensorflow
     # pkgs.python310Packages.scikit-learn
-    ]
-    ++ (myHome.packages or [])
-    ++ (
-      if pkgs.system == "x86_64-linux"
-      then [
+  ] ++ (myHome.packages or [ ]) ++ (if pkgs.system == "x86_64-linux" then [
     pkgs.logseq
-      ]
-      else []
-    )
+  ] else [ ])
   );
 
   ## Configs ## 
@@ -67,6 +58,9 @@ in {
   programs.jq = {
     enable = true;
   };
+  # not exist in home-manager
+  # have to do it at system level
+  # services.ntp.enable = true; # automatic time
   programs.nix-index = {
     enable = true;
     enableBashIntegration = true;

nix-conf/home-manager/htran/nix.conf

@@ -1,6 +0,0 @@
-accept-flake-config = true
-experimental-features = nix-command flakes
-post-build-hook = /etc/nix/upload-to-cache.sh
-trusted-users = root htran hungtran hwtr
-max-jobs = 8
-cores = 12

nix-conf/home-manager/hwtr/nix.conf

@@ -1,5 +1,3 @@
 accept-flake-config = true
 experimental-features = nix-command flakes
-post-build-hook = /etc/nix/upload-to-cache.sh
-trusted-users = root htran hungtran hwtr
 

nix-conf/home-manager/nix.conf

@@ -1,4 +0,0 @@
-accept-flake-config = true
-experimental-features = nix-command flakes
-post-build-hook = /etc/nix/upload-to-cache.sh
-trusted-users = root htran hungtran hwtr

nix-conf/home-manager/overlays.nix

@@ -1,71 +0,0 @@
-flake_input @ {
-  kpcli-py,
-  nixgl,
-  rust-overlay,
-  neovim-nightly-overlay,
-  system,
-  nix-boost,
-  nixpkgs-latest,
-  ...
-}: let
-  kpcli-py = final: prev: {
-    # use python3.9, which works because of cython somehow?
-    kpcli-py = final.poetry2nix.mkPoetryApplication {
-      projectDir = flake_input.kpcli-py;
-      overrides = final.poetry2nix.defaultPoetryOverrides.extend (self: super: {
-        # tableformatter requires setuptools
-        tableformatter = super.tableformatter.overridePythonAttrs (
-          old: {
-            buildInputs = (old.buildInputs or []) ++ [self.setuptools self.cython_3];
-            src = old.src;
-          }
-        );
-        kpcli = super.kpcli.overridePythonAttrs (old: {
-          buildInputs = (old.buildInputs or []) ++ [self.setuptools];
-        });
-
-        # ubersmith = super.ubersmith.overridePythonAttrs (old: {
-        #   buildInputs = builtins.filter (x: ! builtins.elem x [ ]) ((old.buildInputs or [ ]) ++ [
-        #     py-final.setuptools
-        #     py-final.pip
-        #   ]);
-        #
-        #   src = final.fetchFromGitHub {
-        #     owner = "jasonkeene";
-        #     repo = "python-ubersmith";
-        #     rev = "0c594e2eb41066d1fe7860e3a6f04b14c14f6e6a";
-        #     sha256 = "sha256-Dystt7CBtjpLkgzCsAif8WkkYYeLyh7VMehAtwoDGuM=";
-        #   };
-        # });
-      });
-    };
-  };
-
-  rust = final: prev: let
-    nightlyRustWithExts = exts:
-      final.rust-bin.selectLatestNightlyWith (
-        toolchain: (toolchain.minimal.override {
-          extensions = exts;
-        })
-      );
-    # https://rust-lang.github.io/rustup/concepts/profiles.html
-    rust-default-components = ["rust-docs" "rustfmt" "clippy"];
-    rust-dev-components = rust-default-components ++ ["rust-src" "rust-analyzer" "miri"];
-  in {
-    rust4devs = nightlyRustWithExts rust-dev-components;
-    rust4cargo = nightlyRustWithExts [];
-    rust4normi = nightlyRustWithExts rust-default-components;
-  };
-
-  vimPlugins = final: prev: {
-    inherit (nixpkgs-latest.legacyPackages.${system}) vimPlugins;
-  };
-in [
-  nix-boost.overlays.default
-  nixgl.overlays.default
-  rust-overlay.overlays.default
-  neovim-nightly-overlay.overlay
-  rust
-  kpcli-py
-  vimPlugins
-]

nix-conf/home-manager/profiles/default.nix

@@ -1,8 +1,5 @@
 # main module exporter for different configuration profiles
+{ pkgs, libs, ... } @ inputs:
 {
-  pkgs,
-  libs,
-  ...
-} @ inputs: {
   hwtr = import ./hwtr.nix;
 }

nix-conf/lib/default.nix

@@ -1,8 +1,8 @@
-{
-  pkgs,
-  lib ? pkgs.lib,
-  ...
-} @ flake_import: let
+{ pkgs
+, lib ? pkgs.lib
+, ...
+}@flake_import:
+let
   serde = import ./serde { inherit pkgs lib; };
   recursiveUpdate = lib.recursiveUpdate;
 in

nix-conf/lib/serde/default.nix

@@ -1,39 +1,30 @@
 # Takes care of serializing and deserializing to some formats
 # Blame: Pegasust<pegasucksgg@gmail.com>
 # TODO: Add to* formats from pkgs.formats.*
-{
-  pkgs,
-  lib,
-} @ inputs: let
-  yamlToJsonDrv = yamlContent: outputPath:
-    pkgs.callPackage
+{ pkgs
+, lib
+} @ inputs:
+let
+  yamlToJsonDrv = yamlContent: outputPath: pkgs.callPackage
     ({ runCommand }:
       # runCommand source: https://github.com/NixOS/nixpkgs/blob/master/pkgs/build-support/trivial-builders.nix#L33
-        runCommand outputPath
-        {
-          inherit yamlContent;
-          nativeBuildInputs = [pkgs.yq];
-        }
+      runCommand outputPath { inherit yamlContent; nativeBuildInputs = [ pkgs.yq ]; }
         # run yq which outputs '.' (no filter) on file at yamlPath
         # note that $out is passed onto the bash/sh script for execution
         ''
           echo "$yamlContent" | yq >$out
         '')
     { };
-in {
+in
+{
   # Takes in a yaml string and produces a derivation with translated JSON at $outputPath
   # similar to builtins.fromJSON, turns a YAML string to nix attrset
   fromYaml = yamlContent: builtins.fromJSON (builtins.readFile (yamlToJsonDrv yamlContent "any_output.json"));
-  fromYamlPath = yamlPath:
-    builtins.fromJSON (
+  fromYamlPath = yamlPath: builtins.fromJSON (
     builtins.readFile (
       yamlToJsonDrv
         (
-          builtins.readFile yamlPath
-        )
-        "any-output.json"
-      )
-    );
-  fromTOML = builtins.fromTOML;
-  fromJSON = builtins.fromJSON;
+          builtins.readFile yamlPath)
+        "any-output.json"));
+  # TODO: fromToml?
 }

nix-conf/pkgs/default.nix

@@ -1,11 +1,9 @@
 # This module aims to be merge (not inject/override) with top-level pkgs to provide
 # personalized/custom packages
-{
-  pkgs,
-  lib,
-  naersk,
-  # rust packages
-  ...
+{ pkgs
+, lib
+, naersk # rust packages
+, ...
 }@pkgs_input: {
   # dot-hwtr = import "./dot-hwtr" pkgs_input;
   cargo-bacon = pkgs.rustPlatform.buildRustPackage rec {

nix-conf/pkgs/flake.nix

@@ -4,12 +4,10 @@
     rust-overlay.url = "github:oxalica/rust-overlay";
     naersk.url = "gihub:nix-community/naersk";
   };
-  outputs = {
-    nixpkgs,
-    rust-overlay,
-    naersk,
-  }: let
+  outputs = { nixpkgs, rust-overlay, naersk }:
+    let
       pkgs = import nixpkgs { overlays = [ rust-overlay.overlays.default ]; };
       lib = pkgs.lib;
-  in (import ./default.nix {inherit pkgs lib naersk;});
+    in
+    (import ./default.nix { inherit pkgs lib naersk; });
 }

nix-conf/secrets.nix

@@ -10,8 +10,10 @@ let
   all = users // systems;
   # stands for calculus
   c_ = builtins;
-in {
-  "system/secrets/s3fs.age".publicKeys = c_.attrValues all;
-  "system/secrets/s3fs.digital-garden.age".publicKeys = c_.attrValues all;
-  "system/secrets/_nhitrl.age".publicKeys = c_.attrValues all;
+in
+{
+  "system/secrets/s3fs.age".publicKeys = c_.attrValues (all);
+  "system/secrets/s3fs.digital-garden.age".publicKeys = c_.attrValues (all);
+  "system/secrets/_nhitrl.age".publicKeys = c_.attrValues (all);
+
 }

nix-conf/system/configuration.nix

@@ -1,11 +1,5 @@
-{
-  lib,
-  pkgs,
-  config,
-  modulesPath,
-  specialArgs,
-  ...
-}: let
+{ lib, pkgs, config, modulesPath, specialArgs, ... }:
+let
   hostname = specialArgs.hostname;
   enableSSH = specialArgs.enableSSH or true;
   _networking = lib.recursiveUpdate { hostName = hostname; } (specialArgs._networking or { });
@@ -14,16 +8,11 @@
   includeHardware = specialArgs.includeHardware or true;
   proj_root = builtins.toString ./../..;
 in
-  with lib; {
-    imports =
-      (
-        if includeHardware
-        then [
+with lib;
+{
+  imports = (if includeHardware then [
     "${proj_root}/hosts/${hostname}/hardware-configuration.nix"
-        ]
-        else []
-      )
-      ++ [
+  ] else [ ]) ++ [
     "${modulesPath}/profiles/minimal.nix"
     "${proj_root}/modules/tailscale.sys.nix"
     "${proj_root}/modules/mosh.sys.nix"
@@ -69,3 +58,4 @@ in
     pkgs.sysstat # sys diag
   ];
 }
+

nix-conf/system/flake.nix

@@ -7,12 +7,8 @@
     };
   };
 
-  outputs = {
-    self,
-    nixpkgs,
-    agenix,
-    ...
-  }: let
+  outputs = { self, nixpkgs, agenix, ... }:
+    let
       lib = nixpkgs.lib;
       proj_root = ./../..;
       # TODO: Change respectively to the system or make a nix shell to alias `nix run github:ryantm/agenix -- `
@@ -34,13 +30,12 @@
           environment.systemPackages = [ agenix.defaultPackage.x86_64-linux ];
         }
       ];
-  in {
+    in
+    {
       # Windows with NixOS WSL
       nixosConfigurations.Felia = nixpkgs.lib.nixosSystem {
         system = "x86_64-linux";
-      modules =
-        base_modules
-        ++ [
+        modules = base_modules ++ [
           ./wsl-configuration.nix
           {
             system.stateVersion = "22.05";
@@ -57,9 +52,7 @@
       };
       nixosConfigurations.lizzi = nixpkgs.lib.nixosSystem {
         system = "x86_64-linux";
-      modules =
-        base_modules
-        ++ [
+        modules = base_modules ++ [
           ./configuration.nix
           {
             system.stateVersion = "22.05";
@@ -69,12 +62,10 @@
         specialArgs = {
           hostname = "lizzi";
           _networking = {
-          interfaces.eth1.ipv4.addresses = [
-            {
+            interfaces.eth1.ipv4.addresses = [{
               address = "71.0.0.1";
               prefixLength = 24;
-            }
-          ];
+            }];
             firewall = {
               enable = true;
               allowedTCPPorts = [ 80 443 22 ];
@@ -121,9 +112,7 @@
       # Generic machine
       nixosConfigurations.pixi = nixpkgs.lib.nixosSystem {
         system = "x86_64-linux";
-      modules =
-        base_modules
-        ++ [
+        modules = base_modules ++ [
           ./configuration.nix
           {
             system.stateVersion = "22.05";
@@ -179,9 +168,7 @@
       };
       nixosConfigurations.nyx = nixpkgs.lib.nixosSystem {
         system = "x86_64-linux";
-      modules =
-        base_modules
-        ++ [
+        modules = base_modules ++ [
           ./configuration.nix
           {
             system.stateVersion = "22.05";
@@ -191,12 +178,10 @@
           hostname = "nyx";
           _networking = {
             enableIPv6 = false;
-          interfaces.eth1.ipv4.addresses = [
-            {
+            interfaces.eth1.ipv4.addresses = [{
               address = "71.0.0.2";
               prefixLength = 24;
-            }
-          ];
+            }];
             firewall.enable = true;
             useDHCP = false;
             interfaces.eth0.useDHCP = true;
@@ -211,9 +196,7 @@
       };
       nixosConfigurations.nixos = nixpkgs.lib.nixosSystem {
         system = "x86_64-linux";
-      modules =
-        base_modules
-        ++ [
+        modules = base_modules ++ [
           ./configuration.nix
           {
             system.stateVersion = "22.05";
@@ -225,9 +208,7 @@
       };
       nixosConfigurations.htran-dev = nixpkgs.lib.nixosSystem {
         system = "x86_64-linux";
-      modules =
-        base_modules
-        ++ [
+        modules = base_modules ++ [
           ./configuration.nix
           {
             system.stateVersion = "22.11";
@@ -237,10 +218,7 @@
               # interface = "ens32";
             };
             networking.interfaces.ens32.ipv4.addresses = [
-              {
-                address = "10.100.200.230";
-                prefixLength = 24;
-              }
+              { address = "10.100.200.230"; prefixLength = 24; }
             ];
           }
         ];
@@ -262,9 +240,7 @@
       nixosConfigurations.bao = nixpkgs.lib.nixosSystem {
         system = "x86_64-linux";
         specialArgs.hostname = "bao";
-      modules =
-        base_modules
-        ++ [
+        modules = base_modules ++ [
           ./configuration.nix
           ./../../modules/storage.perso.sys.nix
           ./../../modules/kde.sys.nix
@@ -272,12 +248,8 @@
           ./../../modules/pulseaudio.sys.nix
           ./../../modules/opengl.sys.nix
           ./../../modules/nvgpu.sys.nix
-          ({
-            config,
-            pkgs,
-            lib,
-            ...
-          }: {
+          ({ config, pkgs, lib, ... }:
+            {
               mod.tailscale.enable = true;
               # Use UEFI
               boot.loader.systemd-boot.enable = true;

nix-conf/system/hardware-configuration.nix

@@ -1,14 +1,11 @@
 # Do not modify this file!  It was generated by ‘nixos-generate-config’
 # and may be overwritten by future invocations.  Please make changes
 # to /etc/nixos/configuration.nix instead.
+{ config, lib, pkgs, modulesPath, ... }:
+
 {
-  config,
-  lib,
-  pkgs,
-  modulesPath,
-  ...
-}: {
-  imports = [
+  imports =
+    [
       (modulesPath + "/profiles/qemu-guest.nix")
     ];
 
@@ -26,12 +23,14 @@
   boot.kernelModules = [ ];
   boot.extraModulePackages = [ ];
 
-  fileSystems."/" = {
+  fileSystems."/" =
+    {
       device = "/dev/sda";
       fsType = "ext4";
     };
 
-  swapDevices = [{device = "/dev/sdb";}];
+  swapDevices =
+    [{ device = "/dev/sdb"; }];
 
   # Enables DHCP on each ethernet and wireless interface. In case of scripted networking
   # (the default) this is the recommended approach. When using systemd-networkd it's

nix-conf/system/nixos-wsl/default.nix

@@ -10,5 +10,4 @@
   )
   {
     src = ./.;
-  })
-.defaultNix
+  }).defaultNix

nix-conf/system/nixos-wsl/flake.nix

@@ -11,13 +11,9 @@
     };
   };
 
-  outputs = {
-    self,
-    nixpkgs,
-    flake-utils,
-    ...
-  }:
+  outputs = { self, nixpkgs, flake-utils, ... }:
     {
+
       nixosModules.wsl = {
         imports = [
           ./modules/build-tarball.nix
@@ -35,15 +31,16 @@
           ./configuration.nix
         ];
       };
-    }
-    // flake-utils.lib.eachSystem
+
+    } //
+    flake-utils.lib.eachSystem
       (with flake-utils.lib.system; [ "x86_64-linux" "aarch64-linux" ])
-    (
-      system: let
+      (system:
+        let
           pkgs = import nixpkgs { inherit system; };
-      in {
-        checks.check-format =
-          pkgs.runCommand "check-format"
+        in
+        {
+          checks.check-format = pkgs.runCommand "check-format"
             {
               buildInputs = with pkgs; [ nixpkgs-fmt ];
             } ''

nix-conf/system/nixos-wsl/modules/build-tarball.nix

@@ -1,23 +1,11 @@
-{
-  config,
-  pkgs,
-  lib,
-  ...
-}:
-with builtins;
-with lib; let
-  pkgs2storeContents = l:
-    map
-    (x: {
-      object = x;
-      symlink = "none";
-    })
-    l;
+{ config, pkgs, lib, ... }:
+with builtins; with lib;
+let
+  pkgs2storeContents = l: map (x: { object = x; symlink = "none"; }) l;
 
   nixpkgs = lib.cleanSource pkgs.path;
 
-  channelSources =
-    pkgs.runCommand "nixos-${config.system.nixos.version}"
+  channelSources = pkgs.runCommand "nixos-${config.system.nixos.version}"
     { preferLocalBuild = true; }
     ''
       mkdir -p $out
@@ -70,7 +58,10 @@ with lib; let
       sed -i 's|import \./default\.nix|import \./nixos-wsl|' ./etc/nixos/configuration.nix
     ''}
   '';
-in {
+
+in
+{
+
   options.wsl.tarball = {
     includeConfig = mkOption {
       type = types.bool;
@@ -79,6 +70,7 @@ in {
     };
   };
 
+
   config = mkIf config.wsl.enable {
     # These options make no sense without the wsl-distro module anyway
 
@@ -100,5 +92,6 @@ in {
       compressCommand = "gzip";
       compressionExtension = ".gz";
     };
+
   };
 }

nix-conf/system/nixos-wsl/modules/docker-desktop.nix

@@ -1,11 +1,6 @@
-{
-  config,
-  lib,
-  pkgs,
-  ...
-}:
-with builtins;
-with lib; {
+{ config, lib, pkgs, ... }:
+with builtins; with lib; {
+
   imports = [
     (mkRenamedOptionModule [ "wsl" "docker" ] [ "wsl" "docker-desktop" ])
   ];
@@ -14,10 +9,12 @@ with lib; {
     enable = mkEnableOption "Docker Desktop integration";
   };
 
-  config = let
+  config =
+    let
       cfg = config.wsl.docker-desktop;
     in
     mkIf (config.wsl.enable && cfg.enable) {
+
       environment.systemPackages = with pkgs; [
         docker
         docker-compose
@@ -38,5 +35,7 @@ with lib; {
       users.groups.docker.members = [
         config.wsl.defaultUser
       ];
+
     };
+
 }

nix-conf/system/nixos-wsl/modules/docker-native.nix

@@ -1,11 +1,6 @@
-{
-  config,
-  lib,
-  pkgs,
-  ...
-}:
-with builtins;
-with lib; {
+{ config, lib, pkgs, ... }:
+with builtins; with lib; {
+
   options.wsl.docker-native = with types; {
     enable = mkEnableOption "Native Docker integration in NixOS.";
 
@@ -20,7 +15,8 @@ with lib; {
     };
   };
 
-  config = let
+  config =
+    let
       cfg = config.wsl.docker-native;
     in
     mkIf (config.wsl.enable && cfg.enable) {

nix-conf/system/nixos-wsl/modules/installer.nix

@@ -1,19 +1,11 @@
-{
-  config,
-  lib,
-  pkgs,
-  ...
-}:
-with builtins;
-with lib; {
+{ config, lib, pkgs, ... }:
+with builtins; with lib; {
+
   config = mkIf config.wsl.enable (
     let
       mkTarball = pkgs.callPackage "${lib.cleanSource pkgs.path}/nixos/lib/make-system-tarball.nix";
 
-      pkgs2storeContents = map (x: {
-        object = x;
-        symlink = "none";
-      });
+      pkgs2storeContents = map (x: { object = x; symlink = "none"; });
 
       rootfs = let tarball = config.system.build.tarball; in "${tarball}/tarball/${tarball.fileName}.tar${tarball.extension}";
 
@@ -47,39 +39,25 @@ with lib; {
       passwd = pkgs.writeText "passwd" ''
         root:x:0:0:System administrator:/root:${installer}
       '';
-    in {
+    in
+    {
+
       system.build.installer = mkTarball {
         fileName = "nixos-wsl-installer";
         compressCommand = "gzip";
         compressionExtension = ".gz";
         extraArgs = "--hard-dereference";
 
-        storeContents = with pkgs;
-          pkgs2storeContents [
+        storeContents = with pkgs; pkgs2storeContents [
           installer
         ];
 
         contents = [
-          {
-            source = config.environment.etc."wsl.conf".source;
-            target = "/etc/wsl.conf";
-          }
-          {
-            source = config.environment.etc."fstab".source;
-            target = "/etc/fstab";
-          }
-          {
-            source = passwd;
-            target = "/etc/passwd";
-          }
-          {
-            source = "${pkgs.busybox}/bin/busybox";
-            target = "/bin/sh";
-          }
-          {
-            source = "${pkgs.busybox}/bin/busybox";
-            target = "/bin/mount";
-          }
+          { source = config.environment.etc."wsl.conf".source; target = "/etc/wsl.conf"; }
+          { source = config.environment.etc."fstab".source; target = "/etc/fstab"; }
+          { source = passwd; target = "/etc/passwd"; }
+          { source = "${pkgs.busybox}/bin/busybox"; target = "/bin/sh"; }
+          { source = "${pkgs.busybox}/bin/busybox"; target = "/bin/mount"; }
         ];
 
         extraCommands = pkgs.writeShellScript "prepare" ''
@@ -88,6 +66,8 @@ with lib; {
           ln -s /init bin/wslpath
         '';
       };
+
     }
   );
+
 }

nix-conf/system/nixos-wsl/modules/interop.nix

@@ -1,11 +1,7 @@
+{ lib, pkgs, config, ... }:
+
+with builtins; with lib;
 {
-  lib,
-  pkgs,
-  config,
-  ...
-}:
-with builtins;
-with lib; {
   imports = [
     (mkRenamedOptionModule [ "wsl" "compatibility" "interopPreserveArgvZero" ] [ "wsl" "interop" "preserveArgvZero" ])
   ];
@@ -36,12 +32,15 @@ with lib; {
     };
   };
 
-  config = let
+  config =
+    let
       cfg = config.wsl.interop;
     in
     mkIf config.wsl.enable {
+
       boot.binfmt.registrations = mkIf cfg.register {
-        WSLInterop = let
+        WSLInterop =
+          let
             compat = cfg.preserveArgvZero;
 
             # WSL Preview 0.58 and up registers the /init binfmt interp for Windows executable
@@ -62,17 +61,12 @@ with lib; {
             '';
 
             # use the autodetect hack if unset, otherwise call /init directly
-          interpreter =
-            if compat == null
-            then compatWrapper
-            else "/init";
+            interpreter = if compat == null then compatWrapper else "/init";
 
             # enable for the wrapper and autodetect hack
-          preserveArgvZero =
-            if compat == false
-            then false
-            else true;
-        in {
+            preserveArgvZero = if compat == false then false else true;
+          in
+          {
             magicOrExtension = "MZ";
             fixBinary = true;
             wrapInterpreterInShell = false;
@@ -83,9 +77,12 @@ with lib; {
       # Include Windows %PATH% in Linux $PATH.
       environment.extraInit = mkIf cfg.includePath ''PATH="$PATH:$WSLPATH"'';
 
-      warnings = let
+      warnings =
+        let
           registrations = config.boot.binfmt.registrations;
         in
         optional (!(registrations ? WSLInterop) && (length (attrNames config.boot.binfmt.registrations)) != 0) "Having any binfmt registrations without re-registering WSLInterop (wsl.interop.register) will break running .exe files from WSL2";
     };
+
+
 }

nix-conf/system/nixos-wsl/modules/wsl-distro.nix

@@ -1,14 +1,12 @@
+{ lib, pkgs, config, ... }:
+
+with builtins; with lib;
+{
+  options.wsl = with types;
+    let
+      coercedToStr = coercedTo (oneOf [ bool path int ]) (toString) str;
+    in
     {
-  lib,
-  pkgs,
-  config,
-  ...
-}:
-with builtins;
-with lib; {
-  options.wsl = with types; let
-    coercedToStr = coercedTo (oneOf [bool path int]) toString str;
-  in {
       enable = mkEnableOption "support for running NixOS as a WSL distribution";
       automountPath = mkOption {
         type = str;
@@ -32,15 +30,13 @@ with lib; {
       };
     };
 
-  config = let
+  config =
+    let
       cfg = config.wsl;
-    syschdemd = import ../syschdemd.nix {
-      inherit lib pkgs config;
-      inherit (cfg) automountPath defaultUser;
-      defaultUserHome = config.users.users.${cfg.defaultUser}.home;
-    };
+      syschdemd = import ../syschdemd.nix { inherit lib pkgs config; inherit (cfg) automountPath defaultUser; defaultUserHome = config.users.users.${cfg.defaultUser}.home; };
     in
     mkIf cfg.enable {
+
       wsl.wslConf = {
         automount = {
           enabled = true;
@@ -61,6 +57,7 @@ with lib; {
       hardware.opengl.enable = true; # Enable GPU acceleration
 
       environment = {
+
         etc = {
           "wsl.conf".text = generators.toINI { } cfg.wslConf;
 
@@ -137,6 +134,6 @@ with lib; {
         enableEmergencyMode = false;
       };
 
-      warnings = optional (config.systemd.services.systemd-resolved.enable && config.wsl.wslConf.network.generateResolvConf) "systemd-resolved is enabled, but resolv.conf is managed by WSL";
+      warnings = (optional (config.systemd.services.systemd-resolved.enable && config.wsl.wslConf.network.generateResolvConf) "systemd-resolved is enabled, but resolv.conf is managed by WSL");
     };
 }

nix-conf/system/nixos-wsl/syschdemd.nix

@@ -1,12 +1,12 @@
-{
-  lib,
-  pkgs,
-  config,
-  automountPath,
-  defaultUser,
-  defaultUserHome ? "/home/${defaultUser}",
-  ...
+{ lib
+, pkgs
+, config
+, automountPath
+, defaultUser
+, defaultUserHome ? "/home/${defaultUser}"
+, ...
 }:
+
 pkgs.substituteAll {
   name = "syschdemd";
   src = ./syschdemd.sh;

nix-conf/system/profiles/Felia/hardware-configuration.nix

@@ -1,13 +1,9 @@
 # Do not modify this file!  It was generated by ‘nixos-generate-config’
 # and may be overwritten by future invocations.  Please make changes
 # to /etc/nixos/configuration.nix instead.
+{ config, lib, pkgs, modulesPath, ... }:
+
 {
-  config,
-  lib,
-  pkgs,
-  modulesPath,
-  ...
-}: {
   imports = [ ];
 
   boot.initrd.availableKernelModules = [ ];
@@ -47,17 +43,20 @@
   #     fsType = "drvfs";
   #   };
 
-  fileSystems."/mnt/c" = {
+  fileSystems."/mnt/c" =
+    {
       device = "C:";
       fsType = "drvfs";
     };
 
-  fileSystems."/mnt/d" = {
+  fileSystems."/mnt/d" =
+    {
       device = "D:";
       fsType = "drvfs";
     };
 
-  fileSystems."/mnt/f" = {
+  fileSystems."/mnt/f" =
+    {
       device = "F:";
       fsType = "drvfs";
     };

nix-conf/system/profiles/bao/hardware-configuration.nix

@@ -1,14 +1,11 @@
 # Do not modify this file!  It was generated by ‘nixos-generate-config’
 # and may be overwritten by future invocations.  Please make changes
 # to /etc/nixos/configuration.nix instead.
+{ config, lib, pkgs, modulesPath, ... }:
+
 {
-  config,
-  lib,
-  pkgs,
-  modulesPath,
-  ...
-}: {
-  imports = [
+  imports =
+    [
       (modulesPath + "/installer/scan/not-detected.nix")
     ];
 

nix-conf/system/profiles/homeless/hardware-configuration.nix

@@ -1,14 +1,11 @@
 # Do not modify this file!  It was generated by ‘nixos-generate-config’
 # and may be overwritten by future invocations.  Please make changes
 # to /etc/nixos/configuration.nix instead.
+{ config, lib, pkgs, modulesPath, ... }:
+
 {
-  config,
-  lib,
-  pkgs,
-  modulesPath,
-  ...
-}: {
-  imports = [
+  imports =
+    [
       (modulesPath + "/profiles/qemu-guest.nix")
     ];
 
@@ -26,12 +23,14 @@
   boot.kernelModules = [ ];
   boot.extraModulePackages = [ ];
 
-  fileSystems."/" = {
+  fileSystems."/" =
+    {
       device = "/dev/sda";
       fsType = "ext4";
     };
 
-  swapDevices = [{device = "/dev/sdb";}];
+  swapDevices =
+    [{ device = "/dev/sdb"; }];
 
   # Enables DHCP on each ethernet and wireless interface. In case of scripted networking
   # (the default) this is the recommended approach. When using systemd-networkd it's

nix-conf/system/profiles/lester/hardware-configuration.nix

@@ -1,14 +1,11 @@
 # Do not modify this file!  It was generated by ‘nixos-generate-config’
 # and may be overwritten by future invocations.  Please make changes
 # to /etc/nixos/configuration.nix instead.
+{ config, lib, pkgs, modulesPath, ... }:
+
 {
-  config,
-  lib,
-  pkgs,
-  modulesPath,
-  ...
-}: {
-  imports = [
+  imports =
+    [
       (modulesPath + "/profiles/qemu-guest.nix")
     ];
 
@@ -26,12 +23,14 @@
   boot.kernelModules = [ ];
   boot.extraModulePackages = [ ];
 
-  fileSystems."/" = {
+  fileSystems."/" =
+    {
       device = "/dev/sda";
       fsType = "ext4";
     };
 
-  swapDevices = [{device = "/dev/sdb";}];
+  swapDevices =
+    [{ device = "/dev/sdb"; }];
 
   # Enables DHCP on each ethernet and wireless interface. In case of scripted networking
   # (the default) this is the recommended approach. When using systemd-networkd it's

nix-conf/system/profiles/lizzi/hardware-configuration.nix

@@ -1,14 +1,11 @@
 # Do not modify this file!  It was generated by ‘nixos-generate-config’
 # and may be overwritten by future invocations.  Please make changes
 # to /etc/nixos/configuration.nix instead.
+{ config, lib, pkgs, modulesPath, ... }:
+
 {
-  config,
-  lib,
-  pkgs,
-  modulesPath,
-  ...
-}: {
-  imports = [
+  imports =
+    [
       (modulesPath + "/profiles/qemu-guest.nix")
     ];
 
@@ -38,7 +35,8 @@
     };
   };
 
-  swapDevices = [{device = "/dev/sdb";}];
+  swapDevices =
+    [{ device = "/dev/sdb"; }];
 
   # Enables DHCP on each ethernet and wireless interface. In case of scripted networking
   # (the default) this is the recommended approach. When using systemd-networkd it's

nix-conf/system/profiles/nyx/hardware-configuration.nix

@@ -1,14 +1,11 @@
 # Do not modify this file!  It was generated by ‘nixos-generate-config’
 # and may be overwritten by future invocations.  Please make changes
 # to /etc/nixos/configuration.nix instead.
+{ config, lib, pkgs, modulesPath, ... }:
+
 {
-  config,
-  lib,
-  pkgs,
-  modulesPath,
-  ...
-}: {
-  imports = [
+  imports =
+    [
       (modulesPath + "/profiles/qemu-guest.nix")
     ];
 
@@ -26,12 +23,14 @@
   boot.loader.grub.forceInstall = true;
   boot.loader.grub.device = "nodev";
   boot.loader.timeout = 10;
-  fileSystems."/" = {
+  fileSystems."/" =
+    {
       device = "/dev/sda";
       fsType = "ext4";
     };
 
-  swapDevices = [{device = "/dev/sdb";}];
+  swapDevices =
+    [{ device = "/dev/sdb"; }];
 
   # Enables DHCP on each ethernet and wireless interface. In case of scripted networking
   # (the default) this is the recommended approach. When using systemd-networkd it's

nix-conf/system/wsl-configuration.nix

@@ -1,7 +1,10 @@
 { lib, ... }:
-with lib; let
+
+with lib;
+let
   nixos-wsl = import ./nixos-wsl;
-in {
+in
+{
   imports = [
     ./configuration.nix
     nixos-wsl.nixosModules.wsl
@@ -18,7 +21,9 @@ in {
 
     # Enable integration with Docker Desktop (needs to be installed)
     docker-desktop.enable = true;
+
   };
   # users.users.<defaultUser>.uid = 1000;
   # networking.hostName = "nixos";
+
 }

nix/cells/dotfiles/devshells.nix

@@ -1,11 +0,0 @@
-{
-  inputs,
-  cell,
-}: let
-  inherit (inputs) std nixpkgs;
-in {
-  default = std.lib.dev.mkShell {
-    name = "default";
-    imports = [inputs.std.std.devshellProfiles.default];
-  };
-}

nix/cells/dotfiles/packages/default.nix

@@ -1,24 +0,0 @@
-{
-  inputs,
-  cell,
-}: let
-  inherit (inputs.nixpkgs) system;
-  inherit (inputs.nix-boost.pkgs."${system}".mypkgs) poetry2nix;
-  inherit (poetry2nix) mkPoetryApplication defaultPoetryOverrides;
-in {
-  kpcli-py = mkPoetryApplication {
-    projectDir = inputs.kpcli-py;
-    overrides = defaultPoetryOverrides.extend (self: super: {
-      # TODO: add this to upstream poetry2nix
-      tableformatter = super.tableformatter.overridePythonAttrs (old: {
-        buildInputs = (old.buildInputs or []) ++ [self.setuptools self.cython_3];
-        src = old.src;
-      });
-
-      kpcli = super.kpcli.overridePythonAttrs (old: {
-        buildInputs = (old.buildInputs or []) ++ [self.setuptools];
-      });
-    });
-  };
-
-}

nix/cells/repo/home-configs/default.nix

@@ -1,47 +0,0 @@
-# TODO: this should use winnow with a fair matching of supported systems
-{
-  inputs,
-  cell,
-}: let
-  inherit (cell) home-profiles home-modules;
-  inherit (inputs) home-manager;
-  pkgs = inputs.nixpkgs;
-
-  # hm is derivation that is compatible with homeConfigurations
-  home-config = {supported_systems, hm, tested_systems ? []}: 
-  hm // { 
-    _supported_systems = supported_systems; 
-    _tested_systems = tested_systems;
-  };
-
-  base-modules = [
-    home-profiles.alacritty
-    # home-profiles.git
-    home-profiles.ssh
-    home-profiles.shells
-    ({config.programs.home-manager.enable = true;})
-    home-profiles.nix-index
-    home-profiles.neovim
-  ];
-in {
-  homeConfigurations.htran = home-config {
-    supported_systems = ["aarch64-darwin" "x86_64-darwin"];
-    tested_systems = ["aarch64-darwin"];
-    hm = home-manager.lib.homeManagerConfiguration {
-      inherit pkgs;
-      modules = base-modules ++ [
-        home-profiles.nerd_font_module
-        home-profiles.git-htran
-        home-profiles.dev-packages
-        home-profiles.zk
-        home-modules.darwin-spotlight
-
-        ({
-          home.username = "htran";
-          home.homeDirectory = "/Users/htran";
-          home.stateVersion = "23.11";
-        })
-      ];
-    };
-  };
-}

nix/cells/repo/home-modules/default.nix

@@ -1,250 +0,0 @@
-# This is an interface for home-profiles and should not contain opinionated
-# configurations. It should provide alternative configurations, aggregates
-# or new configurations
-_imports@{ inputs, cell }:
-let
-  namespace = "repo";
-  imports = _imports // { inherit namespace; };
-in
-{
-  git = { config, lib, ... }:
-    let
-      cfg = config."${namespace}".git;
-      baseAliases = {
-        a = "add";
-        c = "commit";
-        ca = "commit --amend";
-        cm = "commit -m";
-        lol = "log --graph --decorate --pretty=oneline --abbrev-commit";
-        lola = "log --graph --decorate --pretty=oneline --abbrev-commit --all";
-        sts = "status";
-        co = "checkout";
-        b = "branch";
-      };
-      default-user = "Pegasust";
-      default-email = "pegasucksgg@gmail.com";
-    in
-    {
-      options."${namespace}".git = {
-        aliases = lib.mkOption {
-          type = lib.types.attrs;
-          default = { };
-          example = baseAliases;
-          description = ''
-            Additional git aliases. This settings comes with base configuration.
-            Redeclaring the base config will override the values.
-          ''; # TODO: Add baseAliases as string here (builtins.toString doesn't work)
-        };
-        name = lib.mkOption {
-          type = lib.types.str;
-          default = default-user;
-          description = "Git username that appears on commits";
-          example = default-user;
-        };
-        email = lib.mkOption {
-          type = lib.types.str;
-          default = default-email;
-          example = default-email;
-          description = "Git email that appears on commits";
-        };
-        ignores = lib.mkOption {
-          type = lib.types.listOf lib.types.str;
-          default = [
-            ".vscode" # vscode settings
-            ".direnv" # .envrc cached outputs
-            ".DS_Store" # MacOS users, amrite
-          ];
-          description = ''
-            .gitignore patterns that are applied in every "${namespace}"sitory.
-            This is useful for IDE-specific settings.
-          '';
-          example = [ ".direnv" "node_modules" ];
-        };
-        enable = lib.mkOption {
-          type = lib.types.bool;
-          default = true;
-          description = ''
-            Enables git
-          '';
-          example = false;
-        };
-        credentialCacheTimeoutSeconds = lib.mkOption {
-          type = lib.types.int;
-          default = 3000;
-          description = "Credential cache (in-memory store) for Git in seconds.";
-          example = 3000;
-        };
-      };
-      # TODO : anyway to override configuration?
-      # idk wtf I was thinking about. there is no context in this question
-      config.programs.git = {
-        inherit (cfg) enable ignores;
-        userName = cfg.name;
-        userEmail = cfg.email;
-        aliases = baseAliases // cfg.aliases;
-        extraConfig = {
-          # TODO: in the case of darwin, git always open up the built-in keychain.
-          # possibly something we can't really control since we don't have access to `nix-darwin`
-          credential.helper = "cache --timeout=${builtins.toString cfg.credentialCacheTimeoutSeconds}";
-        };
-        lfs.enable = true;
-      };
-    };
-
-  alacritty = { config, lib, ... }:
-    let
-      inherit (inputs.cells.repo.lib) fromYAML;
-      cfg = config."${namespace}".alacritty;
-    in
-    {
-      options."${namespace}".alacritty = {
-        font.family = lib.mkOption {
-          type = lib.types.nullOr lib.types.singleLineStr;
-          default = null;
-          description = ''
-            The font family for Alacritty
-          '';
-          example = "DroidSansMono NF";
-        };
-        font.size = lib.mkOption {
-          type = lib.types.nullOr lib.types.number;
-          default = 11.0;
-          description = ''
-            The default font size for Alacritty. This is probably measured in px.
-          '';
-          example = 7.0;
-        };
-        enable = lib.mkOption {
-          type = lib.types.bool;
-          default = false;
-          description = ''
-            Enables alacritty
-          '';
-          example = true;
-        };
-        config-path = lib.mkOption {
-          type = lib.types.path;
-          description = "Path to alacritty yaml";
-          default = null;
-          example = "./config/alacritty.yaml";
-        };
-      };
-      config.programs.alacritty = {
-        enable = cfg.enable;
-        settings =
-          let
-            actualConfig =
-              if cfg.config-path != null then fromYAML (builtins.readFile cfg.config-path) else { };
-          in
-          lib.recursiveUpdate actualConfig {
-            font.normal.family = lib.mkIf (cfg.font.family != null) cfg.font.family;
-            font.size = lib.mkIf (cfg.font.size != null) cfg.font.size;
-          };
-      };
-    };
-
-  # TODO: chromium is not really supported on darwin
-  private_chromium = { config, pkgs, lib, ... }:
-    let
-      cfg = config."${namespace}".private_chromium;
-    in
-    {
-      options."${namespace}".private_chromium = {
-        enable = lib.mkOption {
-          type = lib.types.bool;
-          default = true;
-          example = false;
-          description = ''
-            Enable extremely lightweight chromium with vimium plugin
-          '';
-        };
-      };
-      config = lib.mkIf (cfg.enable) {
-        # home.packages = [pkgs.ungoogled-chromium];
-        programs.chromium = {
-          enable = true;
-          package = pkgs.ungoogled-chromium;
-          extensions =
-            let
-              # TODO: how about a chrome extension registry?
-              mkChromiumExtForVersion = browserVersion: { id, sha256, extVersion, ... }:
-                {
-                  inherit id;
-                  crxPath = builtins.fetchurl {
-                    url = "https://clients2.google.com/service/update2/crx" +
-                      "?response=redirect" +
-                      "&acceptformat=crx2,crx3" +
-                      "&prodversion=${browserVersion}" +
-                      "&x=id%3D${id}%26installsource%3Dondemand%26uc";
-                    name = "${id}.crx";
-                    inherit sha256;
-                  };
-                  version = extVersion;
-                };
-              mkChromiumExt = mkChromiumExtForVersion (lib.versions.major pkgs.ungoogled-chromium.version);
-            in
-            [
-              # vimium
-              (mkChromiumExt {
-                id = "dbepggeogbaibhgnhhndojpepiihcmeb";
-                sha256 = "00qhbs41gx71q026xaflgwzzridfw1sx3i9yah45cyawv8q7ziic";
-                extVersion = "1.67.4";
-              })
-            ];
-        };
-      };
-    };
-
-  darwin-spotlight = { lib, pkgs, config, ... }: {
-    # This patch exists since Darwin's search bar requires solid apps and not
-    # symlinked
-    # TODO: QA
-    # - [x] works for base case
-    # - [x] works for repeated case
-    # - [ ] works after base case, then removed 
-    # - [ ] works for repeated case, then removed
-
-    # Copy GUI apps to "~/Applications/Home Manager Apps"
-    # Based on this comment: https://github.com/nix-community/home-manager/issues/1341#issuecomment-778820334
-    home.activation.patch-spotlight =
-      if pkgs.stdenv.isDarwin then
-        let
-          apps = pkgs.buildEnv {
-            name = "home-manager-applications";
-            paths = config.home.packages;
-            pathsToLink = "/Applications";
-          };
-        in
-        lib.hm.dag.entryAfter [ "linkGeneration" ] ''
-          # Install MacOS applications to the user environment.
-          HM_APPS="$HOME/Applications/Home Manager Apps"
-          # Reset current state
-          if [ -e "$HM_APPS" ]; then
-            $DRY_RUN_CMD mv "$HM_APPS" "$HM_APPS.$(date +%Y%m%d%H%M%S)"
-          fi
-          $DRY_RUN_CMD mkdir -p "$HM_APPS"
-          # .app dirs need to be actual directories for Finder to detect them as Apps.
-          # In the env of Apps we build, the .apps are symlinks. We pass all of them as
-          # arguments to cp and make it dereference those using -H
-          $DRY_RUN_CMD cp --archive -H --dereference ${apps}/Applications/* "$HM_APPS"
-          $DRY_RUN_CMD chmod +w -R "$HM_APPS"
-        ''
-      else
-        "";
-    # We need this in case upstream home-manager changes the behavior of linking
-    # applications
-    home.activation.remove-patch-spotlight =
-      if pkgs.stdenv.isDarwin then
-        lib.hm.dag.entryBefore [ "checkLinkTargets" ] ''
-          HM_APPS="$HOME/Applications/Home Manager Apps"
-          # Reset current state
-          if [ -e "$HM_APPS" ]; then
-            $DRY_RUN_CMD mv "$HM_APPS" "$HM_APPS.$(date +%Y%m%d%H%M%S)"
-          fi
-        ''
-      else
-        "";
-  };
-
-}
-

nix/cells/repo/home-modules/nixgl.nix

@@ -1,47 +0,0 @@
-{
-  inputs,
-  cell,
-  namespace,
-}: {
-  pkgs,
-  config,
-  lib,
-  ...
-}: let
-  cfg = config."${namespace}".graphics;
-  cfgEnable = cfg.enable or (cfg.useNixGL.defaultPackage != null);
-  types = lib.types;
-in {
-  imports = [./shells.nix];
-  options."${namespace}".nixgl = {
-    enable = lib.mkEnableOption "nixgl";
-    useNixGL = {
-      package = lib.mkPackageOption pkgs "nixGL package" {
-        default = [
-          "nixgl"
-          "auto"
-          "nixGLDefault"
-        ];
-      };
-      defaultPackage = lib.mkOption {
-        type = types.nullOr (types.enum ["nixGLIntel" "nixGLNvidia" "nixGLNvidiaBumblebee"]);
-        description = "Which nixGL package to be aliased as `nixGL` on the shell";
-        default = null;
-        example = "nixGLIntel";
-      };
-    };
-  };
-  # NOTE: importing shells does not mean we're enabling everything, if we do mkDefault false
-  # but the dilemma is, if the user import BOTH graphics.nix and shells.nix
-  # they will also need to do `config."${namespace}".shells.enable`
-  # generally, we want the behavior: import means enable
-  config = lib.mkIf cfgEnable {
-    "${namespace}".graphics._enable = lib.mkForce true;
-    "${namespace}".shells = {
-      shellAliases = lib.mkIf (cfg.useNixGL.defaultPackage != null) {
-        nixGL = cfg.useNixGL.defaultPackage;
-      };
-    };
-    home.packages = [cfg.useNixGL.package];
-  };
-}

nix/cells/repo/home-profiles/default.nix

@@ -1,200 +0,0 @@
-# This creates a layer that is specific to some profiles, but may require
-# some variants in environment like username/email, work-oriented or personal
-# and many more
-_imports @ {
-  inputs,
-  cell,
-}: let
-  # TODO: I don't think abstracting namespace away is a good idea in this case
-  namespace = "repo";
-  imports = _imports // {inherit namespace;};
-  inherit (cell) home-modules;
-in {
-  neovim = import ./neovim.nix imports;
-  nerd_font_module = {
-    config,
-    pkgs,
-    ...
-  }: {
-    config.fonts.fontconfig.enable = true;
-    config.home.packages = [
-      (pkgs.nerdfonts.override {fonts = ["Hack"];})
-    ];
-    config."${namespace}".alacritty.font.family = "Hack Nerd Font Mono";
-  };
-
-  secrets = {
-    age.secrets.s3fs = {
-      file = "${inputs.self}/secrets/s3fs.age";
-      # mode = "600";  # owner + group only
-      # owner = "hungtr";
-      # group = "users";
-    };
-    age.secrets."s3fs.digital-garden" = {
-      file = "${inputs.self}/secrets/s3fs.digital-garden.age";
-    };
-    age.secrets._nhitrl_cred = {
-      file = "${inputs.self}/secrets/_nhitrl.age";
-    };
-    age.secrets."wifi.env" = {
-      file = "${inputs.self}/secrets/wifi.env.age";
-    };
-  };
-
-  ssh = {
-    config,
-    lib,
-    ...
-  }: let
-    cfg = config."${namespace}".ssh;
-  in {
-    options."${namespace}".ssh.enable = lib.mkOption {
-      type = lib.types.bool;
-      default = true;
-      example = false;
-      description = ''
-        Enables SSH
-      '';
-    };
-    config.programs.ssh = {
-      inherit (cfg) enable;
-      forwardAgent = true;
-      includes = ["${inputs.self}/native_configs/ssh/config"];
-    };
-  };
-
-  alacritty = {
-    config,
-    lib,
-    ...
-  }: let
-    cfg = config."${namespace}".alacritty;
-  in {
-    imports = [
-      inputs.cells.repo.home-modules.alacritty
-    ];
-    config."${namespace}".alacritty = {
-      enable = true;
-      config-path = "${inputs.self}//native_configs/alacritty/alacritty.yml";
-      font.size = 11.0;
-      font.family = "Hack Nerd Font Mono";
-    };
-  };
-
-  shells = import ./shells.nix imports;
-
-  git = {
-    config,
-    pkgs,
-    lib,
-    ...
-  }: let
-    baseAliases = {
-      a = "add";
-      c = "commit";
-      ca = "commit --amend";
-      cm = "commit -m";
-      lol = "log --graph --decorate --pretty=oneline --abbrev-commit";
-      lola = "log --graph --decorate --pretty=oneline --abbrev-commit --all";
-      sts = "status";
-      co = "checkout";
-      b = "branch";
-    };
-    cfg = config."${namespace}".profile.git;
-  in {
-    imports = [
-      home-modules.git
-    ];
-    options."${namespace}".profile.git = {
-      aliases = lib.mkOption {
-        type = lib.types.attrs;
-        default = {};
-        example = baseAliases;
-        description = ''
-          Additional git aliases. This config is merged on top of base aliases.
-        '';
-      };
-      name = lib.mkOption {
-        type = lib.types.str;
-        default = "Pegasust";
-        description = "Git username that appears on commits";
-        example = "Pegasust";
-      };
-      email = lib.mkOption {
-        type = lib.types.str;
-        default = "pegasucksgg@gmail.com";
-        example = "peagsucksgg@gmail.com";
-        description = "Git email that appears on commits";
-      };
-      ignores = lib.mkOption {
-        type = lib.types.listOf lib.types.str;
-        default = [
-          ".vscode" # vscode settings
-          ".direnv" # .envrc cached outputs
-          ".DS_Store" # MacOS users, amrite
-        ];
-        description = ''
-          .gitignore patterns that are applied in every repository.
-          This is useful for IDE-specific or environment-specific settings.
-        '';
-        example = [".direnv" "node_modules"];
-      };
-    };
-    # WARNING: This should be completed wtf
-    config."${namespace}".git = {
-      inherit (cfg) name email ignores aliases;
-      enable = true;
-    };
-  };
-
-  git-htran = {
-    imports = [inputs.cells.repo.home-profiles.git];
-    config."${namespace}".profile.git = {
-      name = "htran";
-      email = "htran@egihosting.com";
-    };
-  };
-
-  git-pegasust = {
-    imports = [inputs.cells.repo.home-profiles.git];
-    config."${namespace}".profile.git = {
-      email = "pegasucksgg@gmail.com";
-      name = "pegasust";
-    };
-  };
-
-  dev-packages = let pkgs = inputs.nixpkgs; in {
-    programs.jq.enable = true;
-    home.packages = [
-      pkgs.htop
-      pkgs.ripgrep
-      pkgs.unzip
-      pkgs.zip
-
-      pkgs.yq-go
-      pkgs.mosh
-      pkgs.python310
-    ];
-  };
-
-  # Local nixpkgs search and fallback if command not found to search from nixpkgs
-  nix-index = {
-    imports = [
-      inputs.nix-index-database.hmModules.nix-index
-    ];
-    config.programs.nix-index = {
-      enable = true;
-      enableBashIntegration = true;
-      enableZshIntegration = true;
-    };
-  };
-
-  # digital garden stack
-  zk = {
-    config.xdg.configFile."zk/config.toml".source = "${inputs.self}/native_configs/zk/config.toml";
-    # NB: this is done with lib.mkMerge
-    config.home.packages = [
-      inputs.nixpkgs.zk
-    ];
-  };
-}

nix/cells/repo/home-profiles/neovim.nix

@@ -1,178 +0,0 @@
-# TODO: vim-plug and Mason supports laziness. Probably worth it to explore incremental dependencies based on the project TODO: just install these things, then symlink to mason's bin directory
-#
-# One thing to consider, though, /nix/store of `nix-shell` or `nix-develop`
-# might be different from `home-manager`'s (~/.nix_profile/bin/jq)
-{
-  inputs,
-  cell,
-  namespace,
-}: {
-  pkgs,
-  lib,
-  config,
-  ...
-}: let
-  # NOTE: Add packages to nvim_pkgs instead, so that it's available at userspace
-  # and is added to the path after wrapping.
-  # check: nix repl `homeConfigurations.hungtr.config.programs.neovim.finalPackage.buildCommand`
-  # see: :/--suffix.*PATH
-  # there should be mentions of additional packages
-  my_neovim = pkgs.neovim-unwrapped;
-  inherit (inputs.nixpkgs) system;
-  nvim_pkgs =
-    [
-      # pkgs.gccStdenv
-      pkgs.tree-sitter
-      pkgs.fzf # file name fuzzy search
-      pkgs.ripgrep # content fuzzy search
-      pkgs.zk # Zettelkasten (limited support)
-      pkgs.fd # Required by a Telescope plugin (?)
-      pkgs.stdenv.cc.cc.lib
-      pkgs.nil  # oxalica's better nix language server
-      inputs.nix-boost.packages."${system}".rust4cargo
-      pkgs.nickel
-      pkgs.nls
-
-      pkgs.go # doesn't work, Mason installs from runtime path
-
-      # Language-specific stuffs
-      pkgs.sumneko-lua-language-server
-      # pkgs.python3Packages.python-lsp-server
-      pkgs.nodePackages.pyright
-      pkgs.python3Packages.pylint
-      pkgs.python3Packages.flake8
-      # FIXME: installing ansible from here just doesn't work :/
-      # pkgs.ansible-lint
-      # pkgs.python38Packages.ansible
-      # pkgs.ansible-language-server
-      # TODO: the devShell should provide rust-analyzer so that
-      # cargo test builds binaries compatible with rust-analyzer
-
-      # pkgs.rust-analyzer
-      # rust_pkgs
-      # pkgs.evcxr # Rust REPL for Conjure!
-    ]
-    ++ lib.optionals (pkgs.stdenv.isDarwin) (
-      let
-        inherit (pkgs.darwin.apple_sdk.frameworks) System CoreFoundation;
-      in [
-        System
-        CoreFoundation
-      ]
-    );
-in {
-  options.base.neovim = {
-    enable = lib.mkOption {
-      default = true;
-      description = "enable personalized neovim as default editor";
-      type = lib.types.bool;
-      example = false;
-    };
-  };
-  config = lib.mkIf config.base.neovim.enable {
-    # home-manager
-    programs.neovim = {
-      enable = true;
-      package = my_neovim;
-      viAlias = true;
-      vimAlias = true;
-      withPython3 = true;
-      withNodeJs = true;
-      # NOTE: this adds path to the wrapped version of neovim
-      extraPackages = nvim_pkgs;
-      extraLuaConfig = builtins.readFile "${inputs.self}/native_configs/neovim/init.lua";
-      plugins = let
-        inherit
-          (inputs.nixpkgs-latest.legacyPackages.${system}.vimPlugins)
-          plenary-nvim
-          nvim-treesitter
-          nvim-treesitter-textobjects
-          nvim-treesitter-context
-          telescope-fzf-native-nvim
-          telescope-file-browser-nvim
-          telescope-nvim
-          nvim-lspconfig
-          gruvbox-community
-          neodev-nvim
-          cmp-nvim-lsp
-          cmp-path
-          cmp-buffer
-          cmp-cmdline
-          nvim-cmp
-          lspkind-nvim
-          nvim-autopairs
-          nvim-ts-autotag
-          guess-indent-nvim
-          harpoon
-          zk-nvim
-          luasnip
-          fidget-nvim
-          rust-tools-nvim
-          cmp_luasnip
-          gitsigns-nvim
-          indent-blankline-nvim
-          lualine-nvim
-          mason-lspconfig-nvim
-          mason-nvim
-          neogit
-          nlua-nvim
-          nvim-jqx
-          nvim-surround
-          nvim-web-devicons
-          playground
-          todo-comments-nvim
-          trouble-nvim
-          vim-dispatch
-          vim-dispatch-neovim
-          vim-fugitive
-          vim-jack-in
-          ;
-      in [
-        plenary-nvim
-        nvim-treesitter.withAllGrammars
-        nvim-treesitter-textobjects
-        telescope-fzf-native-nvim
-        telescope-file-browser-nvim
-        telescope-nvim
-        nvim-lspconfig
-        gruvbox-community
-        neodev-nvim
-        cmp-nvim-lsp
-        cmp-path
-        cmp-buffer
-        cmp-cmdline
-        nvim-cmp
-        lspkind-nvim
-        nvim-autopairs
-        nvim-ts-autotag
-        guess-indent-nvim
-        harpoon
-        zk-nvim
-        luasnip
-        nvim-treesitter-context
-        fidget-nvim
-        rust-tools-nvim
-
-        cmp_luasnip
-        gitsigns-nvim
-        indent-blankline-nvim
-        lualine-nvim
-        mason-lspconfig-nvim
-        mason-nvim
-        neogit
-        nlua-nvim
-        nvim-jqx
-        nvim-surround
-        nvim-web-devicons
-        playground
-        todo-comments-nvim
-        trouble-nvim
-        vim-dispatch
-        vim-dispatch-neovim
-        vim-fugitive
-        vim-jack-in
-      ];
-    };
-    # home.packages = nvim_pkgs;
-  };
-}

nix/cells/repo/home-profiles/shells.nix

@@ -1,133 +0,0 @@
-{
-  inputs,
-  cell,
-  namespace,
-}: {
-  config,
-  lib,
-  pkgs,
-  ...
-}: let
-  cfg = config."${namespace}".shells;
-in {
-  options."${namespace}".shells = {
-    enable = lib.mkOption {
-      type = lib.types.bool;
-      description = "Enable umbrella shell configuration";
-      default = true;
-      example = false;
-    };
-    shellInitExtra = lib.mkOption {
-      type = lib.types.str;
-      description = "Extra shell init. The syntax should be sh-compliant";
-      default = "";
-      example = ''
-        # X11 support for WSL
-        export DISPLAY=$(ip route list default | awk '{print $3}'):0
-        export LIBGL_ALWAYS_INDIRECT=1
-      '';
-    };
-    shellAliases = lib.mkOption {
-      type = lib.types.attrs;
-      description = "Shell command aliases";
-      default = {};
-      example = {
-        nixGL = "nixGLIntel";
-      };
-    };
-  };
-  config = lib.mkIf cfg.enable {
-    # nix: Propagates the environment with packages and vars when enter (children of)
-    # a directory with shell.nix-compatible and .envrc
-    programs.direnv = {
-      enable = true;
-      nix-direnv.enable = true;
-      # nix-direnv.enableFlakes = true; # must remove. this will always be supported.
-    };
-    # z <path> as smarter cd
-    programs.zoxide = {
-      enable = true;
-      enableZshIntegration = true;
-    };
-    programs.tmux = {
-      enable = true;
-      plugins = let inherit (pkgs.tmuxPlugins) cpu net-speed; in [cpu net-speed];
-      extraConfig = builtins.readFile "${inputs.self}/native_configs/tmux/tmux.conf";
-    };
-    xdg.configFile."tmux/tmux.conf".text = lib.mkOrder 600 ''
-      set -g status-right '#{cpu_bg_color} CPU: #{cpu_icon} #{cpu_percentage} | %a %h-%d %H:%M '
-    '';
-    # Colored ls
-    programs.exa = {
-      enable = true;
-      enableAliases = true;
-    };
-    # Make the shell look beautiful
-    programs.starship = {
-      enable = true;
-      enableZshIntegration = true;
-      settings = let
-        native = builtins.fromTOML (builtins.readFile "${inputs.self}/native_configs/starship/starship.toml");
-        patch-nix = pkgs.lib.recursiveUpdate native {
-          # WARNING: home-manager fails on here for some reason. Likely not at the 
-          # validation phase (type-checking), but at evaluation phaase (stringify)
-          # I'm thinking when `settings` are evaluated, it has some sort of
-          # recursive processing before it gets turned into a toml
-          # c.commands = [
-          #   ["nix" "run" "nixpkgs#clang" "--" "--version"]
-          #   ["nix" "run" "nixpkgs#gcc" "--" "--version"]
-          # ];
-          c.disabled = true;
-        };
-      in
-        patch-nix;
-    };
-    # Fuzzy finder. `fzf` for TUI, `fzf -f '<fuzzy query>'` for UNIX piping
-    programs.fzf.enable = true;
-    programs.bash = {
-      enable = true;
-      enableCompletion = true;
-      initExtra = cfg.shellInitExtra or "";
-    };
-    programs.zsh = {
-      enable = true;
-      enableCompletion = true;
-      enableAutosuggestions = true;
-      shellAliases =
-        {
-          nix-rebuild = "sudo nixos-rebuild switch";
-          hm-switch = "home-manager switch --flake";
-        }
-        // (cfg.shellAliases or {});
-      history = {
-        size = 10000;
-        path = "${config.xdg.dataHome}/zsh/history";
-      };
-      oh-my-zsh = {
-        enable = true;
-        plugins = [
-          "git" # git command aliases: https://github.com/ohmyzsh/ohmyzsh/tree/master/plugins/git#aliases
-          "command-not-found" # suggests which package to install; does not support nixos (we have solution already)
-          "gitignore" # `gi list` -> `gi java >>.gitignore`
-          "ripgrep" # adds completion for `rg`
-          "rust" # compe for rustc/cargo
-          "poetry" # compe for poetry - Python's cargo
-        ];
-      };
-      sessionVariables = {
-        # Vim mode on the terminal
-        # VI_MODE_RESET_PROMPT_ON_MODE_CHANGE = true;
-        # VI_MODE_SET_CURSOR = true;
-        # ZVM_VI_ESCAPE_BINDKEY = "";
-        ZVM_READKEY_ENGINE = "$ZVM_READKEY_ENGINE_NEX";
-        ZVM_KEYTIMEOUT = 0.004; # 40ms, or subtly around 25 FPS. I'm a gamer :)
-        ZVM_ESCAPE_KEYTIMEOUT = 0.004; # 40ms, or subtly around 25 FPS. I'm a gamer :)
-      };
-      initExtra =
-        (cfg.shellInitExtra or "")
-        + ''
-          source ${pkgs.zsh-vi-mode}/share/zsh-vi-mode/zsh-vi-mode.plugin.zsh
-        '';
-    };
-  };
-}

nix/cells/repo/lib/default.nix

@@ -1,16 +0,0 @@
-{ inputs, cell }:
-let
-  namespace = "repo"; # ignore: unused
-
-  yamlToJsonDrv = pkgs: yamlContent: outputPath: (pkgs.runCommand
-    outputPath
-    { inherit yamlContent; nativeBuildInputs = [ pkgs.yq ]; }
-    # run yq which outputs '.' (no filter) on file at yamlPath
-    # note that $out is passed onto the bash/sh script for execution
-    ''
-      echo "$yamlContent" | yq >$out
-    '');
-in
-{
-  fromYAML = yamlContent: builtins.fromJSON (builtins.readFile (yamlToJsonDrv inputs.nixpkgs yamlContent "fromYaml.json"));
-}

nix/cells/repo/packages/default.nix

@@ -1,6 +0,0 @@
-{
-  inputs,
-  cell,
-}: {
-  inherit (inputs.cells.dotfiles.packages) kpcli-py;
-}

nix/cells/repo/userShells.nix

@@ -1,7 +0,0 @@
-{
-  inputs,
-  cell,
-}: {
-  htran = inputs.cells.dotfiles.devshells.default;
-  hungtran = inputs.cells.dotfiles.devshells.default;
-}

out-of-tree/flake-compat/default.nix

@@ -4,26 +4,22 @@
 # calls the flake's 'outputs' function. It then returns an attrset
 # containing 'defaultNix' (to be used in 'default.nix'), 'shellNix'
 # (to be used in 'shell.nix').
-{
-  src,
-  system ? builtins.currentSystem or "unknown-system",
-}: let
+
+{ src, system ? builtins.currentSystem or "unknown-system" }:
+
+let
+
   lockFilePath = src + "/flake.lock";
 
   lockFile = builtins.fromJSON (builtins.readFile lockFilePath);
 
-  fetchTree = info:
-    if info.type == "github"
-    then {
-      outPath =
+  fetchTree =
+    info:
+    if info.type == "github" then
+      { outPath =
           fetchTarball
-        (
-          {url = "https://api.${info.host or "github.com"}/repos/${info.owner}/${info.repo}/tarball/${info.rev}";}
-          // (
-            if info ? narHash
-            then {sha256 = info.narHash;}
-            else {}
-          )
+            ({ url = "https://api.${info.host or "github.com"}/repos/${info.owner}/${info.repo}/tarball/${info.rev}"; }
+             // (if info ? narHash then { sha256 = info.narHash; } else {})
             );
         rev = info.rev;
         shortRev = builtins.substring 0 7 info.rev;
@@ -31,76 +27,43 @@
         lastModifiedDate = formatSecondsSinceEpoch info.lastModified;
         narHash = info.narHash;
       }
-    else if info.type == "git"
-    then
-      {
-        outPath =
+    else if info.type == "git" then
+      { outPath =
           builtins.fetchGit
-          (
-            {url = info.url;}
-            // (
-              if info ? rev
-              then {inherit (info) rev;}
-              else {}
-            )
-            // (
-              if info ? ref
-              then {inherit (info) ref;}
-              else {}
-            )
-            // (
-              if info ? submodules
-              then {inherit (info) submodules;}
-              else {}
-            )
+            ({ url = info.url; }
+             // (if info ? rev then { inherit (info) rev; } else {})
+             // (if info ? ref then { inherit (info) ref; } else {})
+             // (if info ? submodules then { inherit (info) submodules; } else {})
             );
         lastModified = info.lastModified;
         lastModifiedDate = formatSecondsSinceEpoch info.lastModified;
         narHash = info.narHash;
-      }
-      // (
-        if info ? rev
-        then {
+      } // (if info ? rev then {
         rev = info.rev;
         shortRev = builtins.substring 0 7 info.rev;
-        }
-        else {}
-      )
-    else if info.type == "path"
-    then {
-      outPath = builtins.path {
-        path =
-          if builtins.substring 0 1 info.path != "/"
+      } else {
+      })
+    else if info.type == "path" then
+      { outPath = builtins.path { 
+        path = if builtins.substring 0 1 info.path != "/"
           then src + ("/" + info.path)  # make this absolute path by prepending ./
           else info.path; # it's already an absolute path
       };
         narHash = info.narHash;
       }
-    else if info.type == "tarball"
-    then {
-      outPath =
+    else if info.type == "tarball" then
+      { outPath =
           fetchTarball
-        (
-          {inherit (info) url;}
-          // (
-            if info ? narHash
-            then {sha256 = info.narHash;}
-            else {}
-          )
+            ({ inherit (info) url; }
+             // (if info ? narHash then { sha256 = info.narHash; } else {})
             );
       }
-    else if info.type == "gitlab"
-    then {
-      inherit (info) rev narHash lastModified;
+    else if info.type == "gitlab" then
+      { inherit (info) rev narHash lastModified;
         outPath =
           fetchTarball
-        (
-          {url = "https://${info.host or "gitlab.com"}/api/v4/projects/${info.owner}%2F${info.repo}/repository/archive.tar.gz?sha=${info.rev}";}
-          // (
-            if info ? narHash
-            then {sha256 = info.narHash;}
-            else {}
-          )
+            ({ url = "https://${info.host or "gitlab.com"}/api/v4/projects/${info.owner}%2F${info.repo}/repository/archive.tar.gz?sha=${info.rev}"; }
+             // (if info ? narHash then { sha256 = info.narHash; } else {})
             );
         shortRev = builtins.substring 0 7 info.rev;
       }
@@ -108,55 +71,46 @@
       # FIXME: add Mercurial, tarball inputs.
       throw "flake input has unsupported input type '${info.type}'";
 
-  callFlake4 = flakeSrc: locks: let
+  callFlake4 = flakeSrc: locks:
+    let
       flake = import (flakeSrc + "/flake.nix");
 
-    inputs =
-      builtins.mapAttrs
-      (n: v:
+      inputs = builtins.mapAttrs (n: v:
         if v.flake or true
         then callFlake4 (fetchTree (v.locked // v.info)) v.inputs
-        else fetchTree (v.locked // v.info))
-      locks;
+        else fetchTree (v.locked // v.info)) locks;
 
       outputs = flakeSrc // (flake.outputs (inputs // {self = outputs;}));
     in
-    assert flake.edition == 201909; outputs;
-
-  callLocklessFlake = flakeSrc: let
-    flake = import (flakeSrc + "/flake.nix");
-    outputs = flakeSrc // (flake.outputs {self = outputs;});
-  in
+      assert flake.edition == 201909;
       outputs;
 
+  callLocklessFlake = flakeSrc:
+    let
+      flake = import (flakeSrc + "/flake.nix");
+      outputs = flakeSrc // (flake.outputs ({ self = outputs; }));
+    in outputs;
+
   rootSrc = let
     # Try to clean the source tree by using fetchGit, if this source
     # tree is a valid git repository.
     tryFetchGit = src:
       if isGit && !isShallow
-      then let
-        res = builtins.fetchGit src;
-      in
-        if res.rev == "0000000000000000000000000000000000000000"
-        then removeAttrs res ["rev" "shortRev"]
-        else res
+      then
+        let res = builtins.fetchGit src;
+        in if res.rev == "0000000000000000000000000000000000000000" then removeAttrs res ["rev" "shortRev"]  else res
       else { outPath = src; };
     # NB git worktrees have a file for .git, so we don't check the type of .git
     isGit = builtins.pathExists (src + "/.git");
     isShallow = builtins.pathExists (src + "/.git/shallow");
+
   in
-    {
-      lastModified = 0;
-      lastModifiedDate = formatSecondsSinceEpoch 0;
-    }
-    // (
-      if src ? outPath
-      then src
-      else tryFetchGit src
-    );
+    { lastModified = 0; lastModifiedDate = formatSecondsSinceEpoch 0; }
+      // (if src ? outPath then src else tryFetchGit src);
 
   # Format number of seconds in the Unix epoch as %Y%m%d%H%M%S.
-  formatSecondsSinceEpoch = t: let
+  formatSecondsSinceEpoch = t:
+    let
       rem = x: y: x - x / y * y;
       days = t / 86400;
       secondsInDay = rem t 86400;
@@ -166,65 +120,33 @@
 
       # Courtesy of https://stackoverflow.com/a/32158604.
       z = days + 719468;
-    era =
-      (
-        if z >= 0
-        then z
-        else z - 146096
-      )
-      / 146097;
+      era = (if z >= 0 then z else z - 146096) / 146097;
       doe = z - era * 146097;
       yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
       y = yoe + era * 400;
       doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
       mp = (5 * doy + 2) / 153;
       d = doy - (153 * mp + 2) / 5 + 1;
-    m =
-      mp
-      + (
-        if mp < 10
-        then 3
-        else -9
-      );
-    y' =
-      y
-      + (
-        if m <= 2
-        then 1
-        else 0
-      );
+      m = mp + (if mp < 10 then 3 else -9);
+      y' = y + (if m <= 2 then 1 else 0);
 
-    pad = s:
-      if builtins.stringLength s < 2
-      then "0" + s
-      else s;
+      pad = s: if builtins.stringLength s < 2 then "0" + s else s;
     in "${toString y'}${pad (toString m)}${pad (toString d)}${pad (toString hours)}${pad (toString minutes)}${pad (toString seconds)}";
 
   allNodes =
     builtins.mapAttrs
-    (
-      key: node: let
+      (key: node:
+        let
           sourceInfo =
             if key == lockFile.root
             then rootSrc
             else fetchTree (node.info or {} // removeAttrs node.locked ["dir"]);
 
-        subdir =
-          if key == lockFile.root
-          then ""
-          else node.locked.dir or "";
+          subdir = if key == lockFile.root then "" else node.locked.dir or "";
 
-        flake = import (sourceInfo
-          + (
-            if subdir != ""
-            then "/"
-            else ""
-          )
-          + subdir
-          + "/flake.nix");
+          flake = import (sourceInfo + (if subdir != "" then "/" else "") + subdir + "/flake.nix");
 
-        inputs =
-          builtins.mapAttrs
+          inputs = builtins.mapAttrs
             (inputName: inputSpec: allNodes.${resolveInput inputSpec})
             (node.inputs or {});
 
@@ -249,18 +171,13 @@
 
           outputs = flake.outputs (inputs // { self = result; });
 
-        result =
-          outputs
-          // sourceInfo
-          // {
-            inherit inputs;
-            inherit outputs;
-            inherit sourceInfo;
-          };
+          result = outputs // sourceInfo // { inherit inputs; inherit outputs; inherit sourceInfo; };
         in
-        if node.flake or true
-        then assert builtins.isFunction flake.outputs; result
-        else sourceInfo
+          if node.flake or true then
+            assert builtins.isFunction flake.outputs;
+            result
+          else
+            sourceInfo
       )
       lockFile.nodes;
 
@@ -272,30 +189,16 @@
     else if lockFile.version >= 5 && lockFile.version <= 7
     then allNodes.${lockFile.root}
     else throw "lock file '${lockFilePath}' has unsupported version ${toString lockFile.version}";
-in rec {
+
+in
+  rec {
     defaultNix =
       (builtins.removeAttrs result ["__functor"])
-    // (
-      if result ? defaultPackage.${system}
-      then {default = result.defaultPackage.${system};}
-      else {}
-    )
-    // (
-      if result ? packages.${system}.default
-      then {default = result.packages.${system}.default;}
-      else {}
-    );
+      // (if result ? defaultPackage.${system} then { default = result.defaultPackage.${system}; } else {})
+      // (if result ? packages.${system}.default then { default = result.packages.${system}.default; } else {});
 
     shellNix =
       defaultNix
-    // (
-      if result ? devShell.${system}
-      then {default = result.devShell.${system};}
-      else {}
-    )
-    // (
-      if result ? devShells.${system}.default
-      then {default = result.devShells.${system}.default;}
-      else {}
-    );
+      // (if result ? devShell.${system} then { default = result.devShell.${system}; } else {})
+      // (if result ? devShells.${system}.default then { default = result.devShells.${system}.default; } else {});
   }

out-of-tree/nixGL/all.nix

@@ -6,19 +6,19 @@ let
     nvidiaHash = "edd415acf2f75a659e0f3b4f27c1fab770cf21614e84a18152d94f0d004a758e";
   });
 
-  versionFile440 = pkgs.callPackage ./nixGL.nix {
+  versionFile440 = (pkgs.callPackage ./nixGL.nix {
     nvidiaVersionFile = pkgs.writeText "nvidia-version-440.82" ''
       NVRM version: NVIDIA UNIX x86_64 Kernel Module  440.82  Wed Apr  1 20:04:33 UTC 2020
       GCC version:  gcc version 9.3.0 (Arch Linux 9.3.0-1)
     '';
-  };
+  });
 
-  versionFile510 = pkgs.callPackage ./nixGL.nix {
+  versionFile510 = (pkgs.callPackage ./nixGL.nix {
     nvidiaVersionFile = pkgs.writeText "nvidia-version-510.54" ''
       NVRM version: NVIDIA UNIX x86_64 Kernel Module  510.54  Wed Apr  1 20:04:33 UTC 2020
       GCC version:  gcc version 9.3.0 (Arch Linux 9.3.0-1)
     '';
-  };
+  });
 in
 (with pure; [ nixGLIntel nixVulkanNvidia nixGLNvidia nixVulkanIntel ])
 ++ (with versionFile440.auto; [ nixGLNvidia nixGLDefault nixVulkanNvidia ])

out-of-tree/nixGL/default.nix

@@ -1,27 +1,26 @@
 {
   ## Nvidia informations.
   # Version of the system kernel module. Let it to null to enable auto-detection.
-  nvidiaVersion ? null,
-  # Hash of the Nvidia driver .run file. null is fine, but fixing a value here
+  nvidiaVersion ? null
+, # Hash of the Nvidia driver .run file. null is fine, but fixing a value here
   # will be more reproducible and more efficient.
-  nvidiaHash ? null,
-  # Alternatively, you can pass a path that points to a nvidia version file
+  nvidiaHash ? null
+, # Alternatively, you can pass a path that points to a nvidia version file
   # and let nixGL extract the version from it. That file must be a copy of
   # /proc/driver/nvidia/version. Nix doesn't like zero-sized files (see
   # https://github.com/NixOS/nix/issues/3539 ).
-  nvidiaVersionFile ? null,
-  # Enable 32 bits driver
+  nvidiaVersionFile ? null
+, # Enable 32 bits driver
   # This is on by default, you can switch it to off if you want to reduce a
   # bit the size of nixGL closure.
-  enable32bits ? true,
-  # Make sure to enable config.allowUnfree to the instance of nixpkgs to be
+  enable32bits ? true
+, # Make sure to enable config.allowUnfree to the instance of nixpkgs to be
   # able to access the nvidia drivers.
-  pkgs ?
-    import <nixpkgs> {
+  pkgs ? import <nixpkgs> {
     config = { allowUnfree = true; };
-    },
-  # Enable all Intel specific extensions which only works on x86_64
-  enableIntelX86Extensions ? true,
+  }
+, # Enable all Intel specific extensions which only works on x86_64
+  enableIntelX86Extensions ? true
 }:
 pkgs.callPackage ./nixGL.nix ({
   inherit
@@ -30,12 +29,8 @@ pkgs.callPackage ./nixGL.nix ({
     nvidiaHash
     enable32bits
     ;
-  }
-  // (
-    if enableIntelX86Extensions
-    then {}
+} // (if enableIntelX86Extensions then { }
 else {
   intel-media-driver = null;
   vaapiIntel = null;
-    }
-  ))
+}))

out-of-tree/nixGL/fetch.py

@@ -1,81 +1,65 @@
 #!/usr/bin/env python3
-# execution: fetch.py >nvidia_versions.json
-
-import http.client
+import urllib3
 import json
-import sys
 
-NV_FREE_X86_URL = "download.nvidia.com"
-POTENTIAL_SHA256_EXTS = [".sha256sum", ".sha256"]
-RIGHT_PAD = " " * 20
+http = urllib3.PoolManager()
+dl_dir = http.request("GET", "https://download.nvidia.com/XFree86/Linux-x86_64/")
 
-conn = http.client.HTTPSConnection(NV_FREE_X86_URL)
-conn.request("GET", "/XFree86/Linux-x86_64/")
-response = conn.getresponse()
-dir_html = response.read()
+# print(f"{dl_dir.status=}\n{dl_dir.data=}")
 
-assert (response.status < 400), "Error occurred fetching for source from"
+assert (dl_dir.status < 400), "Error probably occurred"
 
-def scrape_driver_versions(dir_html: bytes):
-    # The idea is to recursively follows all interesting `src` from `<a href={src}>`
-    def _rec(dir_html: bytes, href_url_start: int = 0, so_far: list[str] = []) -> list[str]:
+def find_versions(dir_html: bytes) -> list[str]:
+    # this algorithm obviously need recursion because we need to discover the items
+    def _rec(dir_html: bytes, start: int = 0, so_far: list[str] = []) -> list[str]:
         MATCH_START = b"<span class=\'dir\'><a href=\'"
-        href_url_start = dir_html.find(MATCH_START, href_url_start)
-        if href_url_start == -1: # EOF
+        potential_start = dir_html.find(MATCH_START, start)
+        if potential_start == -1:
             return so_far
-
-        # version href should start with a number
-        potential_version_start = href_url_start + len(MATCH_START)
+        # check that it starts with a number
+        potential_version_start = potential_start + len(MATCH_START)
         p = potential_version_start
         if not (dir_html[p: p+1].decode().isnumeric()):
             return _rec(dir_html, potential_version_start, so_far)
 
+        # this thing matches, add to so_far and continue
         version_end = dir_html.find(b"/", potential_version_start)
-        assert version_end != -1, "Should have end-signaling /"
+        assert version_end != -1, "There should be matching /"
         so_far.append(dir_html[potential_version_start:version_end].decode())
         return _rec(dir_html, version_end, so_far)
+    return _rec(dir_html, 0, [])
     
-    versions = _rec(dir_html, 0, [])
-    num_versions = len(versions)
-    for i, version in enumerate(versions):
-        print(f"[{i+1}/{num_versions}] Processing version {version}{RIGHT_PAD}", end="\r", file=sys.stderr)
-        yield version
-    print()
+versions = find_versions(dl_dir.data)
+# print("\n".join(versions))
 
-versions = scrape_driver_versions(dir_html)
+download_urls = lambda ver: [f"https://download.nvidia.com/XFree86/Linux-x86_64/{ver}/NVIDIA-Linux-x86_64-{ver}.run"]
+sha256_urls = lambda ver: [f"{url}{dl_ext}" for dl_ext in [".sha256sum", ".sha256"] for url in download_urls(ver)]
+def req_monad(url: str, err_fn, then_fn):
+    res = http.request("GET", url)
+    if res.status >= 400:
+        return err_fn(res.status)
+    return then_fn(res.data)
 
-download_urls_of = lambda ver: [f"/XFree86/Linux-x86_64/{ver}/NVIDIA-Linux-x86_64-{ver}.run"]
-sha256_urls_of = lambda ver: [
-    f"{url}{dl_ext}" 
-    for dl_ext in POTENTIAL_SHA256_EXTS 
-    for url in download_urls_of(ver)
-]
+identity = lambda e: e
+none_id = lambda _: None
 
-def sha256_of(version: str) -> str | None:
-    if int(version.split(".")[0]) < 256:
-        # Has 3 different packages that we should probably not bother
+def get_sha256(version: str) -> str | None:
+    for url in sha256_urls(version):
+        res = http.request("GET", url)
+        # print(f"attempting: {url}")
+        if res.status < 400:
+            return res.data.decode().split()[0]
     return None
-    for url in sha256_urls_of(version):
-        conn = http.client.HTTPSConnection(NV_FREE_X86_URL)
-        conn.request("GET", url)
-        response = conn.getresponse()
-        if response.status < 400:
-            return response.read().decode().split()[0]
-    print(f"No sha256 for {version}{RIGHT_PAD}", file=sys.stderr)
-    return None
-
-def fetch(version: str):
-    dl_url = download_urls_of(version)[0]
-    sha256 = sha256_of(version)
-    return (version, dl_url, sha256)
-
-fetch_data = [fetch(v) for v in versions]
+fetch_data = [(v, download_urls(v)[0], get_sha256(v)) for v in versions]
 fetch_data.append(("latest", *fetch_data[-1][1:]))
 
+# print(fetch_data)
+
 # now print the JSON object
 print(json.dumps({
     version: {
-        "url": f"https://{NV_FREE_X86_URL}{dl_url}", 
+        "url": dl_url, 
         "sha256": sha256
     } for (version, dl_url, sha256) in fetch_data if sha256 is not None}, indent=4))
+# execution: fetch.py >nvidia_versions.json