commit a19d5a4a4a540196388b912cc8d87e475169c600 · aylac.top/nixcfg-own-knot

+5 -1

modules/flake/files/helix.nix

···

       15
       15
        
                     name = "nix";

     

       16
       16
        
                     auto-format = true;

     

       17
       17
        
                     formatter = {command = lib.getExe pkgs.alejandra;};

     

       18
       18
       -
                     language-servers = ["nixd"];

     

       18
       18
       +
                     language-servers = ["nixd" "nil"];

     

       19
       19
        
                   }

     

       20
       20
        
                   {

     

       21
       21
        
                     name = "bash";

     
···

       39
       39
        
       

     

       40
       40
        
                   nixd = {

     

       41
       41
        
                     command = lib.getExe pkgs.nixd;

     

       42
       42
       +
                   };

     

       43
       43
       +
       

     

       44
       44
       +
                   nil = {

     

       45
       45
       +
                     command = lib.getExe pkgs.nil;

     

       42
       46
        
                   };

     

       43
       47
        
                 };

     

       44
       48
        
               };

+33 -6

modules/flake/files/zed.nix

···

       32
       32
        
                 auto_install_extensions = {

     

       33
       33
        
                   basher = true;

     

       34
       34
        
                   nix = true;

     

       35
       35
       +
                   marksman = true;

     

       35
       36
        
                 };

     

       36
       37
        
       

     

       37
       38
        
                 languages = {

     

       38
       38
       -
                   JSON = biome;

     

       39
       39
       +
                   JSON = biome // {language_servers = ["json-language-server"];};

     

       39
       40
        
       

     

       40
       41
        
                   Markdown = {

     

       41
       42
        
                     format_on_save = "on";

     

       42
       42
       -
       

     

       43
       43
        
                     formatter = prettier;

     

       44
       44
       +
                     language_servers = ["marksman"];

     

       44
       45
        
                   };

     

       45
       46
        
       

     

       46
       47
        
                   Nix = {

     

       47
       48
        
                     format_on_save = "on";

     

       48
       49
        
                     formatter = "language_server";

     

       49
       49
       -
                     language_servers = ["nixd"];

     

       50
       50
       +
                     language_servers = [

     

       51
       51
       +
                       "nixd"

     

       52
       52
       +
                       "nil"

     

       53
       53
       +
                     ];

     

       50
       54
        
                   };

     

       51
       55
        
       

     

       52
       56
        
                   "Shell Script" = {

     
···

       69
       73
        
                   };

     

       70
       74
        
                 };

     

       71
       75
        
       

     

       72
       72
       -
                 lsp.nixd = {

     

       73
       73
       -
                   binary.path = lib.getExe pkgs.nixd;

     

       74
       74
       -
                   settings.formatting.command = [(lib.getExe pkgs.alejandra) "--quiet" "--"];

     

       76
       76
       +
                 lsp = {

     

       77
       77
       +
                   nixd = {

     

       78
       78
       +
                     binary.path = lib.getExe pkgs.nixd;

     

       79
       79
       +
                     settings.formatting.command = [(lib.getExe pkgs.alejandra) "--quiet" "--"];

     

       80
       80
       +
                   };

     

       81
       81
       +
                   nil = {

     

       82
       82
       +
                     binary = {

     

       83
       83
       +
                       path = lib.getExe pkgs.nil;

     

       84
       84
       +
                       arguments = ["--stdio"];

     

       85
       85
       +
                     };

     

       86
       86
       +
                   };

     

       87
       87
       +
                   json-language-server = {

     

       88
       88
       +
                     binary = {

     

       89
       89
       +
                       path = pkgs.writeScript "vscode-json-languageserver-bun" ''

     

       90
       90
       +
                         #! ${pkgs.bash}/bin/bash -e

     

       91
       91
       +
                         exec ${lib.getExe pkgs.bun} ${pkgs.vscode-json-languageserver}/lib/node_modules/vscode-json-languageserver/./bin/vscode-json-languageserver "$@"

     

       92
       92
       +
                       '';

     

       93
       93
       +
                       arguments = ["--stdio"];

     

       94
       94
       +
                     };

     

       95
       95
       +
                   };

     

       96
       96
       +
                   marksman = {

     

       97
       97
       +
                     binary = {

     

       98
       98
       +
                       path = lib.getExe pkgs.marksman;

     

       99
       99
       +
                       arguments = ["server"];

     

       100
       100
       +
                     };

     

       101
       101
       +
                   };

     

       75
       102
        
                 };

     

       76
       103
        
               };

     

       77
       104
        
             }

