jan-leila/nix-config
1
0
Fork 1
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

refactor: moved modules to legacy-modules

Browse source
This commit is contained in:
Leyla Becker 2026-04-06 19:32:37 -05:00
parent d646b954ac
commit db7ac35613
233 changed files with 5 additions and 5 deletions
Download patch file Download diff file Expand all files Collapse all files

45
legacy-modules/home-manager-modules/programs/vscode/aiCode.nix Normal file
View file

@ -0,0 +1,45 @@
{
lib,
pkgs,
...
}: let
pkgsRepository = pkgs.codium-extensions;
in {
options.programs.vscode.profiles = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule ({config, ...}: {
options = {
extraExtensions.aiCode = {
enable = lib.mkEnableOption "should the ai code extension for vscode be enabled";
extension = lib.mkPackageOption pkgsRepository "ai-code" {};
ollamaHost = lib.mkOption {
type = lib.types.nullOr lib.types.str;
description = "what host should be used for ollama";
default = null;
};
inlineCompletion = {
enable = lib.mkOption {
type = lib.types.bool;
description = "should inline completion be enabled";
default = true;
};
model = lib.mkOption {
type = lib.types.nullOr lib.types.str;
description = "what model should be used for ollama";
default = null;
};
};
};
};
config = lib.mkIf config.extraExtensions.aiCode.enable {
extensions = [
config.extraExtensions.aiCode.extension
];
userSettings = {
"aiCode.ollamaHost" = lib.mkIf (config.extraExtensions.aiCode.ollamaHost != null) config.extraExtensions.aiCode.ollamaHost;
"aiCode.inlineCompletion.enable" = config.extraExtensions.aiCode.inlineCompletion.enable;
"aiCode.inlineCompletion.model" = lib.mkIf (config.extraExtensions.aiCode.inlineCompletion.model != null) config.extraExtensions.aiCode.inlineCompletion.model;
};
};
}));
};
}

34
legacy-modules/home-manager-modules/programs/vscode/alejandra.nix Normal file
View file

@ -0,0 +1,34 @@
{
lib,
pkgs,
config,
...
}: let
pkgsRepositories = pkgs.nix-vscode-extensions.forVSCodeVersion config.programs.vscode.package.version;
pkgsRepository = pkgsRepositories.open-vsx;
in {
options.programs.vscode.profiles = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule ({config, ...}: {
options = {
extraExtensions.alejandra = {
enable = lib.mkEnableOption "Enable Alejandra extension for Nix formatting";
extension = lib.mkPackageOption pkgsRepository "alejandra" {
default = ["kamadorueda" "alejandra"];
};
};
};
config = lib.mkIf config.extraExtensions.alejandra.enable {
extensions = [config.extraExtensions.alejandra.extension];
userSettings = {
"[nix]" = {
"editor.defaultFormatter" = "kamadorueda.alejandra";
"editor.formatOnPaste" = true;
"editor.formatOnSave" = true;
"editor.formatOnType" = true;
};
"alejandra.program" = "alejandra";
};
};
}));
};
}

27
legacy-modules/home-manager-modules/programs/vscode/astroVscode.nix Normal file
View file

@ -0,0 +1,27 @@
{
lib,
pkgs,
config,
...
}: let
pkgsRepositories = pkgs.nix-vscode-extensions.forVSCodeVersion config.programs.vscode.package.version;
pkgsRepository = pkgsRepositories.open-vsx;
in {
options.programs.vscode.profiles = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule ({config, ...}: {
options = {
extraExtensions.astroVscode = {
enable = lib.mkEnableOption "should the astro-vscode extension for vscode be enabled";
extension = lib.mkPackageOption pkgsRepository "astro-vscode" {
default = ["astro-build" "astro-vscode"];
};
};
};
config = lib.mkIf config.extraExtensions.astroVscode.enable {
extensions = [
config.extraExtensions.astroVscode.extension
];
};
}));
};
}

27
legacy-modules/home-manager-modules/programs/vscode/atomKeybindings.nix Normal file
View file

@ -0,0 +1,27 @@
{
lib,
pkgs,
config,
...
}: let
pkgsRepositories = pkgs.nix-vscode-extensions.forVSCodeVersion config.programs.vscode.package.version;
pkgsRepository = pkgsRepositories.open-vsx;
in {
options.programs.vscode.profiles = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule ({config, ...}: {
options = {
extraExtensions.atomKeybindings = {
enable = lib.mkEnableOption "should the atom keybindings extension for vscode be enabled";
extension = lib.mkPackageOption pkgsRepository "atom-keybindings" {
default = ["ms-vscode" "atom-keybindings"];
};
};
};
config = lib.mkIf config.extraExtensions.atomKeybindings.enable {
extensions = [
config.extraExtensions.atomKeybindings.extension
];
};
}));
};
}

