feat(herdr): enable kitty graphics

flake.lock

@@ -404,6 +404,21 @@
         "type": "github"
       }
     },
+    "monorepo": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_2"
+      },
+      "locked": {
+        "lastModified": 1788059616,
+        "narHash": "sha256-HBYT3h0vXRsvmgPOhUW3kgPTkgdl73PEwRTJQ5X48aM=",
+        "path": "/home/alexion/dev",
+        "type": "path"
+      },
+      "original": {
+        "path": "/home/alexion/dev",
+        "type": "path"
+      }
+    },
     "nixos-hardware": {
       "inputs": {
         "nixpkgs": [
@@ -542,8 +557,12 @@
         "firefox-addons": "firefox-addons",
         "gitea-axi": "gitea-axi",
         "home-manager": "home-manager_3",
+        "monorepo": "monorepo",
         "nixos-hardware": "nixos-hardware",
-        "nixpkgs": "nixpkgs_2",
+        "nixpkgs": [
+          "monorepo",
+          "nixpkgs"
+        ],
         "nixpkgs-stable": "nixpkgs-stable",
         "nixpkgs-unstable": "nixpkgs-unstable",
         "nixvim": "nixvim",

flake.nix

@@ -2,8 +2,10 @@
   description = "Alexion's NixOS configuration — one flake for every host";
 
   inputs = {
-    # Base channel.
+    monorepo.url = "path:/home/alexion/dev";
-    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
+
+    # Base package set shared with the monorepo.
+    nixpkgs.follows = "monorepo/nixpkgs";
 
     # Fresher packages, reachable per-package as `unstable.<name>`.
     nixpkgs-unstable.url = "github:nixos/nixpkgs/nixpkgs-unstable";
@@ -76,13 +78,9 @@
     { self, nixpkgs, ... }@inputs:
     let
       inherit (nixpkgs) lib;
-      flake = import ./flake { inherit lib inputs self; };
     in
     {
-      # Every host under hosts/ is discovered and built.
+      inherit (import ./flake { inherit lib inputs self; }) nixosConfigurations;
-      nixosConfigurations = flake.mkHosts {
-        root = self + "/hosts";
-      };
 
       # A project shell for agent-local resources that should travel with this
       # checkout rather than the operator's global profile.

flake/default.nix

@@ -4,55 +4,50 @@
   self,
 }:
 let
-  # TODO: refactor the registry code
-  registryAssembly = import ./registry.nix { inherit lib self; };
-
   util = import ../lib { inherit lib; };
-  mkModules = import ./module.nix { inherit util; };
 
-  modules = mkModules {
+  registry = import ./registry.nix {
+    inherit lib;
+    hosts = self.nixosConfigurations;
+    root = self + "/registry";
+  };
+
+  modules = import ./module.nix {
+    inherit util;
     root = self + "/modules";
   };
 
-  guestModules = guests.mkGuests {
+  guestModules = import ./guest.nix {
+    inherit
+      inputs
+      lib
+      registry
+      specialArgs
+      util
+      ;
+    repositoryModules = modules;
     root = self + "/guests";
   };
 
-  #----------------------------------------------------------
-
-  collectedRegistry = registryAssembly.collect { hosts = self.nixosConfigurations; };
-
   specialArgs = {
     inherit
       inputs
       self
       util
       ;
-    registry = collectedRegistry;
+    registry = registry.collected;
   };
-
+in
-  guests = import ./guest.nix {
+{
-    inherit
+  nixosConfigurations = import ./host.nix {
-      inputs
-      lib
-      specialArgs
-      registryAssembly
-      util
-      ;
-    repositoryModules = modules;
-  };
-
-  hosts = import ./host.nix {
     inherit
       inputs
       lib
       specialArgs
       guestModules
-      registryAssembly
       ;
+    registryModule = registry.module;
     repositoryModules = modules;
+    root = self + "/hosts";
   };
-in
-{
-  inherit (hosts) mkHosts;
 }

flake/guest.nix

@@ -1,9 +1,10 @@
 {
   inputs,
   lib,
+  root,
   specialArgs,
   repositoryModules,
-  registryAssembly,
+  registry,
   util,
 }:
 let
@@ -65,7 +66,7 @@ let
           enable = lib.mkEnableOption "a reverse-proxy route for this guest";
 
           route = lib.mkOption {
-            type = registryAssembly.definitions.route.type;
+            type = registry.types.route;
             description = "Route registry entry published for this guest.";
           };
         };
@@ -247,7 +248,7 @@ let
               inputs.stylix.nixosModules.stylix
 
               repositoryModules
-              registryAssembly.module
+              registry.module
               cfg.interior
 
               {
@@ -268,15 +269,11 @@ let
       };
     };
 in
+let
+  files = util.collectNixFiles root;
+  guestFiles = lib.filterAttrs (file: type: type == "regular" && lib.hasSuffix ".nix" file) (builtins.readDir root);
+  names = map (file: lib.removeSuffix ".nix" file) (lib.attrNames guestFiles);
+in
 {
-  mkGuests =
+  imports = files ++ map mkGuest names;
-    { root }:
-    let
-      files = util.collectNixFiles root;
-      guestFiles = lib.filterAttrs (file: type: type == "regular" && lib.hasSuffix ".nix" file) (builtins.readDir root);
-      names = map (file: lib.removeSuffix ".nix" file) (lib.attrNames guestFiles);
-    in
-    {
-      imports = files ++ map mkGuest names;
-    };
 }

flake/host.nix

@@ -1,12 +1,12 @@
 {
   inputs,
   lib,
+  root,
   specialArgs,
   repositoryModules,
 
   guestModules,
-  # TODO refactor registry
+  registryModule,
-  registryAssembly,
 }:
 let
   mkHost =
@@ -26,7 +26,7 @@ let
         guestModules
 
         # TODO: refactor
-        registryAssembly.module (root + "/${name}")
+        registryModule (root + "/${name}")
 
         {
           networking.hostName = name;
@@ -35,15 +35,11 @@ let
       ];
     };
 in
-{
+let
-  mkHosts =
+  directories = lib.filterAttrs (_name: type: type == "directory") (builtins.readDir root);
-    { root }:
+  names = lib.attrNames directories;
-    let
+in
-      directories = lib.filterAttrs (_name: type: type == "directory") (builtins.readDir root);
+lib.genAttrs names (
-      names = lib.attrNames directories;
+  name:
-    in
+  mkHost { inherit root name; }
-    lib.genAttrs names (
+)
-      name:
-      mkHost { inherit root name; }
-    );
-}

flake/module.nix

@@ -1,5 +1,7 @@
-{ util }:
+{
-{ root }:
+  root,
+  util,
+}:
 {
   imports = util.collectNixFiles root;
 }

flake/registry.nix

@@ -1,35 +1,16 @@
-{ lib, self }:
+{ hosts, lib, root }:
 let
-  inherit (lib)
+  checkType = lib.types.submodule {
-    all
-    concatLists
-    concatMapStringsSep
-    filter
-    filterAttrs
-    foldl'
-    hasAttr
-    hasSuffix
-    mapAttrs
-    mapAttrs'
-    mapAttrsToList
-    mkOption
-    nameValuePair
-    removeSuffix
-    types
-    unique
-    ;
-
-  checkType = types.submodule {
     options = {
-      assertion = mkOption {
+      assertion = lib.mkOption {
-        type = types.functionTo types.bool;
+        type = lib.types.functionTo lib.types.bool;
         description = ''
           Predicate run against this registry's flattened collected entries.
         '';
       };
 
-      message = mkOption {
+      message = lib.mkOption {
-        type = types.str;
+        type = lib.types.str;
         description = ''
           Error message shown when this registry validation check fails.
         '';
@@ -38,7 +19,7 @@ let
   };
 
   predicates = {
-    uniqueValue = value: entries: builtins.length (unique (map value entries)) == builtins.length entries;
+    uniqueValue = value: entries: builtins.length (lib.unique (map value entries)) == builtins.length entries;
   };
 
   registryLib = lib // {
@@ -49,23 +30,23 @@ let
 
   registryDefinitionModule = {
     options = {
-      type = mkOption {
+      type = lib.mkOption {
-        type = types.raw;
+        type = lib.types.raw;
         description = ''
           NixOS option type for one registry entry.
         '';
       };
 
-      replicate = mkOption {
+      replicate = lib.mkOption {
-        type = types.bool;
+        type = lib.types.bool;
         default = false;
         description = ''
           Whether collected entries are merged and published under every host key.
         '';
       };
 
-      checks = mkOption {
+      checks = lib.mkOption {
-        type = types.listOf checkType;
+        type = lib.types.listOf checkType;
         default = [ ];
         description = ''
           Validation checks for this registry's flattened collected entries.
@@ -74,10 +55,10 @@ let
     };
   };
 
-  registryName = fileName: removeSuffix ".nix" fileName;
+  registryName = fileName: lib.removeSuffix ".nix" fileName;
 
-  registryOption = registry: mkOption {
+  registryOption = registry: lib.mkOption {
-    type = types.attrsOf (types.attrsOf registry.type);
+    type = lib.types.attrsOf (lib.types.attrsOf registry.type);
     default = { };
     description = ''
       Lazily collected fleet-visible registry entries, nested by host and entry name.
@@ -98,19 +79,19 @@ let
       inherit (evaluated.config) type replicate checks;
     };
 
-  definitions = mapAttrs' (
+  definitions = lib.mapAttrs' (
     name: type:
     let
-      path = self + "/registry/${name}";
+      path = root + "/${name}";
     in
-    nameValuePair (registryName name) (mkRegistry path)
+    lib.nameValuePair (registryName name) (mkRegistry path)
-  ) (filterAttrs (name: type: type == "regular" && hasSuffix ".nix" name) (builtins.readDir (self + "/registry")));
+  ) (lib.filterAttrs (name: type: type == "regular" && lib.hasSuffix ".nix" name) (builtins.readDir root));
 
   flattenRegistryEntries = registryName: data:
-    concatLists (
+    lib.concatLists (
-      mapAttrsToList (
+      lib.mapAttrsToList (
         host: entries:
-        mapAttrsToList (entry: value: {
+        lib.mapAttrsToList (entry: value: {
           path = "registry.${registryName}.${host}.${entry}";
           inherit host entry value;
         }) entries
@@ -118,17 +99,17 @@ let
     );
 
   rawDeclarations = registryName: hosts:
-    mapAttrs (_hostName: host: host.config.registry.${registryName} or { }) hosts;
+    lib.mapAttrs (_hostName: host: host.config.registry.${registryName} or { }) hosts;
 
   replicatedEntries = registryName: raw:
     let
-      entries = concatLists (
+      entries = lib.concatLists (
-        concatLists (
+        lib.concatLists (
-          mapAttrsToList (
+          lib.mapAttrsToList (
             _evalHost: hostDeclarations:
-            mapAttrsToList (
+            lib.mapAttrsToList (
               hostName: declarations:
-              mapAttrsToList (entryName: value: {
+              lib.mapAttrsToList (entryName: value: {
                 path = "registry.${registryName}.${hostName}.${entryName}";
                 inherit entryName value;
               }) declarations
@@ -137,9 +118,9 @@ let
         )
       );
     in
-    foldl' (
+    lib.foldl' (
       acc: entry:
-      if hasAttr entry.entryName acc then
+      if lib.hasAttr entry.entryName acc then
         if acc.${entry.entryName}.value == entry.value then
           acc
         else
@@ -152,13 +133,13 @@ let
 
   replicatedData = registryName: hosts: raw:
     let
-      entries = mapAttrs (_entryName: entry: entry.value) (replicatedEntries registryName raw);
+      entries = lib.mapAttrs (_entryName: entry: entry.value) (replicatedEntries registryName raw);
     in
-    mapAttrs (_hostName: _host: entries) hosts;
+    lib.mapAttrs (_hostName: _host: entries) hosts;
 
   validationAssertions = data:
-    concatLists (
+    lib.concatLists (
-      mapAttrsToList (
+      lib.mapAttrsToList (
         registryName: registry:
         let
           entries = flattenRegistryEntries registryName data.${registryName};
@@ -173,28 +154,28 @@ let
   assertValid = data:
     let
       assertions = validationAssertions data;
-      failures = filter (assertion: !assertion.assertion) assertions;
+      failures = lib.filter (assertion: !assertion.assertion) assertions;
     in
-    assert lib.assertMsg (all (assertion: assertion.assertion) assertions) (
+    assert lib.assertMsg (lib.all (assertion: assertion.assertion) assertions) (
-      concatMapStringsSep "\n" (assertion: assertion.message) failures
+      lib.concatMapStringsSep "\n" (assertion: assertion.message) failures
     );
     data;
 
   join = registry: host: entry:
-    filterAttrs (_name: value: value != null) (
+    lib.filterAttrs (_name: value: value != null) (
-      mapAttrs (registryName: _registry: (registry.${registryName}.${host} or { }).${entry} or null) definitions
+      lib.mapAttrs (registryName: _registry: (registry.${registryName}.${host} or { }).${entry} or null) definitions
     );
 
   collectData =
     { hosts }:
     let
-      raw = mapAttrs (registryName: _registry: rawDeclarations registryName hosts) definitions;
+      raw = lib.mapAttrs (registryName: _registry: rawDeclarations registryName hosts) definitions;
-      data = mapAttrs (
+      data = lib.mapAttrs (
         registryName: registry:
         if registry.replicate or false then
           replicatedData registryName hosts raw.${registryName}
         else
-          mapAttrs (hostName: host: host.config.registry.${registryName}.${hostName} or { }) hosts
+          lib.mapAttrs (hostName: host: host.config.registry.${registryName}.${hostName} or { }) hosts
       ) definitions;
     in
     assertValid data;
@@ -206,11 +187,11 @@ let
     };
 in
 {
-  inherit definitions predicates;
+  types = lib.mapAttrs (_name: definition: definition.type) definitions;
 
   module = {
-    options.registry = mapAttrs (_name: registry: registryOption registry) definitions;
+    options.registry = lib.mapAttrs (_name: registry: registryOption registry) definitions;
   };
 
-  collect = args: withOperations (collectData args);
+  collected = withOperations (collectData { inherit hosts; });
 }

modules/default.nix

@@ -121,5 +121,6 @@ in
     modules.shell.nvim.enable = lib.mkDefault true;
     modules.shell.git.enable = lib.mkDefault true;
     modules.shell.direnv.enable = lib.mkDefault true;
+    modules.shell.yazi.enable = lib.mkDefault true;
   };
 }

modules/desktop/apps/ghostty.nix

@@ -0,0 +1,18 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}:
+# Ghostty as the desktop terminal.
+let
+  cfg = config.modules.desktop.apps.ghostty;
+  user = config.user.name;
+in
+{
+  options.modules.desktop.apps.ghostty.enable = lib.mkEnableOption "Ghostty as the desktop terminal";
+
+  config = lib.mkIf cfg.enable {
+    home-manager.users.${user}.home.packages = [ pkgs.ghostty ];
+  };
+}

modules/desktop/default.nix

@@ -9,8 +9,8 @@ in
   # Each piece is turned on at default priority, so a host can still override
   # any one of them while the single flag above enables the whole desktop.
   config = lib.mkIf cfg.enable {
-    modules.desktop.apps.alacritty.enable = lib.mkDefault true;
     modules.desktop.apps.firefox.enable = lib.mkDefault true;
+    modules.desktop.apps.ghostty.enable = lib.mkDefault true;
     modules.desktop.session.hyprland.enable = lib.mkDefault true;
     modules.desktop.session.hyprland.hypridle.enable = lib.mkDefault true;
     modules.desktop.session.hyprland.hyprlock.enable = lib.mkDefault true;

modules/desktop/session/hyprland/default.nix

@@ -61,7 +61,7 @@ in
 
       settings = {
         "$mod" = "SUPER";
-        "$terminal" = "alacritty";
+        "$terminal" = "ghostty";
 
         # Session variables handed to the compositor directly.
         # UWSM launches the session without the shell profile that would carry

modules/desktop/session/waybar.nix

@@ -89,6 +89,7 @@ in
           window-rewrite-default = g "f2d0";
           window-rewrite = {
             "class<Alacritty>" = g "f120";
+            "class<com.mitchellh.ghostty>" = g "f120";
             "class<.*[Ff]irefox.*>" = g "f269";
             "class<chromium.*>" = g "f268";
             "class<[Cc]ode>" = g "f121";

modules/shell/direnv/default.nix

@@ -20,6 +20,7 @@ in
       # nix-direnv caches the evaluated shell so re-entering a directory is instant
       # instead of re-running `nix develop`, and adds the `use flake` stdlib helper.
       nix-direnv.enable = true;
+      stdlib = builtins.readFile ./repo-flake.sh;
     };
   };
 }

modules/shell/direnv/repo-flake.sh

@@ -0,0 +1,33 @@
+if declare -f use_flake >/dev/null; then
+  __dotfiles_use_flake_definition="$(declare -f use_flake)"
+  eval "${__dotfiles_use_flake_definition/use_flake/__dotfiles_nix_direnv_use_flake}"
+  unset __dotfiles_use_flake_definition
+
+  use_flake() {
+    local flake_expr="${1:-.}"
+
+    if [[ "$flake_expr" == //* ]]; then
+      local git_root
+      if ! git_root="$(git rev-parse --show-toplevel 2>/dev/null)"; then
+        log_error 'use flake // requires a Git repository'
+        return 1
+      fi
+
+      local flake_suffix="${flake_expr#//}"
+      if [[ -n "$flake_suffix" && "$flake_suffix" != \#* && "$flake_suffix" != /* ]]; then
+        flake_expr="path:${git_root}/${flake_suffix}"
+      else
+        flake_expr="path:${git_root}${flake_suffix}"
+      fi
+
+      shift
+      __dotfiles_nix_direnv_use_flake "$flake_expr" "$@"
+      return
+    fi
+
+    __dotfiles_nix_direnv_use_flake "$@"
+  }
+else
+  log_error 'nix-direnv must define use_flake before the // wrapper loads'
+  return 1
+fi

modules/shell/herdr.nix

@@ -38,6 +38,9 @@ in
 
         [ui]
         prompt_new_tab_name = false
+
+        [experimental]
+        kitty_graphics = true
       '';
     };
   };

modules/shell/nvim/config.lua

@@ -16,6 +16,16 @@ vim.api.nvim_create_autocmd("FileType", {
   end,
 })
 
+-- Soft-wrap prose buffers without inserting line breaks.
+vim.api.nvim_create_autocmd("FileType", {
+  pattern = { "gitcommit", "markdown", "text" },
+  callback = function()
+    vim.opt_local.wrap = true
+    vim.opt_local.linebreak = true
+    vim.opt_local.breakindent = true
+  end,
+})
+
 -- Turn line blame off again once the Neogit status buffer is closed.
 vim.api.nvim_create_autocmd("BufUnload", {
   callback = function(args)

modules/shell/nvim/default.nix

@@ -92,6 +92,18 @@ in
             action = "<cmd>nohlsearch<CR>";
             options.desc = "Clear search highlight";
           }
+          {
+            mode = "n";
+            key = "j";
+            action = "gj";
+            options.desc = "Move down by display line";
+          }
+          {
+            mode = "n";
+            key = "k";
+            action = "gk";
+            options.desc = "Move up by display line";
+          }
           {
             mode = "n";
             key = "<leader>e";

modules/shell/yazi.nix

@@ -0,0 +1,32 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}:
+# Yazi, a terminal file manager.
+let
+  cfg = config.modules.shell.yazi;
+  user = config.user.name;
+in
+{
+  options.modules.shell.yazi.enable = lib.mkEnableOption "Yazi, a terminal file manager";
+
+  config = lib.mkIf cfg.enable {
+    home-manager.users.${user}.programs.yazi = {
+      enable = true;
+      enableFishIntegration = true;
+      extraPackages = with pkgs; [
+        fd
+        ffmpegthumbnailer
+        fzf
+        imagemagick
+        jq
+        poppler
+        ripgrep
+        unar
+        zoxide
+      ];
+    };
+  };
+}