+35 -7

modules/home/programs/helix/default.nix

···

       91
       91
        
       

     

       92
       92
        
                 fish-lsp = {

     

       93
       93
        
                   command = lib.getExe pkgs.fish-lsp;

     

       94
       94
       -
                   args = ["--stdio"];

     

       94
       94
       +
                   args = ["start"];

     

       95
       95
        
                 };

     

       96
       96
        
       

     

       97
       97
        
                 lua-language-server = {

     

       98
       98
        
                   command = lib.getExe pkgs.lua-language-server;

     

       99
       99
       -
                   args = ["--stdio"];

     

       100
       99
        
                 };

     

       101
       100
        
       

     

       102
       101
        
                 marksman = {

     

       103
       102
        
                   command = lib.getExe pkgs.marksman;

     

       104
       104
       -
                   args = ["--stdio"];

     

       103
       103
       +
                   args = ["server"];

     

       105
       104
        
                 };

     

       106
       105
        
       

     

       107
       106
        
                 nixd = {

     

       108
       107
        
                   command = lib.getExe pkgs.nixd;

     

       108
       108
       +
                 };

     

       109
       109
       +
       

     

       110
       110
       +
                 nil = {

     

       111
       111
       +
                   command = lib.getExe pkgs.nil;

     

       109
       112
        
                 };

     

       110
       113
        
       

     

       111
       114
        
                 vscode-json-languageserver = {

     
···

       126
       129
        
       

     

       127
       130
        
                 superhtml = {

     

       128
       131
        
                   command = lib.getExe pkgs.superhtml;

     

       129
       129
       -
                   args = ["--stdio"];

     

       132
       132
       +
                   args = ["lsp"];

     

       130
       133
        
                 };

     

       131
       134
        
       

     

       132
       135
        
                 biome = {

     

       133
       136
        
                   command = lib.getExe pkgs.biome;

     

       134
       137
        
                   args = ["lsp-proxy"];

     

       138
       138
       +
                   config = {

     

       139
       139
       +
                     format = {"html.formatter.enabled" = true;};

     

       140
       140
       +
                   };

     

       141
       141
       +
                 };

     

       142
       142
       +
       

     

       143
       143
       +
                 vscode-html-language-server = {

     

       144
       144
       +
                   command = pkgs.writeScript "vscode-html-language-server-bun" ''

     

       145
       145
       +
                     #! ${pkgs.bash}/bin/bash -e

     

       146
       146
       +
                     exec ${lib.getExe pkgs.bun} ${pkgs.vscode-langservers-extracted}/lib/node_modules/vscode-langservers-extracted/bin/vscode-html-language-server "$@"

     

       147
       147
       +
                   '';

     

       148
       148
       +
                   args = ["--stdio"];

     

       135
       149
        
                 };

     

       136
       150
        
               };

     

       137
       151
        
       

     