27
legacy-modules/home-manager-modules/programs/vscode/autoRenameTag.nix Normal file
View file

@ -0,0 +1,27 @@
{
lib,
pkgs,
config,
...
}: let
pkgsRepositories = pkgs.nix-vscode-extensions.forVSCodeVersion config.programs.vscode.package.version;
pkgsRepository = pkgsRepositories.open-vsx;
in {
options.programs.vscode.profiles = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule ({config, ...}: {
options = {
extraExtensions.autoRenameTag = {
enable = lib.mkEnableOption "should the auto-rename-tag extension for vscode be enabled";
extension = lib.mkPackageOption pkgsRepository "auto-rename-tag" {
default = ["formulahendry" "auto-rename-tag"];
};
};
};
config = lib.mkIf config.extraExtensions.autoRenameTag.enable {
extensions = [
config.extraExtensions.autoRenameTag.extension
];
};
}));
};
}

237
legacy-modules/home-manager-modules/programs/vscode/claudeDev.nix Normal file
View file

@ -0,0 +1,237 @@
{
lib,
pkgs,
config,
inputs,
...
}: let
pkgsRepositories = pkgs.nix-vscode-extensions.forVSCodeVersion config.programs.vscode.package.version;
pkgsRepository = pkgsRepositories.open-vsx;
mcp-nixos = inputs.mcp-nixos.packages.${pkgs.stdenv.hostPlatform.system}.default;
anyProfileHasInstallTool = lib.any (
profile:
profile.extraExtensions.claudeDev.enable
&& profile.extraExtensions.claudeDev.installTool
) (lib.attrValues config.programs.vscode.profiles);
getInstallToolPackage = lib.findFirst (package: package != null) pkgs.cline (map (
profile:
if profile.extraExtensions.claudeDev.enable && profile.extraExtensions.claudeDev.installTool
then profile.extraExtensions.claudeDev.package
else null
) (lib.attrValues config.programs.vscode.profiles));
anyProfileHasMcpNixos = lib.any (
profile:
profile.extraExtensions.claudeDev.enable
&& profile.extraExtensions.claudeDev.mcp.nixos.enable
) (lib.attrValues config.programs.vscode.profiles);
anyProfileHasMcpEslint = lib.any (
profile:
profile.extraExtensions.claudeDev.enable
&& profile.extraExtensions.claudeDev.mcp.eslint.enable
) (lib.attrValues config.programs.vscode.profiles);
anyProfileHasMcpVitest = lib.any (
profile:
profile.extraExtensions.claudeDev.enable
&& profile.extraExtensions.claudeDev.mcp.vitest.enable
) (lib.attrValues config.programs.vscode.profiles);
anyProfileHasMcpSleep = lib.any (
profile:
profile.extraExtensions.claudeDev.enable
&& profile.extraExtensions.claudeDev.mcp.sleep.enable
) (lib.attrValues config.programs.vscode.profiles);
anyProfileHasMcp = anyProfileHasMcpNixos || anyProfileHasMcpEslint || anyProfileHasMcpVitest || anyProfileHasMcpSleep;
getMcpTimeout = serverName:
lib.findFirst (timeout: timeout != null) null (map (
profile:
if profile.extraExtensions.claudeDev.enable && profile.extraExtensions.claudeDev.mcp.${serverName}.enable
then profile.extraExtensions.claudeDev.mcp.${serverName}.timeout
else null
) (lib.attrValues config.programs.vscode.profiles));
getMcpAutoApprove = serverName:
lib.foldl' (
acc: profile:
if profile.extraExtensions.claudeDev.enable && profile.extraExtensions.claudeDev.mcp.${serverName}.enable
then acc // profile.extraExtensions.claudeDev.mcp.${serverName}.autoApprove
else acc
) {} (lib.attrValues config.programs.vscode.profiles);
getMcpPackage = serverName:
lib.findFirst (package: package != null) null (map (
profile:
if profile.extraExtensions.claudeDev.enable && profile.extraExtensions.claudeDev.mcp.${serverName}.enable
then profile.extraExtensions.claudeDev.mcp.${serverName}.package
else null
) (lib.attrValues config.programs.vscode.profiles));
in {
options.programs.vscode.profiles = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule ({config, ...}: {
options = {
extraExtensions.claudeDev = {
enable = lib.mkEnableOption "should the claude-dev extension for vscode be enabled";
extension = lib.mkPackageOption pkgsRepository "claude-dev" {
default = ["saoudrizwan" "claude-dev"];
};
installTool = lib.mkOption {
type = lib.types.bool;
default = true;
description = "Whether to install the cline CLI tool for subagent support when the extension is enabled";
};
package = lib.mkOption {
type = lib.types.package;
default = pkgs.cline;
description = "The package to install for the cline CLI tool";
};
mcp = {
nixos = {
enable = lib.mkEnableOption "enable NixOS MCP server for Claude Dev";
autoApprove = {
nixos_search = lib.mkEnableOption "should the nixos_search tool be auto approved for the nixos MCP server";
nixos_info = lib.mkEnableOption "should the nixos_info tool be auto approved for the nixos MCP server";
home_manager_search = lib.mkEnableOption "should the home_manager_search tool be auto approved for the nixos MCP server";
home_manager_info = lib.mkEnableOption "should the home_manager_info tool be auto approved for the nixos MCP server";
darwin_search = lib.mkEnableOption "should the darwin_search tool be auto approved for the nixos MCP server";
darwin_info = lib.mkEnableOption "should the darwin_info tool be auto approved for the nixos MCP server";
nixos_flakes_search = lib.mkEnableOption "should the nixos_flakes_search tool be auto approved for the nixos MCP server";
};
};
eslint = {
enable = lib.mkEnableOption "enable ESLint MCP server for Claude Dev";
package = lib.mkOption {
type = lib.types.str;
default = "@eslint/mcp@latest";
description = "NPM package to use for ESLint MCP server";
};
timeout = lib.mkOption {
type = lib.types.nullOr lib.types.int;
default = null;
description = "Timeout in seconds for ESLint MCP server operations";
};
autoApprove = {
lint-files = lib.mkEnableOption "Should the lint-files tool be auto approved for ESLint MCP server";
};
};
vitest = {
enable = lib.mkEnableOption "enable Vitest MCP server for Claude Dev";
package = lib.mkOption {
type = lib.types.str;
default = "@djankies/vitest-mcp";
description = "NPM package to use for Vitest MCP server";
};
timeout = lib.mkOption {
type = lib.types.nullOr lib.types.int;
default = null;
description = "Timeout in seconds for Vitest MCP server operations";
};
autoApprove = {
list_tests = lib.mkEnableOption "Should the list_tests tool be auto approved for Vitest MCP server";
run_tests = lib.mkEnableOption "Should the run_tests tool be auto approved for Vitest MCP server";
analyze_coverage = lib.mkEnableOption "Should the analyze_coverage tool be auto approved for Vitest MCP server";
set_project_root = lib.mkEnableOption "Should the set_project_root tool be auto approved for Vitest MCP server";
};
};
sleep = {
enable = lib.mkEnableOption "enable Sleep MCP server for Claude Dev";
package = lib.mkOption {
type = lib.types.str;
default = "sleep-mcp";
description = "NPM package to use for Sleep MCP server";
};
timeout = lib.mkOption {
type = lib.types.nullOr lib.types.int;
default = null;
description = "Timeout in seconds for Sleep MCP server operations";
};
autoApprove = {
sleep = lib.mkEnableOption "Should the sleep tool be auto approved for Sleep MCP server";
};
};
};
};
};
config = lib.mkIf config.extraExtensions.claudeDev.enable {
extensions = [
config.extraExtensions.claudeDev.extension
];
};
}));
};
config = lib.mkMerge [
(lib.mkIf anyProfileHasInstallTool {
home.packages = [
getInstallToolPackage
];
})
(lib.mkIf anyProfileHasMcpNixos {
home.packages = [
mcp-nixos
];
})
(lib.mkIf anyProfileHasMcp {
home.file."${config.xdg.configHome}/VSCodium/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json" = {
text = builtins.toJSON {
mcpServers =
(lib.optionalAttrs anyProfileHasMcpNixos {
nixos = {
command = "${mcp-nixos}/bin/mcp-nixos";
};
})
// (lib.optionalAttrs anyProfileHasMcpEslint {
eslint =
{
command = "${pkgs.nodejs}/bin/npx";
args = ["-y" (getMcpPackage "eslint")];
}
// (lib.optionalAttrs ((getMcpTimeout "eslint") != null) {
timeout = getMcpTimeout "eslint";
})
// (lib.optionalAttrs ((getMcpAutoApprove "eslint") != {}) {
autoApprove = builtins.attrNames (lib.filterAttrs (_: v: v) (getMcpAutoApprove "eslint"));
});
})
// (lib.optionalAttrs anyProfileHasMcpVitest {
vitest =
{
command = "${pkgs.nodejs}/bin/npx";
args = ["-y" (getMcpPackage "vitest")];
}
// (lib.optionalAttrs ((getMcpTimeout "vitest") != null) {
timeout = getMcpTimeout "vitest";
})
// (lib.optionalAttrs ((getMcpAutoApprove "vitest") != {}) {
autoApprove = builtins.attrNames (lib.filterAttrs (_: v: v) (getMcpAutoApprove "vitest"));
});
})
// (lib.optionalAttrs anyProfileHasMcpSleep {
sleep-mcp =
{
command = "${pkgs.nodejs}/bin/npx";
args = ["-y" (getMcpPackage "sleep")];
}
// (lib.optionalAttrs ((getMcpTimeout "sleep") != null) {
timeout = getMcpTimeout "sleep";
})
// (lib.optionalAttrs ((getMcpAutoApprove "sleep") != {}) {
autoApprove = builtins.attrNames (lib.filterAttrs (_: v: v) (getMcpAutoApprove "sleep"));
});
});
};
force = true;
};
})
];
}

