refactor: address PR review — auto-install tsgo via npm, merge tests into existing suite

- Replace shutil.which() lookup with npm-based auto-install pattern
  (using RuntimeDependencyCollection like typescript_language_server)
- Remove standalone test_typescript_tsgo.py; parametrize existing
  typescript tests with TYPESCRIPT_TSGO (always in CI via is_ci)
- Add tsgo installation step to pytest CI workflow
- Update docs to reflect automatic installation

Author: extern.shiji.yan

.github/workflows/pytest.yml

@@ -399,6 +399,10 @@ jobs:
         uses: krdlab/setup-haxe@v2
         with:
           haxe-version: 4.3.7
+      - name: Install tsgo (TypeScript native LSP)
+        shell: bash
+        run: npm install -g @typescript/native-preview
+
       - name: Install Elm
         shell: bash
         run: npm install -g elm@0.19.1-6

docs/01-about/020_programming-languages.md

@@ -113,7 +113,7 @@ Some languages require additional installations or setup steps, as noted.
 * **Swift**
 * **TypeScript**
   (by default, uses [typescript-language-server](https://github.com/typescript-language-server/typescript-language-server) (language `typescript`);
-  we also support [tsgo](https://github.com/nicolo-ribaudo/tc39-proposal-type-annotations) (language `typescript_tsgo`), the native Go-based TypeScript 7 compiler with built-in LSP — does not require Node.js, must be installed separately via `npm install -g @typescript/native-preview`)
+  alternatively supports [tsgo](https://github.com/nicolo-ribaudo/tc39-proposal-type-annotations) (language `typescript_tsgo`), the native Go-based TypeScript 7 compiler with built-in LSP — automatically installed via npm)
 * **Vue**
   (3.x with TypeScript; requires Node.js v18+ and npm; supports .vue Single File Components with monorepo detection)
 * **YAML**

src/solidlsp/language_servers/tsgo_language_server.py

@@ -10,16 +10,18 @@
 import logging
 import os
 import pathlib
-import subprocess
+import shutil
 from typing import cast
 
 from overrides import override
+from sensai.util.logging import LogTime
 
 from solidlsp.ls import LanguageServerDependencyProviderSinglePath, SolidLanguageServer
 from solidlsp.ls_config import LanguageServerConfig
 from solidlsp.lsp_protocol_handler.lsp_types import InitializeParams
 from solidlsp.settings import SolidLSPSettings
 
+from .common import RuntimeDependency, RuntimeDependencyCollection, build_npm_install_command
 from .typescript_language_server import prefer_non_node_modules_definition
 
 log = logging.getLogger(__name__)
@@ -29,11 +31,11 @@ class TsgoLanguageServer(SolidLanguageServer):
     """
     TypeScript support via tsgo — the native Go-based TypeScript 7 compiler with built-in LSP.
 
-    tsgo does not require Node.js. It must be installed separately
-    (e.g. via ``npm install -g @typescript/native-preview``).
+    tsgo is installed automatically via npm (``@typescript/native-preview``).
+    It does not require the traditional typescript-language-server wrapper.
 
     You can pass the following entries in ls_specific_settings["typescript_tsgo"]:
-        - ls_path: Path to the tsgo binary (default: discovered from PATH)
+        - tsgo_version: Version of @typescript/native-preview to install (default: "7.0.0-dev.20250601")
     """
 
     @override
@@ -49,29 +51,58 @@ def is_ignored_dirname(self, dirname: str) -> bool:
 
     class DependencyProvider(LanguageServerDependencyProviderSinglePath):
         def _get_or_install_core_dependency(self) -> str:
-            """Locate the tsgo binary on the system. tsgo must be pre-installed by the user."""
-            import shutil
-
-            tsgo_path = shutil.which("tsgo")
-            if tsgo_path is None:
-                raise RuntimeError(
-                    "tsgo is not installed or not found in PATH.\n"
-                    "Install it via: npm install -g @typescript/native-preview\n"
-                    "Or set the 'ls_path' option in ls_specific_settings['typescript_tsgo'] "
-                    "to point to your tsgo binary."
-                )
-
-            # Verify it works
-            try:
-                result = subprocess.run([tsgo_path, "--version"], capture_output=True, text=True, check=False, timeout=10)
-                if result.returncode == 0:
-                    log.info(f"Found tsgo: {result.stdout.strip()}")
-                else:
-                    log.warning(f"tsgo --version returned non-zero exit code: {result.returncode}")
-            except (FileNotFoundError, subprocess.TimeoutExpired) as e:
-                raise RuntimeError(f"Failed to verify tsgo binary at {tsgo_path}: {e}") from e
-
-            return tsgo_path
+            """Install @typescript/native-preview via npm and return the path to the tsgo executable."""
+            language_specific_config = self._custom_settings
+            tsgo_version = language_specific_config.get("tsgo_version", "7.0.0-dev.20250601")
+            npm_registry = language_specific_config.get("npm_registry")
+
+            deps = RuntimeDependencyCollection(
+                [
+                    RuntimeDependency(
+                        id="typescript-native-preview",
+                        description="@typescript/native-preview (tsgo) package",
+                        command=build_npm_install_command("@typescript/native-preview", tsgo_version, npm_registry),
+                        platform_id="any",
+                    ),
+                ]
+            )
+
+            # Verify npm is installed
+            is_npm_installed = shutil.which("npm") is not None
+            assert is_npm_installed, "npm is not installed or isn't in PATH. Please install npm and try again."
+
+            tsgo_ls_dir = os.path.join(self._ls_resources_dir, "tsgo-lsp")
+            tsgo_executable_path = os.path.join(tsgo_ls_dir, "node_modules", ".bin", "tsgo")
+
+            # Check if installation is needed
+            version_file = os.path.join(tsgo_ls_dir, ".installed_version")
+            expected_version = tsgo_version
+
+            needs_install = False
+            if not os.path.exists(tsgo_executable_path):
+                log.info(f"tsgo executable not found at {tsgo_executable_path}.")
+                needs_install = True
+            elif os.path.exists(version_file):
+                with open(version_file) as f:
+                    installed_version = f.read().strip()
+                if installed_version != expected_version:
+                    log.info(f"tsgo version mismatch: installed={installed_version}, expected={expected_version}. Reinstalling...")
+                    needs_install = True
+            else:
+                log.info("tsgo version file not found. Reinstalling to ensure correct version...")
+                needs_install = True
+
+            if needs_install:
+                log.info("Installing tsgo dependencies...")
+                with LogTime("Installation of tsgo (typescript/native-preview)", logger=log):
+                    deps.install(tsgo_ls_dir)
+                with open(version_file, "w") as f:
+                    f.write(expected_version)
+                log.info("tsgo installed successfully")
+
+            if not os.path.exists(tsgo_executable_path):
+                raise FileNotFoundError(f"tsgo executable not found at {tsgo_executable_path}, something went wrong with the installation.")
+            return tsgo_executable_path
 
         def _create_launch_command(self, core_path: str) -> list[str]:
             return [core_path, "--lsp", "--stdio"]

test/conftest.py

@@ -269,6 +269,7 @@ def project_with_ls(request: LanguageParamRequest) -> Iterator[Project]:
     Language.PYTHON_TY: [pytest.mark.python],
     Language.RUST: [pytest.mark.rust],
     Language.TYPESCRIPT: [pytest.mark.typescript],
+    Language.TYPESCRIPT_TSGO: [pytest.mark.typescript],
 }
 
 

test/solidlsp/typescript/test_typescript_basic.py

@@ -5,19 +5,26 @@
 from solidlsp import SolidLanguageServer
 from solidlsp.ls_config import Language
 from solidlsp.ls_utils import SymbolUtils
+from test.conftest import is_ci, language_tests_enabled
 from test.solidlsp.conftest import format_symbol_for_assert, has_malformed_name, request_all_symbols
 
+_typescript_servers: list[Language] = [Language.TYPESCRIPT]
+
+# tsgo is always tested in CI; locally only if the language is enabled
+if is_ci or language_tests_enabled(Language.TYPESCRIPT_TSGO):
+    _typescript_servers.append(Language.TYPESCRIPT_TSGO)
+
 
 @pytest.mark.typescript
 class TestTypescriptLanguageServer:
-    @pytest.mark.parametrize("language_server", [Language.TYPESCRIPT], indirect=True)
+    @pytest.mark.parametrize("language_server", _typescript_servers, indirect=True)
     def test_find_symbol(self, language_server: SolidLanguageServer) -> None:
         symbols = language_server.request_full_symbol_tree()
         assert SymbolUtils.symbol_tree_contains_name(symbols, "DemoClass"), "DemoClass not found in symbol tree"
         assert SymbolUtils.symbol_tree_contains_name(symbols, "helperFunction"), "helperFunction not found in symbol tree"
         assert SymbolUtils.symbol_tree_contains_name(symbols, "printValue"), "printValue method not found in symbol tree"
 
-    @pytest.mark.parametrize("language_server", [Language.TYPESCRIPT], indirect=True)
+    @pytest.mark.parametrize("language_server", _typescript_servers, indirect=True)
     def test_find_referencing_symbols(self, language_server: SolidLanguageServer) -> None:
         file_path = os.path.join("index.ts")
         symbols = language_server.request_document_symbols(file_path).get_all_symbols_and_roots()
@@ -33,7 +40,7 @@ def test_find_referencing_symbols(self, language_server: SolidLanguageServer) ->
             "index.ts should reference helperFunction (tried all positions in selectionRange)"
         )
 
-    @pytest.mark.parametrize("language_server", [Language.TYPESCRIPT], indirect=True)
+    @pytest.mark.parametrize("language_server", _typescript_servers, indirect=True)
     def test_bare_symbol_names(self, language_server) -> None:
         all_symbols = request_all_symbols(language_server)
         malformed_symbols = []