nichts/packages/helix.nix

{
  symlinkJoin,
  makeWrapper,
  helix,
  alejandra,
  basedpyright,
  bash-language-server,
  black,
  clang-tools,
  clippy,
  cmake-format,
  cmake-language-server,
  deno,
  dprint,
  formats,
  gdb,
  golangci-lint-langserver,
  gopls,
  lazygit,
  lib,
  lldb_19,
  marksman,
  nil,
  pyright,
  ruff,
  rust-analyzer,
  rustfmt,
  shellcheck,
  shfmt,
  solargraph,
  stdenv,
  superhtml,
  tinymist,
  typescript-language-server,
  vscode-langservers-extracted,
  ...
}: let
  inherit (lib.meta) getExe;

  toml = formats.toml {};
  helix-config = {
    theme = "gruvbox";
    editor = {
      cursorline = false;
      color-modes = true;
      indent-guides.render = true;
      lsp = {
        enable = true;
        auto-signature-help = true;
        display-inlay-hints = true;
        display-messages = true;
        snippets = true;
      };
      file-picker = {
        hidden = true;
      };
      line-number = "relative";
      true-color = true;
      auto-format = true;
      completion-timeout = 5;
      mouse = true;
      bufferline = "multiple";
      soft-wrap.enable = true;
      cursor-shape = {
        insert = "bar";
        normal = "block";
        select = "underline";
      };
      statusline = {
        left = ["spinner" "version-control" "diagnostics" "file-name"];
        right = ["file-base-name" "file-type" "position" "file-encoding"];
      };
      gutters.layout = ["diff" "diagnostics" "line-numbers" "spacer"];
      inline-diagnostics = {
        cursor-line = "hint";
        other-lines = "error";
      };
    };
    keys = {
      normal = {
        space.g = [":new" ":insert-output XDG_CONFIG_HOME=~/.config ${getExe lazygit}" ":buffer-close!" ":redraw"];
        esc = ["collapse_selection" "keep_primary_selection" "normal_mode"];
        A-H = "goto_previous_buffer";
        A-L = "goto_next_buffer";
        A-w = ":buffer-close";
        A-f = ":format";
        A-r = ":reload";
        A-x = "extend_to_line_bounds";
        X = ["extend_line_up" "extend_to_line_bounds"];
      };
      select = {
        A-x = "extend_to_line_bounds";
        X = ["extend_line_up" "extend_to_line_bounds"];
      };
    };
  };
  helix-languages = {
    language = let
      mark = lang: {
        command = getExe deno;
        args = ["fmt" "-" "--ext" lang];
      };
    in [
      {
        name = "bash";
        auto-format = true;
        formatter = {
          command = getExe shfmt;
          args = ["-i" "2"];
        };
      }
      {
        name = "clojure";
        injection-regex = "(clojure|clj|edn|boot|yuck)";
        file-types = ["clj" "cljs" "cljc" "clje" "cljr" "cljx" "edn" "boot" "yuck"];
      }
      {
        name = "cmake";
        auto-format = true;
        language-servers = ["cmake-language-server"];
        formatter = {
          command = getExe cmake-format;
          args = ["-"];
        };
      }
      {
        name = "javascript";
        auto-format = true;
        language-servers = ["dprint" "typescript-language-server"];
      }
      {
        name = "json";
        formatter = mark "json";
      }
      {
        name = "markdown";
        auto-format = true;
        formatter = mark "md";
      }
      {
        name = "qml";
        language-servers = ["qmlls"];
      }
      {
        name = "python";
        auto-format = true;
        language-servers = [
          "basedpyright"
          "ruff"
        ];
      }
      {
        name = "typescript";
        auto-format = true;
        language-servers = ["dprint" "typescript-language-server"];
      }
      {
        name = "rust";
      }
      {
        name = "c";
        auto-format = true;
        language-servers = ["clangd"];
      }
      {
        name = "c";
        debugger = {
          name = "gdb";
          command = getExe gdb;
          transport = "stdio";
          templates = [
            {
              name = "binary";
              request = "launch";
              completion = [
                {
                  name = "binary";
                  completion = "filename";
                }
              ];
              args = {
                program = "{0}";
                runInTerminal = true;
              };
            }
          ];
        };
      }
    ];

    language-server = {
      bash-language-server = {
        command = getExe bash-language-server;
        args = ["start"];
      };

      rust-analyzer = {
        config = {
          check.command = "clippy";
          cargo.features = "all";
        };
      };

      clangd = {
        command = "${clang-tools}/bin/clangd";
        clangd.fallbackFlags = ["-std=c++2b"];
      };

      cmake-language-server = {
        command = getExe cmake-language-server;
      };

      deno-lsp = {
        command = lib.getExe deno;
        args = ["lsp"];
        environment.NO_COLOR = "1";
        config.deno = {
          enable = true;
          lint = true;
          unstable = true;
          suggest = {
            completeFunctionCalls = false;
            imports = {hosts."https://deno.land" = true;};
          };
          inlayHints = {
            enumMemberValues.enabled = true;
            functionLikeReturnTypes.enabled = true;
            parameterNames.enabled = "all";
            parameterTypes.enabled = true;
            propertyDeclarationTypes.enabled = true;
            variableTypes.enabled = true;
          };
        };
      };
      dprint = {
        command = getExe dprint;
        args = ["lsp"];
      };

      nil = {
        command = getExe nil;
        # alejandro
        config.nil.formatting.command = ["${getExe alejandra}" "-q"];
      };

      typescript-language-server = {
        command = lib.getExe typescript-language-server;
        args = ["--stdio"];
        config = {
          typescript-language-server.source = {
            addMissingImports.ts = true;
            fixAll.ts = true;
            organizeImports.ts = true;
            removeUnusedImports.ts = true;
            sortImports.ts = true;
          };
        };
      };
      ruff = {
        command = lib.getExe ruff;
        args = ["server"];
      };
      basedpyright.command = "${basedpyright}/bin/basedpyright-langserver";

      vscode-css-language-server = {
        command = "${vscode-langservers-extracted}/bin/vscode-css-languageserver";
        args = ["--stdio"];
        config = {
          provideFormatter = true;
          css.validate.enable = true;
          scss.validate.enable = true;
        };
      };
    };
  };
  wrapped-helix = symlinkJoin {
    name = "helix-wrapped";
    paths = [
      helix

      rust-analyzer
      rustfmt
      clippy
      # typst lsp
      tinymist

      # C/C++
      clang-tools

      # Markdown
      marksman

      # Nix
      nil
      lldb_19
      # Bash
      bash-language-server

      # Shell
      shellcheck

      # ruby
      solargraph

      gopls
      golangci-lint-langserver

      vscode-langservers-extracted

      superhtml
    ];
    buildInputs = [makeWrapper];
    postBuild = ''
      mkdir -p $out/config/helix
      cp "${toml.generate "config.toml" helix-config}" $out/config/helix/config.toml
      cp "${toml.generate "languages.toml" helix-languages}" $out/config/helix/languages.toml
      wrapProgram $out/bin/hx --set \
      XDG_CONFIG_HOME $out/config
    '';
  };
in
  wrapped-helix