40
legacy-modules/home-manager-modules/programs/vscode/conventionalCommits.nix Normal file
View file

@ -0,0 +1,40 @@
{
lib,
pkgs,
config,
...
}: let
pkgsRepositories = pkgs.nix-vscode-extensions.forVSCodeVersion config.programs.vscode.package.version;
pkgsRepository = pkgsRepositories.vscode-marketplace;
in {
options.programs.vscode.profiles = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule ({config, ...}: {
options = {
extraExtensions.conventionalCommits = {
enable = lib.mkEnableOption "Enable VSCode Conventional Commits extension";
extension = lib.mkPackageOption pkgsRepository "conventional-commits" {
default = ["vivaxy" "vscode-conventional-commits"];
};
gitmoji = lib.mkEnableOption "should emoji be prompted for as a part of the commit message./";
promptScopes = lib.mkEnableOption "prompting for scopes in conventional commits";
promptFooter = lib.mkEnableOption "prompting for footer in conventional commits";
showNewVersionNotes = lib.mkEnableOption "showing new version notes for conventional commits";
};
};
config = lib.mkIf config.extraExtensions.conventionalCommits.enable {
extensions = [config.extraExtensions.conventionalCommits.extension];
userSettings = {
"conventionalCommits.gitmoji" = config.extraExtensions.conventionalCommits.gitmoji;
"conventionalCommits.promptScopes" = config.extraExtensions.conventionalCommits.promptScopes;
"conventionalCommits.promptFooter" = config.extraExtensions.conventionalCommits.promptFooter;
"conventionalCommits.showNewVersionNotes" = config.extraExtensions.conventionalCommits.showNewVersionNotes;
};
};
}));
};
}