···

       169
       183
        
                   auto-format = true;

     

       170
       184
        
                   language-servers = [

     

       171
       185
        
                     {

     

       172
       172
       -
                       name = "superhmtl";

     

       186
       186
       +
                       name = "vscode-html-language-server";

     

       187
       187
       +
                       except-features = ["format"];

     

       188
       188
       +
                     }

     

       189
       189
       +
                     {

     

       190
       190
       +
                       name = "superhtml";

     

       191
       191
       +
                       except-features = ["format"];

     

       192
       192
       +
                     }

     

       193
       193
       +
                     {

     

       194
       194
       +
                       name = "biome";

     

       173
       195
        
                       except-features = ["format"];

     

       174
       196
        
                     }

     

       175
       175
       -
                     "biome"

     

       176
       197
        
                   ];

     

       198
       198
       +
                   formatter = {

     

       199
       199
       +
                     command = lib.getExe pkgs.biome;

     

       200
       200
       +
                     args = ["format" "--use-server" "--html-formatter-enabled=true" "--stdin-file-path=%{buffer_name}"];

     

       201
       201
       +
                   };

     

       177
       202
        
                 }

     

       178
       203
        
                 {

     

       179
       204
        
                   name = "javascript";

     
···

       213
       238
        
                   name = "nix";

     

       214
       239
        
                   auto-format = true;

     

       215
       240
        
                   formatter = {command = lib.getExe pkgs.alejandra;};

     

       216
       216
       -
                   language-servers = ["nixd"];

     

       241
       241
       +
                   language-servers = [

     

       242
       242
       +
                     "nixd"

     

       243
       243
       +
                     "nil"

     

       244
       244
       +
                   ];

     

       217
       245
        
                 }

     

       218
       246
        
                 {

     

       219
       247
        
                   name = "typescript";

+115 -16

modules/home/programs/zed-editor/default.nix

···

       11
       11
        
           code_actions_on_format = {

     

       12
       12
        
             "source.fixAll.biome" = true;

     

       13
       13
        
             "source.organizeImports.biome" = true;

     

       14
       14
       +
             "source.action.useSortedKeys.biome" = true;

     

       14
       15
        
           };

     

       15
       16
        
         };

     

       16
       16
       -
         biomeTS =

     

       17
       17
       -
           biome

     

       18
       18
       -
           // {

     

       19
       19
       -
             language_servers = [

     

       20
       20
       -
               "typescript-language-server"

     

       21
       21
       -
               "biome"

     

       22
       22
       -
               "!vtsls"

     

       23
       23
       -
               "!eslint"

     

       24
       24
       -
             ];

     

       25
       25
       -
           };

     

       26
       17
        
         prettier = {

     

       27
       18
        
           external = {

     

       28
       19
        
             command = pkgs.writeScript "prettier-bun" ''

     
···

       49
       40
        
               "scss"

     

       50
       41
        
               "toml"

     

       51
       42
        
               "biome"

     

       43
       43
       +
               "superhtml"

     

       44
       44
       +
               "marksman"

     

       52
       45
        
             ];

     

       53
       46
        
             userSettings = {

     

       54
       47
        
               auto_indent_on_paste = true;

     
···

       75
       68
        
               };

     

       76
       69
        
       

     

       77
       70
        
               languages = {

     

       78
       78
       -
                 JavaScript = biomeTS;

     

       79
       79
       -
                 TypeScript = biomeTS;

     

       80
       80
       -
                 TSX = biomeTS;

     

       81
       81
       -
                 JSON = biome;

     

       82
       82
       -
                 CSS = biome;

     

       71
       71
       +
                 JavaScript =

     

       72
       72
       +
                   biome

     

       73
       73
       +
                   // {

     

       74
       74
       +
                     language_servers = [

     

       75
       75
       +
                       "typescript-language-server"

     

       76
       76
       +
                       "biome"

     

       77
       77
       +
                       "!vtsls"

     

       78
       78
       +
                       "!eslint"

     

       79
       79
       +
                     ];

     

       80
       80
       +
                   };

     

       81
       81
       +
                 TypeScript =

     

       82
       82
       +
                   biome

     

       83
       83
       +
                   // {

     

       84
       84
       +
                     language_servers = [

     

       85
       85
       +
                       "typescript-language-server"

     

       86
       86
       +
                       "biome"

     

       87
       87
       +
                       "!vtsls"

     

       88
       88
       +
                       "!eslint"

     

       89
       89
       +
                     ];

     

       90
       90
       +
                   };

     

       91
       91
       +
                 TSX =

     

       92
       92
       +
                   biome

     

       93
       93
       +
                   // {

     

       94
       94
       +
                     language_servers = [

     

       95
       95
       +
                       "typescript-language-server"

     

       96
       96
       +
                       "biome"

     

       97
       97
       +
                       "!vtsls"

     

       98
       98
       +
                       "!eslint"

     

       99
       99
       +
                     ];

     

       100
       100
       +
                   };

     

       101
       101
       +
                 JSON =

     

       102
       102
       +
                   biome

     

       103
       103
       +
                   // {

     

       104
       104
       +
                     language_servers = [

     

       105
       105
       +
                       "json-language-server"

     

       106
       106
       +
                       "biome"

     

       107
       107
       +
                     ];

     

       108
       108
       +
                   };

     

       109
       109
       +
                 CSS =

     

       110
       110
       +
                   biome

     

       111
       111
       +
                   // {

     

       112
       112
       +
                     language_servers = [

     

       113
       113
       +
                       "css-language-server"

     

       114
       114
       +
                       "biome"

     

       115
       115
       +
                     ];

     

       116
       116
       +
                   };

     

       117
       117
       +
                 HTML = {

     

       118
       118
       +
                   format_on_save = "on";

     

       119
       119
       +
                   formatter = {

     

       120
       120
       +
                     language_server = {

     

       121
       121
       +
                       name = "biome";

     

       122
       122
       +
                     };

     

       123
       123
       +
                   };

     

       124
       124
       +
                   code_actions_on_format = {

     

       125
       125
       +
                     "html.formatter.enabled.biome" = true;

     

       126
       126
       +
                   };

     

       127
       127
       +
                   language_servers = ["vscode-html-language-server" "superhtml" "biome"];

     

       128
       128
       +
                 };

     

       83
       129
        
                 Nix = {

     

       84
       130
        
                   format_on_save = "on";

     

       85
       131
        
                   formatter = "language_server";

     

       86
       132
        
                   language_servers = [

     

       87
       133
        
                     "nixd"

     

       134
       134
       +
                     "nil"

     

       88
       135
        
                   ];

     

       89
       136
        
                 };

     

       90
       137
        
                 Markdown = {

     

       91
       138
        
                   format_on_save = "on";

     

       92
       92
       -
       

     

       93
       139
        
                   formatter = prettier;

     

       140
       140
       +
                   language_servers = ["marksman"];

     

       141
       141
       +
                 };

     

       142
       142
       +
                 Fish = {

     

       143
       143
       +
                   format_on_save = "on";

     

       144
       144
       +
                   formatter = "language_server";

     

       145
       145
       +
                   language_servers = ["fish-lsp"];

     

       146
       146
       +
                 };

     

       147
       147
       +
                 Lua = {

     

       148
       148
       +
                   format_on_save = "on";

     

       149
       149
       +
                   formatter = {

     

       150
       150
       +
                     external = {

     

       151
       151
       +
                       command = lib.getExe pkgs.stylua;

     

       152
       152
       +
                     };

     

       153
       153
       +
                   };

     

       154
       154
       +
                   language_servers = ["lua-language-server"];

     

       94
       155
        
                 };

     

       95
       156
        
               };

     

       96
       157
        
               lsp = {

     

       97
       158
        
                 nixd = {

     

       98
       159
        
                   binary.path = lib.getExe pkgs.nixd;

     

       99
       160
        
                   settings.formatting.command = [(lib.getExe pkgs.alejandra) "--quiet" "--"];

     

       161
       161
       +
                 };

     

       162
       162
       +
                 nil = {

     

       163
       163
       +
                   binary = {

     

       164
       164
       +
                     path = lib.getExe pkgs.nil;

     

       165
       165
       +
                     arguments = ["--stdio"];

     

       166
       166
       +
                   };

     

       100
       167
        
                 };

     

       101
       168
        
                 typescript-language-server = with pkgs.nodePackages; {

     

       102
       169
        
                   binary = {

     
···

       125
       192
        
                     arguments = ["--stdio"];

     

       126
       193
        
                   };

     

       127
       194
        
                 };

     

       195
       195
       +
                 vscode-html-language-server = {

     

       196
       196
       +
                   binary = {

     

       197
       197
       +
                     path = pkgs.writeScript "vscode-html-language-server-bun" ''

     

       198
       198
       +
                       #! ${pkgs.bash}/bin/bash -e

     

       199
       199
       +
                       exec ${lib.getExe pkgs.bun} ${pkgs.vscode-langservers-extracted}/lib/node_modules/vscode-langservers-extracted/bin/vscode-html-language-server "$@"

     

       200
       200
       +
                     '';

     

       201
       201
       +
                     arguments = ["--stdio"];

     

       202
       202
       +
                   };

     

       203
       203
       +
                 };

     

       128
       204
        
                 biome = {

     

       129
       205
        
                   binary = {

     

       130
       206
        
                     path = lib.getExe pkgs.biome;

     

       131
       207
        
                     arguments = ["lsp-proxy"];

     

       208
       208
       +
                   };

     

       209
       209
       +
                 };

     

       210
       210
       +
                 superhtml = {

     

       211
       211
       +
                   binary = {

     

       212
       212
       +
                     path = lib.getExe pkgs.superhtml;

     

       213
       213
       +
                     arguments = ["lsp"];

     

       214
       214
       +
                   };

     

       215
       215
       +
                 };

     

       216
       216
       +
                 marksman = {

     

       217
       217
       +
                   binary = {

     

       218
       218
       +
                     path = lib.getExe pkgs.marksman;

     

       219
       219
       +
                     arguments = ["server"];

     

       220
       220
       +
                   };

     

       221
       221
       +
                 };

     

       222
       222
       +
                 fish-lsp = {

     

       223
       223
       +
                   binary = {

     

       224
       224
       +
                     path = lib.getExe pkgs.fish-lsp;

     

       225
       225
       +
                     arguments = ["start"];

     

       226
       226
       +
                   };

     

       227
       227
       +
                 };

     

       228
       228
       +
                 lua-language-server = {

     

       229
       229
       +
                   binary = {

     

       230
       230
       +
                     path = lib.getExe pkgs.lua-language-server;

     

       132
       231
        
                   };

     

       133
       232
        
                 };

     

       134
       233
        
               };