bugfix(roslyn/angular): Fix lsp setup

Author: DashieTM

config/languages/lsp.nix

@@ -5,7 +5,33 @@
   mkDashDefault,
   ...
 }: let
+  toolchain = import ../../lib/toolchain.nix {inherit lib pkgs;};
   pinnedTsserverPath = "${pkgs.typescript}/lib/node_modules/typescript/lib/tsserver.js";
+  angularLanguageServiceRoot = "${pkgs.angular-language-server}/lib";
+  angularLanguageServerCommand =
+    if config'.toolchain.preferProjectTools or false
+    then toolchain.bin "ngserver"
+    else "${pkgs.angular-language-server}/bin/ngserver";
+  typescriptRoot = "${pkgs.typescript}/lib";
+  typescriptToolsWithAngular = pkgs.vimPlugins.typescript-tools-nvim.overrideAttrs (old: {
+    postPatch =
+      (old.postPatch or "")
+      + ''
+        substituteInPlace lua/typescript-tools/process.lua \
+          --replace-fail '  local plugins_path = tsserver_provider:get_plugins_path()' '  local plugins_path = tsserver_provider:get_plugins_path()
+          local plugin_probe_locations = {}
+          if tsserver_provider.npm_local_path and tsserver_provider.npm_local_path:exists() then
+            table.insert(plugin_probe_locations, tsserver_provider.npm_local_path:absolute())
+          end
+          table.insert(plugin_probe_locations, "${angularLanguageServiceRoot}")' \
+          --replace-fail '  if plugins_path and #plugin_config.tsserver_plugins > 0 then' '  if plugins_path then
+            table.insert(plugin_probe_locations, plugins_path:absolute())
+          end
+
+          if #plugin_config.tsserver_plugins > 0 then' \
+          --replace-fail '    table.insert(self.args, plugins_path:absolute())' '    table.insert(self.args, table.concat(plugin_probe_locations, ","))'
+      '';
+  });
   projectTsserverPath =
     lib.generators.mkLuaInline
     /*
@@ -40,7 +66,7 @@ in {
         package = ng-nvim;
       };
       "typescript-tools.nvim" = mkDashDefault {
-        package = typescript-tools-nvim;
+        package = typescriptToolsWithAngular;
         setupModule = "typescript-tools";
         event = [
           {
@@ -49,16 +75,42 @@ in {
           }
           {
             event = "FileType";
-            pattern = "html";
+            pattern = "typescriptreact";
           }
           {
             event = "FileType";
-            pattern = "htmlangular";
+            pattern = "javascript";
+          }
+          {
+            event = "FileType";
+            pattern = "javascriptreact";
           }
         ];
         setupOpts = {
+          on_attach =
+            lib.generators.mkLuaInline
+            /*
+            lua
+            */
+            ''
+              function(client, bufnr)
+                local bufname = vim.api.nvim_buf_get_name(bufnr)
+                if bufname == nil or bufname == "" then
+                  return
+                end
+
+                local angular_root = vim.fs.find({ "angular.json", "nx.json" }, {
+                  path = vim.fs.dirname(bufname),
+                  upward = true,
+                })[1]
+
+                if angular_root ~= nil then
+                  client.server_capabilities.referencesProvider = false
+                end
+              end
+            '';
           settings = {
-            seperate_diagnostic_server = true;
+            separate_diagnostic_server = true;
             expose_as_code_action = [
               "fix_all"
               "add_missing_imports"
@@ -92,15 +144,14 @@ in {
         setupOpts = {
           # Search parent directories for solution files, not just cwd.
           # Fixes "LSP not attaching" when the .sln is above the opened file.
-          broad_search = true;
+          broad_search = config'.lsp.special.roslyn.broadSearch;
 
           # Once a solution is selected, lock it so re-opening files doesn't
           # trigger re-selection or re-initialization (avoids needing restarts).
-          lock_target = true;
+          lock_target = config'.lsp.special.roslyn.lockTarget;
 
-          # Let roslyn own file watching instead of neovim competing with it.
-          # Switch to "off" if you notice performance issues.
-          filewatching = "roslyn";
+          # Roslyn's built-in watcher can consume huge inotify counts on large repos.
+          filewatching = config'.lsp.special.roslyn.filewatching;
         };
       };
     };
@@ -122,27 +173,107 @@ in {
           cmd = ["${pkgs.vscode-langservers-extracted}/bin/vscode-json-language-server" "--stdio"];
           filetypes = ["json" "jsonc"];
         };
-        angular = mkDashDefault {
-          enable = true;
-          cmd = ["${pkgs.angular-language-server}/bin/ngserver" "--stdio"];
-          filetypes = ["htmlangular" "typescript" "html"];
-          root_markers = [".git" "package.json"];
-          on_attach =
-            lib.generators.mkLuaInline
+        angular = {
+          enable = mkDashDefault true;
+          cmd = lib.mkOverride 80 (lib.generators.mkLuaInline
+            /*
+            lua
+            */
+            ''
+              function(dispatchers, config)
+                local root_dir = (config and config.root_dir) or vim.fn.getcwd()
+                local probe_locations = {}
+                local seen = {}
+
+                local function add_probe(path)
+                  if path ~= nil and path ~= "" and not seen[path] and vim.uv.fs_stat(path) then
+                    seen[path] = true
+                    table.insert(probe_locations, path)
+                  end
+                end
+
+                local project_node_modules = vim.fs.find("node_modules", {
+                  path = root_dir,
+                  upward = true,
+                  type = "directory",
+                })[1]
+
+                add_probe(project_node_modules)
+                add_probe("${angularLanguageServiceRoot}")
+                add_probe("${typescriptRoot}")
+
+                local function angular_core_version()
+                  local package_json = vim.fs.find("package.json", {
+                    path = root_dir,
+                    upward = true,
+                    type = "file",
+                  })[1]
+
+                  if package_json == nil then
+                    return ""
+                  end
+
+                  local ok, content = pcall(vim.fn.readfile, package_json)
+                  if not ok then
+                    return ""
+                  end
+
+                  local parsed_ok, package = pcall(vim.json.decode, table.concat(content, "\n"))
+                  if not parsed_ok or type(package) ~= "table" then
+                    return ""
+                  end
+
+                  local version = (package.dependencies or {})["@angular/core"] or (package.devDependencies or {})["@angular/core"] or ""
+                  return version:match("%d+%.%d+%.%d+") or ""
+                end
+
+                return vim.lsp.rpc.start({
+                  "${angularLanguageServerCommand}",
+                  "--stdio",
+                  "--tsProbeLocations",
+                  table.concat(probe_locations, ","),
+                  "--ngProbeLocations",
+                  table.concat(probe_locations, ","),
+                  "--angularCoreVersion",
+                  angular_core_version(),
+                }, dispatchers)
+              end
+            '');
+          filetypes = mkDashDefault ["htmlangular" "typescript" "typescriptreact"];
+          root_markers = mkDashDefault ["angular.json" "nx.json"];
+          on_attach = mkDashDefault (lib.generators.mkLuaInline
             /*
             lua
             */
             ''
               function(client, bufnr)
-                -- This shit is the most annoying thing ever
-                client.server_capabilities.insertReplaceSupport = false
-                client.server_capabilities.renameProvider = false
-                client.server_capabilities.referencesProvider = false
                 client.server_capabilities.documentFormattingProvider = false
                 client.server_capabilities.documentRangeFormattingProvider = false
                 client.server_capabilities.documentOnTypeFormattingProvider = false
+
+                local ft = vim.bo[bufnr].filetype
+                if ft == "typescript" or ft == "typescriptreact" then
+                  client.server_capabilities.callHierarchyProvider = false
+                  client.server_capabilities.codeActionProvider = false
+                  client.server_capabilities.completionProvider = false
+                  client.server_capabilities.declarationProvider = false
+                  client.server_capabilities.definitionProvider = false
+                  client.server_capabilities.diagnosticProvider = false
+                  client.server_capabilities.documentHighlightProvider = false
+                  client.server_capabilities.documentLinkProvider = false
+                  client.server_capabilities.documentSymbolProvider = false
+                  client.server_capabilities.hoverProvider = false
+                  client.server_capabilities.implementationProvider = false
+                  client.server_capabilities.inlayHintProvider = false
+                  client.server_capabilities.renameProvider = false
+                  client.server_capabilities.selectionRangeProvider = false
+                  client.server_capabilities.semanticTokensProvider = false
+                  client.server_capabilities.signatureHelpProvider = false
+                  client.server_capabilities.typeDefinitionProvider = false
+                  client.handlers["textDocument/publishDiagnostics"] = function() end
+                end
               end
-            '';
+            '');
         };
         # csharp = mkDashDefault {
         #   enable = true;
@@ -189,5 +320,88 @@ in {
     languages =
       config'.lsp.lspServers
       // config'.lsp.additionalConfig;
+    luaConfigRC.dashvim-roslyn-file-change-notifications = lib.nvim.dag.entryAfter ["lsp-servers"] ''
+      local dashvim_roslyn_group = vim.api.nvim_create_augroup("DashVimRoslynFileChanges", { clear = true })
+      local dashvim_roslyn_patterns = { "*.cs", "*.csproj", "*.sln", "*.slnx", "*.slnf", "*.props", "*.targets" }
+      local dashvim_roslyn_extensions = {
+        cs = true,
+        csproj = true,
+        sln = true,
+        slnx = true,
+        slnf = true,
+        props = true,
+        targets = true,
+      }
+
+      local function dashvim_roslyn_is_project_file(path)
+        return dashvim_roslyn_extensions[vim.fn.fnamemodify(path, ":e")] == true
+      end
+
+      local function dashvim_roslyn_path_in_root(path, root)
+        if root == nil or root == "" then
+          return true
+        end
+
+        local normalized_path = vim.fs.normalize(path)
+        local normalized_root = vim.fs.normalize(root)
+        return normalized_root == "/" or normalized_path == normalized_root or vim.startswith(normalized_path, normalized_root .. "/")
+      end
+
+      local function dashvim_roslyn_notify_file_change(path, change_type)
+        for _, client in ipairs(vim.lsp.get_clients({ name = "roslyn" })) do
+          if dashvim_roslyn_path_in_root(path, client.config.root_dir) then
+            client:notify("workspace/didChangeWatchedFiles", {
+              changes = {
+                {
+                  uri = vim.uri_from_fname(path),
+                  type = change_type,
+                },
+              },
+            })
+          end
+        end
+      end
+
+      vim.api.nvim_create_autocmd("BufWritePre", {
+        group = dashvim_roslyn_group,
+        pattern = dashvim_roslyn_patterns,
+        callback = function(args)
+          local path = vim.api.nvim_buf_get_name(args.buf)
+          vim.b[args.buf].dashvim_roslyn_file_existed = path ~= "" and vim.uv.fs_stat(path) ~= nil
+        end,
+      })
+
+      vim.api.nvim_create_autocmd("BufWritePost", {
+        group = dashvim_roslyn_group,
+        pattern = dashvim_roslyn_patterns,
+        callback = function(args)
+          local path = vim.api.nvim_buf_get_name(args.buf)
+          if path == "" then
+            return
+          end
+
+          local existed = vim.b[args.buf].dashvim_roslyn_file_existed
+          vim.b[args.buf].dashvim_roslyn_file_existed = true
+          dashvim_roslyn_notify_file_change(path, existed == false and 1 or 2)
+        end,
+      })
+
+      vim.api.nvim_create_autocmd("LspAttach", {
+        group = dashvim_roslyn_group,
+        callback = function(args)
+          local client = vim.lsp.get_client_by_id(args.data.client_id)
+          if client == nil or client.name ~= "roslyn" then
+            return
+          end
+
+          local path = vim.api.nvim_buf_get_name(args.buf)
+          if path == "" or not dashvim_roslyn_is_project_file(path) then
+            return
+          end
+
+          dashvim_roslyn_notify_file_change(path, 2)
+        end,
+      })
+    '';
   };
 }

docs/ARCHITECTURE.md

@@ -9,6 +9,7 @@ DashVim is a Nix flake that builds and distributes a Neovim configuration based
 - `lib/default.nix` calls `inputs.nvf.lib.neovimConfiguration` and passes DashVim options into the `config/` module tree through `extraSpecialArgs`.
 - `config/default.nix` imports the Neovim configuration modules for base settings, theme, keybinds, editor features, language support, custom config, and user-provided `additionalConfig`.
 - `config/languages/toolchain.nix` injects project-aware command resolvers for known DashVim/nvf LSPs, formatters, and linters when `programs.dashvim.toolchain.preferProjectTools` is enabled; `config/languages/lsp.nix` handles the TypeScript server path special case inside the owning plugin definition.
+- `config/languages/lsp.nix` also owns plugin-backed LSP setup such as `typescript-tools.nvim` and `roslyn.nvim`; Roslyn file watching, targeted file-change notifications, broad solution search, and target locking are controlled through `programs.dashvim.lsp.special.roslyn.*`.
 - `lib/env.nix` creates the runnable environment by combining the generated Neovim package, optional wrapped opencode package, and shared CLI/runtime dependencies.
 - `lib/opencode-config.nix` generates opencode theme, TUI config, opencode config JSON, and bundled skills/commands for both wrapped opencode and Home Manager deployments.
 - `lib/toolchain.nix` builds a Rust resolver and per-tool launch symlinks that prefer a different executable from the active Neovim `PATH` and fall back to DashVim's pinned Nix executable.
@@ -21,7 +22,8 @@ DashVim is a Nix flake that builds and distributes a Neovim configuration based
 - Users set `programs.dashvim.*` options through the exported module.
 - Module options flow into `lib/default.nix` as `config'` and become inputs to the `config/` nvf module tree.
 - The nvf output creates the Neovim package used by `lib/env.nix` and `lib/mkPkg.nix`.
-- Toolchain preferences flow from `programs.dashvim.toolchain.preferProjectTools` into `config/languages/toolchain.nix`, which overrides active LSP commands and known formatter/linter commands with resolver scripts at Nix module priority 90. TypeScript's `tsserver_path` is resolved in `config/languages/lsp.nix` so the lazy plugin package metadata remains intact.
+- Toolchain preferences flow from `programs.dashvim.toolchain.preferProjectTools` into `config/languages/toolchain.nix`, which overrides active LSP commands and known formatter/linter commands with resolver scripts at Nix module priority 90. TypeScript's `tsserver_path` is resolved in `config/languages/lsp.nix` so the lazy plugin package metadata remains intact. Angular TypeScript support is loaded as the `@angular/language-service` tsserver plugin through `typescript-tools.nvim`; standalone Angular LS is reserved for Angular template buffers.
+- Roslyn preferences flow from `programs.dashvim.lsp.special.roslyn` into `roslyn.nvim` setup options. The default keeps recursive file watching `"off"` so Roslyn and Neovim do not create broad watchers, and DashVim sends targeted `workspace/didChangeWatchedFiles` notifications when C# project files are saved. Users can opt into `"auto"` or `"roslyn"` only when full external file watching is more important than watcher safety.
 - Shared dependencies are collected in `lib/dependencies.nix` and reused by flake packages and Home Manager integration.
 - Opencode theme generation uses the configured Base16 colorscheme and optional accent color, then writes generated JSON files through `lib/opencode-config.nix`.
 
@@ -33,10 +35,12 @@ DashVim is a Nix flake that builds and distributes a Neovim configuration based
 - Base16 color contract: UI themes and opencode colors derive from a Base16-compatible palette, with `accentColor` overriding `base0D` when set.
 - Global agent instructions: `AGENTS.md` is included in root opencode config, the wrapped opencode instruction paths, and Home Manager deployed opencode instructions. It requires architecture, UI, code guidelines, technical debt, and testing docs to stay current.
 - Project tool preference is enabled by default: known LSPs, formatters, and linters first look for a project/shell executable that differs from DashVim's pinned fallback, preserving reproducibility when a project does not provide a tool.
+- Angular language ownership is split to avoid duplicate TypeScript LSP results: `typescript-tools.nvim` owns JavaScript/TypeScript buffers and loads Angular's tsserver plugin, while standalone `ngserver` owns `htmlangular` buffers and TypeScript references in Angular projects so references include external templates.
 
 ## Tradeoffs
 
 - Generated opencode configs are reproducible, but users must rebuild or redeploy after changing generated inputs.
 - `programs.dashvim.opencode.config` can override generated opencode config keys, which is flexible but can replace defaults like `instructions` if users set the same key.
 - The module surface is broad and convenient, but changes to defaults can affect many language/editor features at once.
 - Project-aware tool resolution depends on Neovim seeing the project shell `PATH` before tools start. LSPs may need restart after entering a shell late.
+- Recursive Roslyn file watching may consume significant inotify resources or watch too high a directory such as a home folder. DashVim avoids that by default, but files created outside Neovim may still require opening/saving the file or restarting the LSP before Roslyn refreshes project state.

docs/CODE_GUIDELINES.md

@@ -16,6 +16,7 @@
 - Keep Docker/container support Nix-generated unless a Dockerfile already exists or explicit instructions say not to use Nix.
 - Use `alejandra` for Nix formatting, available as the flake `format` package.
 - Keep project tool resolver runtime logic in tracked Rust source under `lib/toolchain/`; Nix should wire package metadata and generated launchers, not embed large resolver programs in strings.
+- Keep plugin-backed LSP behavior with large runtime tradeoffs configurable under `programs.dashvim.lsp.special.*` instead of hard-coding environment-specific defaults.
 
 ## Testing And Verification
 

docs/TECHNICAL_DEBT.md

@@ -10,6 +10,8 @@ This file tracks known issues, limitations, deferred work, and cleanup items tha
 - The `programs.dashvim` option surface is broad. Default changes can affect many editor, language, formatter, and opencode behaviors at once.
 - Automated testing is currently Nix-focused. No separate unit/integration test suite is documented for Lua plugin behavior or interactive Neovim workflows.
 - `programs.dashvim.toolchain.preferProjectTools` covers known DashVim/nvf LSP, formatter, and linter names. Custom direct `vim.lsp.servers`, conform formatter, or nvim-lint linter names still need explicit command configuration until a public extension map exists.
+- `programs.dashvim.lsp.special.roslyn.filewatching` defaults to `"off"` to prevent Roslyn or Neovim from recursively watching too much of the filesystem. DashVim sends targeted `workspace/didChangeWatchedFiles` notifications for saved C# project files, but files created outside Neovim may still require opening/saving the file or restarting the LSP before Roslyn refreshes project state.
+- `typescript-tools.nvim` does not expose a first-class plugin probe path option, so DashVim patches its generated process arguments to make Nix-provided `@angular/language-service` discoverable by tsserver. Revisit this if upstream adds `tsserver_plugin_probe_locations` or equivalent.
 
 ## Maintenance Rules