31
legacy-modules/home-manager-modules/programs/vscode/default.nix Normal file
View file

@ -0,0 +1,31 @@
{...}: {
imports = [
./oneDark.nix
./atomKeybindings.nix
./aiCode.nix
./alejandra.nix
./nixIde.nix
./autoRenameTag.nix
./es7ReactJsSnippets.nix
./liveServer.nix
./tauriVscode.nix
./vscodeEslint.nix
./vscodeJest.nix
./vscodeStandard.nix
./vscodeStylelint.nix
./go.nix
./evenBetterToml.nix
./openRemoteSsh.nix
./platformIO.nix
./rustAnalyzer.nix
./astroVscode.nix
./vscodeMdx.nix
./claudeDev.nix
./nearley.nix
./vitest.nix
./direnv.nix
./conventionalCommits.nix
./openDyslexicFont.nix
./graphql.nix
];
}

25
legacy-modules/home-manager-modules/programs/vscode/direnv.nix Normal file
View file

@ -0,0 +1,25 @@
{
lib,
pkgs,
config,
...
}: let
pkgsRepositories = pkgs.nix-vscode-extensions.forVSCodeVersion config.programs.vscode.package.version;
pkgsRepository = pkgsRepositories.vscode-marketplace;
in {
options.programs.vscode.profiles = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule ({config, ...}: {
options = {
extraExtensions.direnv = {
enable = lib.mkEnableOption "Enable direnv extension";
extension = lib.mkPackageOption pkgsRepository "direnv" {
default = ["mkhl" "direnv"];
};
};
};
config = lib.mkIf config.extraExtensions.direnv.enable {
extensions = [config.extraExtensions.direnv.extension];
};
}));
};
}

27
legacy-modules/home-manager-modules/programs/vscode/es7ReactJsSnippets.nix Normal file
View file

@ -0,0 +1,27 @@
{
lib,
pkgs,
config,
...
}: let
pkgsRepositories = pkgs.nix-vscode-extensions.forVSCodeVersion config.programs.vscode.package.version;
pkgsRepository = pkgsRepositories.open-vsx;
in {
options.programs.vscode.profiles = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule ({config, ...}: {
options = {
extraExtensions.es7ReactJsSnippets = {
enable = lib.mkEnableOption "should the es7-react-js-snippets extension for vscode be enabled";
extension = lib.mkPackageOption pkgsRepository "es7-react-js-snippets" {
default = ["dsznajder" "es7-react-js-snippets"];
};
};
};
config = lib.mkIf config.extraExtensions.es7ReactJsSnippets.enable {
extensions = [
config.extraExtensions.es7ReactJsSnippets.extension
];
};
}));
};
}

27
legacy-modules/home-manager-modules/programs/vscode/evenBetterToml.nix Normal file
View file

@ -0,0 +1,27 @@
{
lib,
pkgs,
config,
...
}: let
pkgsRepositories = pkgs.nix-vscode-extensions.forVSCodeVersion config.programs.vscode.package.version;
pkgsRepository = pkgsRepositories.open-vsx;
in {
options.programs.vscode.profiles = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule ({config, ...}: {
options = {
extraExtensions.evenBetterToml = {
enable = lib.mkEnableOption "should the even-better-toml extension for vscode be enabled";
extension = lib.mkPackageOption pkgsRepository "even-better-toml" {
default = ["tamasfe" "even-better-toml"];
};
};
};
config = lib.mkIf config.extraExtensions.evenBetterToml.enable {
extensions = [
config.extraExtensions.evenBetterToml.extension
];
};
}));
};
}

34
legacy-modules/home-manager-modules/programs/vscode/go.nix Normal file
View file

@ -0,0 +1,34 @@
{
lib,
pkgs,
config,
...
}: let
pkgsRepositories = pkgs.nix-vscode-extensions.forVSCodeVersion config.programs.vscode.package.version;
pkgsRepository = pkgsRepositories.open-vsx;
in {
options.programs.vscode.profiles = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule ({config, ...}: {
options = {
extraExtensions.go = {
enable = lib.mkEnableOption "should the go extension for vscode be enabled";
extension = lib.mkPackageOption pkgsRepository "go" {
default = ["golang" "go"];
};
};
};
config = lib.mkIf config.extraExtensions.go.enable {
extensions = [
config.extraExtensions.go.extension
];
userSettings = {
"go.alternateTools" = {
"gopls" = "gopls";
};
"go.toolsManagement.autoUpdate" = false;
"go.useLanguageServer" = true;
};
};
}));
};
}

27
legacy-modules/home-manager-modules/programs/vscode/graphql.nix Normal file
View file

@ -0,0 +1,27 @@
{
lib,
pkgs,
config,
...
}: let
pkgsRepositories = pkgs.nix-vscode-extensions.forVSCodeVersion config.programs.vscode.package.version;
pkgsRepository = pkgsRepositories.open-vsx;
in {
options.programs.vscode.profiles = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule ({config, ...}: {
options = {
extraExtensions.graphql = {
enable = lib.mkEnableOption "should the graphql highlighting extension for vscode be enabled";
extension = lib.mkPackageOption pkgsRepository "vscode-graphql" {
default = ["graphql" "vscode-graphql-syntax"];
};
};
};
config = lib.mkIf config.extraExtensions.graphql.enable {
extensions = [
config.extraExtensions.graphql.extension
];
};
}));
};
}

27
legacy-modules/home-manager-modules/programs/vscode/liveServer.nix Normal file
View file

@ -0,0 +1,27 @@
{
lib,
pkgs,
config,
...
}: let
pkgsRepositories = pkgs.nix-vscode-extensions.forVSCodeVersion config.programs.vscode.package.version;
pkgsRepository = pkgsRepositories.open-vsx;
in {
options.programs.vscode.profiles = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule ({config, ...}: {
options = {
extraExtensions.liveServer = {
enable = lib.mkEnableOption "should the live-server extension for vscode be enabled";
extension = lib.mkPackageOption pkgsRepository "live-server" {
default = ["ms-vscode" "live-server"];
};
};
};
config = lib.mkIf config.extraExtensions.liveServer.enable {
extensions = [
config.extraExtensions.liveServer.extension
];
};
}));
};
}

27
legacy-modules/home-manager-modules/programs/vscode/nearley.nix Normal file
View file

@ -0,0 +1,27 @@
{
lib,
pkgs,
config,
...
}: let
pkgsRepositories = pkgs.nix-vscode-extensions.forVSCodeVersion config.programs.vscode.package.version;
pkgsRepository = pkgsRepositories.vscode-marketplace;
in {
options.programs.vscode.profiles = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule ({config, ...}: {
options = {
extraExtensions.nearley = {
enable = lib.mkEnableOption "should the nearley extension for vscode be enabled";
extension = lib.mkPackageOption pkgsRepository "nearley" {
default = ["karyfoundation" "nearley"];
};
};
};
config = lib.mkIf config.extraExtensions.nearley.enable {
extensions = [
config.extraExtensions.nearley.extension
];
};
}));
};
}

29
legacy-modules/home-manager-modules/programs/vscode/nixIde.nix Normal file
View file

@ -0,0 +1,29 @@
{
lib,
pkgs,
config,
...
}: let
pkgsRepositories = pkgs.nix-vscode-extensions.forVSCodeVersion config.programs.vscode.package.version;
pkgsRepository = pkgsRepositories.open-vsx;
in {
options.programs.vscode.profiles = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule ({config, ...}: {
options = {
extraExtensions.nixIde = {
enable = lib.mkEnableOption "Enable Nix IDE extension";
extension = lib.mkPackageOption pkgsRepository "nix-ide" {
default = ["jnoortheen" "nix-ide"];
};
};
};
config = lib.mkIf config.extraExtensions.nixIde.enable {
extensions = [config.extraExtensions.nixIde.extension];
userSettings = {
"nix.enableLanguageServer" = true;
"nix.serverPath" = "nil";
};
};
}));
};
}

30
legacy-modules/home-manager-modules/programs/vscode/oneDark.nix Normal file
View file

@ -0,0 +1,30 @@
{
lib,
pkgs,
config,
...
}: let
pkgsRepositories = pkgs.nix-vscode-extensions.forVSCodeVersion config.programs.vscode.package.version;
pkgsRepository = pkgsRepositories.open-vsx;
in {
options.programs.vscode.profiles = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule ({config, ...}: {
options = {
extraExtensions.oneDark = {
enable = lib.mkEnableOption "should the one dark theme for vscode be enabled";
extension = lib.mkPackageOption pkgsRepository "onedark" {
default = ["akamud" "vscode-theme-onedark"];
};
};
};
config = lib.mkIf config.extraExtensions.oneDark.enable {
extensions = [
config.extraExtensions.oneDark.extension
];
userSettings = {
"workbench.colorTheme" = "Atom One Dark";
};
};
}));
};
}

49
legacy-modules/home-manager-modules/programs/vscode/openDyslexicFont.nix Normal file
View file

@ -0,0 +1,49 @@
{
lib,
pkgs,
config,
...
}: {
options.programs.vscode.profiles = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule ({config, ...}: {
options = {
extraExtensions.openDyslexicFont = {
enable = lib.mkEnableOption "should OpenDyslexic font be set as the default font for VSCode";
package = lib.mkPackageOption pkgs "nerd-fonts.open-dyslexic" {
default = ["nerd-fonts" "open-dyslexic"];
};
};
};
config = lib.mkIf config.extraExtensions.openDyslexicFont.enable {
userSettings = {
"editor.fontFamily" = "'OpenDyslexicM Nerd Font Mono', Droid Sans Mono, monospace";
"editor.fontSize" = 14;
"editor.letterSpacing" = -0.3;
};
};
}));
};
config = let
enabledProfiles =
lib.filter (profile: profile.extraExtensions.openDyslexicFont.enable or false)
(lib.attrValues config.programs.vscode.profiles);
anyProfileUsesOpenDyslexicFont = enabledProfiles != [];
fontPackages = lib.unique (map (profile: profile.extraExtensions.openDyslexicFont.package) enabledProfiles);
in {
# Ensure OpenDyslexic font packages are installed when any VSCode profile uses them
home.packages = fontPackages;
fonts.fontconfig.enable = lib.mkIf anyProfileUsesOpenDyslexicFont true;
# Add assertion to ensure the fonts are available
assertions =
map (fontPkg: {
assertion = lib.elem fontPkg config.home.packages;
message = "OpenDyslexic font package '${fontPkg.name or "unknown"}' must be installed when using openDyslexicFont extension for VSCode.";
})
fontPackages;
};
}

27
legacy-modules/home-manager-modules/programs/vscode/openRemoteSsh.nix Normal file
View file

@ -0,0 +1,27 @@
{
lib,
pkgs,
config,
...
}: let
pkgsRepositories = pkgs.nix-vscode-extensions.forVSCodeVersion config.programs.vscode.package.version;
pkgsRepository = pkgsRepositories.open-vsx;
in {
options.programs.vscode.profiles = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule ({config, ...}: {
options = {
extraExtensions.openRemoteSsh = {
enable = lib.mkEnableOption "should the open-remote-ssh extension for vscode be enabled";
extension = lib.mkPackageOption pkgsRepository "open-remote-ssh" {
default = ["jeanp413" "open-remote-ssh"];
};
};
};
config = lib.mkIf config.extraExtensions.openRemoteSsh.enable {
extensions = [
config.extraExtensions.openRemoteSsh.extension
];
};
}));
};
}

30
legacy-modules/home-manager-modules/programs/vscode/platformIO.nix Normal file
View file

@ -0,0 +1,30 @@
{
lib,
pkgs,
config,
...
}: let
pkgsRepositories = pkgs.nix-vscode-extensions.forVSCodeVersion config.programs.vscode.package.version;
pkgsRepository = pkgsRepositories.open-vsx;
in {
options.programs.vscode.profiles = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule ({config, ...}: {
options = {
extraExtensions.platformIO = {
enable = lib.mkEnableOption "should the platformIO extension for vscode be enabled";
extension = lib.mkPackageOption pkgsRepository "platformIO" {
default = ["pioarduino" "pioarduino-ide"];
};
};
};
config = lib.mkIf config.extraExtensions.platformIO.enable {
extensions = [
config.extraExtensions.platformIO.extension
];
userSettings = {
"platformio-ide.useBuiltinPIOCore" = false;
};
};
}));
};
}

27
legacy-modules/home-manager-modules/programs/vscode/rustAnalyzer.nix Normal file
View file

@ -0,0 +1,27 @@
{
lib,
pkgs,
config,
...
}: let
pkgsRepositories = pkgs.nix-vscode-extensions.forVSCodeVersion config.programs.vscode.package.version;
pkgsRepository = pkgsRepositories.open-vsx;
in {
options.programs.vscode.profiles = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule ({config, ...}: {
options = {
extraExtensions.rustAnalyzer = {
enable = lib.mkEnableOption "should the rust-analyzer extension for vscode be enabled";
extension = lib.mkPackageOption pkgsRepository "rust-analyzer" {
default = ["rust-lang" "rust-analyzer"];
};
};
};
config = lib.mkIf config.extraExtensions.rustAnalyzer.enable {
extensions = [
config.extraExtensions.rustAnalyzer.extension
];
};
}));
};
}

27
legacy-modules/home-manager-modules/programs/vscode/tauriVscode.nix Normal file
View file

@ -0,0 +1,27 @@
{
lib,
pkgs,
config,
...
}: let
pkgsRepositories = pkgs.nix-vscode-extensions.forVSCodeVersion config.programs.vscode.package.version;
pkgsRepository = pkgsRepositories.open-vsx;
in {
options.programs.vscode.profiles = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule ({config, ...}: {
options = {
extraExtensions.tauriVscode = {
enable = lib.mkEnableOption "should the tauri-vscode extension for vscode be enabled";
extension = lib.mkPackageOption pkgsRepository "tauri-vscode" {
default = ["tauri-apps" "tauri-vscode"];
};
};
};
config = lib.mkIf config.extraExtensions.tauriVscode.enable {
extensions = [
config.extraExtensions.tauriVscode.extension
];
};
}));
};
}

27
legacy-modules/home-manager-modules/programs/vscode/vitest.nix Normal file
View file

@ -0,0 +1,27 @@
{
lib,
pkgs,
config,
...
}: let
pkgsRepositories = pkgs.nix-vscode-extensions.forVSCodeVersion config.programs.vscode.package.version;
pkgsRepository = pkgsRepositories.open-vsx;
in {
options.programs.vscode.profiles = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule ({config, ...}: {
options = {
extraExtensions.vitest = {
enable = lib.mkEnableOption "should the vitest extension for vscode be enabled";
extension = lib.mkPackageOption pkgsRepository "vitest" {
default = ["vitest" "explorer"];
};
};
};
config = lib.mkIf config.extraExtensions.vitest.enable {
extensions = [
config.extraExtensions.vitest.extension
];
};
}));
};
}

27
legacy-modules/home-manager-modules/programs/vscode/vscodeEslint.nix Normal file
View file

@ -0,0 +1,27 @@
{
lib,
pkgs,
config,
...
}: let
pkgsRepositories = pkgs.nix-vscode-extensions.forVSCodeVersion config.programs.vscode.package.version;
pkgsRepository = pkgsRepositories.open-vsx;
in {
options.programs.vscode.profiles = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule ({config, ...}: {
options = {
extraExtensions.vscodeEslint = {
enable = lib.mkEnableOption "should the vscode-eslint extension for vscode be enabled";
extension = lib.mkPackageOption pkgsRepository "vscode-eslint" {
default = ["dbaeumer" "vscode-eslint"];
};
};
};
config = lib.mkIf config.extraExtensions.vscodeEslint.enable {
extensions = [
config.extraExtensions.vscodeEslint.extension
];
};
}));
};
}

27
legacy-modules/home-manager-modules/programs/vscode/vscodeJest.nix Normal file
View file

@ -0,0 +1,27 @@
{
lib,
pkgs,
config,
...
}: let
pkgsRepositories = pkgs.nix-vscode-extensions.forVSCodeVersion config.programs.vscode.package.version;
pkgsRepository = pkgsRepositories.open-vsx;
in {
options.programs.vscode.profiles = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule ({config, ...}: {
options = {
extraExtensions.vscodeJest = {
enable = lib.mkEnableOption "should the vscode-jest extension for vscode be enabled";
extension = lib.mkPackageOption pkgsRepository "vscode-jest" {
default = ["orta" "vscode-jest"];
};
};
};
config = lib.mkIf config.extraExtensions.vscodeJest.enable {
extensions = [
config.extraExtensions.vscodeJest.extension
];
};
}));
};
}

27
legacy-modules/home-manager-modules/programs/vscode/vscodeMdx.nix Normal file
View file

@ -0,0 +1,27 @@
{
lib,
pkgs,
config,
...
}: let
pkgsRepositories = pkgs.nix-vscode-extensions.forVSCodeVersion config.programs.vscode.package.version;
pkgsRepository = pkgsRepositories.open-vsx;
in {
options.programs.vscode.profiles = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule ({config, ...}: {
options = {
extraExtensions.vscodeMdx = {
enable = lib.mkEnableOption "should the vscode-mdx extension for vscode be enabled";
extension = lib.mkPackageOption pkgsRepository "vscode-mdx" {
default = ["unifiedjs" "vscode-mdx"];
};
};
};
config = lib.mkIf config.extraExtensions.vscodeMdx.enable {
extensions = [
config.extraExtensions.vscodeMdx.extension
];
};
}));
};
}

27
legacy-modules/home-manager-modules/programs/vscode/vscodeStandard.nix Normal file
View file

@ -0,0 +1,27 @@
{
lib,
pkgs,
config,
...
}: let
pkgsRepositories = pkgs.nix-vscode-extensions.forVSCodeVersion config.programs.vscode.package.version;
pkgsRepository = pkgsRepositories.open-vsx;
in {
options.programs.vscode.profiles = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule ({config, ...}: {
options = {
extraExtensions.vscodeStandard = {
enable = lib.mkEnableOption "should the vscode-standard extension for vscode be enabled";
extension = lib.mkPackageOption pkgsRepository "vscode-standard" {
default = ["standard" "vscode-standard"];
};
};
};
config = lib.mkIf config.extraExtensions.vscodeStandard.enable {
extensions = [
config.extraExtensions.vscodeStandard.extension
];
};
}));
};
}

27
legacy-modules/home-manager-modules/programs/vscode/vscodeStylelint.nix Normal file
View file

@ -0,0 +1,27 @@
{
lib,
pkgs,
config,
...
}: let
pkgsRepositories = pkgs.nix-vscode-extensions.forVSCodeVersion config.programs.vscode.package.version;
pkgsRepository = pkgsRepositories.open-vsx;
in {
options.programs.vscode.profiles = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule ({config, ...}: {
options = {
extraExtensions.vscodeStylelint = {
enable = lib.mkEnableOption "should the vscode-stylelint extension for vscode be enabled";
extension = lib.mkPackageOption pkgsRepository "vscode-stylelint" {
default = ["stylelint" "vscode-stylelint"];
};
};
};
config = lib.mkIf config.extraExtensions.vscodeStylelint.enable {
extensions = [
config.extraExtensions.vscodeStylelint.extension
];
};
}));
};
}