@narumitw/pi-lsp 0.1.25 → 0.1.27

package/README.md

@@ -1,19 +1,18 @@
-# 🧠 pi-lsp — Shared Language Server Tools for Pi
+# 🧠 pi-lsp — Configurable Language Server Tools for Pi
 
 [![npm](https://img.shields.io/npm/v/@narumitw/pi-lsp)](https://www.npmjs.com/package/@narumitw/pi-lsp) [![Pi extension](https://img.shields.io/badge/Pi-extension-blue)](https://pi.dev) [![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](./LICENSE)
 
-`@narumitw/pi-lsp` is a native [Pi coding agent](https://pi.dev) extension that exposes Biome, ty, and Ruff language-server tools through one shared LSP runner Module.
+`@narumitw/pi-lsp` is a native [Pi coding agent](https://pi.dev) extension that exposes diagnostics and source-fix tools through configurable Language Server Protocol routes.
 
-It supersedes the older split packages `@narumitw/pi-biome-lsp` and `@narumitw/pi-python-lsp`, which now live under `extensions/deprecated/` and are excluded from active workspace scripts.
+The extension is language-agnostic: servers are selected by config and file extension instead of hard-coded language families.
 
 ## ✨ Features
 
-- Runs `biome lsp-proxy` on demand for diagnostics, formatting, import organization, and source fixes.
-- Runs `ty server` on demand for Python type diagnostics.
-- Runs `ruff server` on demand for Python lint diagnostics, formatting, import organization, and source fixes.
-- Uses one internal LSP runner for JSON-RPC framing, subprocess lifecycle, diagnostics, formatting, code actions, and workspace edit application.
-- Keeps Biome, ty, and Ruff behavior in small server Adapters.
-- Supports workspace roots, file limits, recursive file discovery, and write-or-preview edits.
+- Configure LSP servers with simple JSON keyed by server name.
+- Routes diagnostics and source fixes by configured file extensions.
+- Supports multiple servers for the same extension, for example `ty` and `ruff` for `.py`/`.pyi` diagnostics.
+- Uses one internal LSP runner for JSON-RPC framing, subprocess lifecycle, diagnostics, code actions, and workspace edit application.
+- Supports workspace roots, file limits, recursive file discovery, server overrides, and write-or-preview edits.
 - Starts language servers only for tool calls, then shuts them down.
 - Shows statusline activity only while LSP tools are running.
 
@@ -23,121 +22,119 @@ It supersedes the older split packages `@narumitw/pi-biome-lsp` and `@narumitw/p
 pi install npm:@narumitw/pi-lsp
 ```
 
-Try without installing permanently:
-
-```bash
-pi -e npm:@narumitw/pi-lsp
-```
-
 Try this package locally from the repository root:
 
 ```bash
 pi -e ./extensions/pi-lsp
 ```
 
-## ⚠️ Tool-name compatibility
-
-This package intentionally registers the same tool names as `@narumitw/pi-biome-lsp` and `@narumitw/pi-python-lsp`:
+## ⚙️ Configuration
 
-- `biome_lsp_diagnostics`
-- `biome_lsp_format`
-- `biome_lsp_fix`
-- `ty_lsp_diagnostics`
-- `ruff_lsp_diagnostics`
-- `ruff_lsp_format`
-- `ruff_lsp_fix`
+If no config is provided, pi-lsp ships compatible defaults for Biome, ty, and Ruff.
 
-Avoid installing `@narumitw/pi-lsp` side by side with the older deprecated LSP packages unless you have verified how your Pi version handles duplicate tool names.
+Custom config can be supplied in one of these locations:
 
-## ✅ Requirements
+1. `PI_LSP_CONFIG` as inline JSON or a path to a JSON file
+2. `<workspace>/.pi/lsp.json`
+3. `~/.pi/agent/lsp.json`
 
-Install the language servers you want to use somewhere on `PATH`:
+`lsp.json` can be a plain object keyed by server name:
 
-```bash
-uv tool install ty
-uv tool install ruff
+```json
+{
+  "ty": {
+    "command": ["ty", "server"],
+    "extensions": [".py", ".pyi"]
+  },
+  "ruff": {
+    "command": ["ruff", "server"],
+    "extensions": [".py", ".pyi"]
+  },
+  "biome": {
+    "command": ["biome", "lsp-proxy"],
+    "extensions": [
+      ".astro",
+      ".css",
+      ".graphql",
+      ".gql",
+      ".html",
+      ".js",
+      ".jsx",
+      ".json",
+      ".jsonc",
+      ".ts",
+      ".tsx",
+      ".vue"
+    ]
+  }
+}
 ```
 
-For Biome, either install it globally/on `PATH`, add your project's `node_modules/.bin` to `PATH`, or point the extension at a project-local command. For example:
+Use `servers` when you need global pi-lsp options such as timeout:
 
-```bash
-npm install -D @biomejs/biome
-PI_BIOME_LSP_COMMAND="./node_modules/.bin/biome lsp-proxy" pi -e ./extensions/pi-lsp
+```json
+{
+  "timeout": 30000,
+  "servers": {
+    "ty": {
+      "command": ["ty", "server"],
+      "extensions": [".py", ".pyi"],
+      "env": {
+        "LSP_LOG": "debug"
+      },
+      "initialization": {
+        "settings": {}
+      }
+    }
+  }
+}
 ```
 
-Or provide custom server commands:
+Each server entry supports:
 
-```bash
-PI_BIOME_LSP_COMMAND="npx biome lsp-proxy" \
-PI_TY_LSP_COMMAND="uvx ty server" \
-PI_RUFF_LSP_COMMAND="uvx ruff server" \
-pi -e ./extensions/pi-lsp
-```
+- `command`: argv array used to start the LSP server.
+- `extensions`: file extensions that should route to this server.
+- `env`: extra environment variables for the LSP server process.
+- `initialization`: LSP initialization options and workspace configuration values.
 
-Optional timeout overrides:
+Global options:
+
+- `timeout`: request timeout in milliseconds. Defaults to `20000`.
+
+pi-lsp infers `languageId` from common extensions and falls back to the extension without the leading dot.
+
+Per-server command overrides still use the normalized server name:
 
 ```bash
-PI_BIOME_LSP_TIMEOUT_MS=30000 \
-PI_TY_LSP_TIMEOUT_MS=30000 \
-PI_RUFF_LSP_TIMEOUT_MS=30000 \
+PI_TY_LSP_COMMAND="uvx ty server" \
+PI_RUFF_LSP_COMMAND="uvx ruff server" \
 pi -e ./extensions/pi-lsp
 ```
 
 ## 🛠️ Pi tools
 
-### Biome
+### `lsp_diagnostics`
 
-- `biome_lsp_diagnostics` — start `biome lsp-proxy`, open supported files, and return diagnostics.
-- `biome_lsp_format` — compute or write formatting edits for one Biome-supported file.
-- `biome_lsp_fix` — compute or write source actions such as `source.fixAll.biome` or `source.organizeImports.biome`.
+Run diagnostics through configured servers.
 
-### Python
+Parameters:
 
-- `ty_lsp_diagnostics` — start `ty server`, open Python files, and return type diagnostics.
-- `ruff_lsp_diagnostics` — start `ruff server`, open Python files, and return lint diagnostics.
-- `ruff_lsp_format` — compute or write Ruff formatting edits for one Python file.
-- `ruff_lsp_fix` — compute or write Ruff source actions such as `source.fixAll.ruff` or `source.organizeImports.ruff`.
+- `paths?`: files or directories to check. Defaults to the workspace root.
+- `root?`: workspace root. Defaults to cwd.
+- `limit?`: maximum files to open per selected server.
+- `server?`: configured server name, or an array of names. Defaults to all matching servers.
 
-## 🚀 Examples
+### `lsp_fix`
 
-Check a project subset with Biome diagnostics:
+Apply source fixes or import organization through a configured server that matches its extension. If multiple servers match, pass `server` explicitly.
 
-```json
-{
-  "paths": ["src", "extensions/pi-lsp/src"],
-  "limit": 100
-}
-```
-
-Format a TypeScript file with Biome:
-
-```json
-{
-  "path": "src/index.ts",
-  "write": true
-}
-```
+Parameters:
 
-Check a Python project with ty or Ruff diagnostics:
-
-```json
-{
-  "paths": ["src", "tests"],
-  "limit": 100
-}
-```
-
-Organize Python imports with Ruff:
-
-```json
-{
-  "path": "src/app.py",
-  "kind": "source.organizeImports.ruff",
-  "write": true
-}
-```
-
-If `paths` is omitted for diagnostics, the tool recursively discovers supported files under the workspace root while skipping common generated, dependency, cache, and virtualenv directories.
+- `path`: file to fix.
+- `root?`: workspace root. Defaults to cwd.
+- `kind?`: source action kind. Defaults to `source.fixAll`.
+- `write?`: write fixed text back to the file. Defaults to false.
+- `server?`: optional configured server name.
 
 ## 💬 Command
 
@@ -145,7 +142,7 @@ If `paths` is omitted for diagnostics, the tool recursively discovers supported
 /lsp
 ```
 
-Shows the configured Biome, ty, and Ruff LSP commands and whether each command is available on `PATH`.
+Shows configured LSP commands and whether each command is available on `PATH`.
 
 ## 🗂️ Package layout
 
@@ -157,6 +154,7 @@ extensions/pi-lsp/
 │   ├── files.ts
 │   ├── lsp-client.ts
 │   ├── pi-lsp.ts
+│   ├── routes.ts
 │   ├── runner.ts
 │   ├── text-edits.ts
 │   └── types.ts
@@ -166,10 +164,6 @@ extensions/pi-lsp/
 └── package.json
 ```
 
-## 🔎 Keywords
-
-Pi extension, Pi coding agent, Language Server Protocol, Biome LSP, ty, Ruff, Python LSP, formatter, linter, import organization, AI coding tools.
-
 ## 📄 License
 
 MIT. See [`LICENSE`](./LICENSE).

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@narumitw/pi-lsp",
-	"version": "0.1.25",
-	"description": "Pi extension that exposes language-server tools for Biome, ty, and Ruff through a shared LSP runner.",
+	"version": "0.1.27",
+	"description": "Pi extension that exposes configurable, language-agnostic LSP tools through a shared runner.",
 	"type": "module",
 	"license": "MIT",
 	"private": false,
@@ -10,12 +10,11 @@
 		"pi-extension",
 		"pi",
 		"lsp",
-		"biome",
-		"python",
-		"ty",
-		"ruff",
+		"language-server-protocol",
+		"configurable",
 		"lint",
-		"format"
+		"diagnostics",
+		"code-action"
 	],
 	"files": [
 		"src",

package/src/adapters.ts

@@ -1,19 +1,30 @@
+import { existsSync, readFileSync } from "node:fs";
+import os from "node:os";
 import path from "node:path";
-import type { LspServerAdapter } from "./types.js";
+import process from "node:process";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import type { InternalLspServer, LspConfig, LspServerAdapter } from "./types.js";
 
-const BIOME_SKIP_DIRECTORIES = new Set([
+const COMMON_SKIP_DIRECTORIES = new Set([
 	".git",
 	".hg",
+	".mypy_cache",
 	".next",
 	".nuxt",
 	".output",
+	".ruff_cache",
 	".svelte-kit",
+	".tox",
+	".venv",
+	"__pycache__",
 	"coverage",
 	"dist",
 	"node_modules",
 	"out",
+	"venv",
 ]);
-const BIOME_SUPPORTED_EXTENSIONS = new Set([
+
+const BIOME_EXTENSIONS = [
 	".astro",
 	".css",
 	".cts",
@@ -31,111 +42,210 @@ const BIOME_SUPPORTED_EXTENSIONS = new Set([
 	".ts",
 	".tsx",
 	".vue",
-]);
-
-const PYTHON_SKIP_DIRECTORIES = new Set([
-	".git",
-	".hg",
-	".mypy_cache",
-	".ruff_cache",
-	".tox",
-	".venv",
-	"__pycache__",
-	"node_modules",
-	"venv",
-]);
+];
 
-export const biomeAdapter: LspServerAdapter = {
-	label: "Biome",
-	statusPrefix: "🧬",
-	defaultCommand: { command: "biome", args: ["lsp-proxy"] },
-	commandEnvVar: "PI_BIOME_LSP_COMMAND",
-	timeoutEnvVar: "PI_BIOME_LSP_TIMEOUT_MS",
-	missingCommandHint: "Install @biomejs/biome or set PI_BIOME_LSP_COMMAND.",
-	skipDirectories: BIOME_SKIP_DIRECTORIES,
-	isSupportedFile: (filePath) => BIOME_SUPPORTED_EXTENSIONS.has(path.extname(filePath)),
-	languageIdFor: biomeLanguageIdFor,
-	formattingOptions: { tabSize: 2, insertSpaces: false },
-	initialize: {
-		codeAction: true,
-		diagnosticDynamicRegistration: true,
-		formattingDynamicRegistration: true,
-		codeActionDynamicRegistration: true,
-		didChangeConfigurationDynamicRegistration: true,
-		didSaveDynamicRegistration: true,
+export const DEFAULT_SERVER_CONFIGS: InternalLspServer[] = [
+	{
+		name: "biome",
+		command: ["biome", "lsp-proxy"],
+		extensions: BIOME_EXTENSIONS,
 	},
-	fallbackToPublishDiagnostics: true,
-	resolveUnsupportedCodeActions: true,
-	serverRequestWorkspaceFolders: true,
-	emptyDiagnosticsMessage: "Biome LSP found no supported files to check.",
-	formatDiagnosticsHeader: (summary) =>
-		`Biome LSP diagnostics: ${summary.diagnostics} diagnostic(s) across ${summary.files} file(s).`,
-	editSummaryLabel: "Biome",
-	defaultFixKind: "source.fixAll.biome",
-};
-
-export const tyAdapter: LspServerAdapter = {
-	label: "ty",
-	statusPrefix: "🐍 ty",
-	defaultCommand: { command: "ty", args: ["server"] },
-	commandEnvVar: "PI_TY_LSP_COMMAND",
-	timeoutEnvVar: "PI_TY_LSP_TIMEOUT_MS",
-	missingCommandHint: "Install ty or set PI_TY_LSP_COMMAND.",
-	skipDirectories: PYTHON_SKIP_DIRECTORIES,
-	isSupportedFile: isPythonFile,
-	languageIdFor: () => "python",
-	formattingOptions: { tabSize: 4, insertSpaces: true },
-	initialize: {
-		codeAction: false,
-		diagnosticDynamicRegistration: false,
+	{
+		name: "ty",
+		command: ["ty", "server"],
+		extensions: [".py", ".pyi"],
 	},
-	fallbackToPublishDiagnostics: false,
-	resolveUnsupportedCodeActions: false,
-	serverRequestWorkspaceFolders: false,
-	emptyDiagnosticsMessage: "ty LSP found no Python files to check.",
-	formatDiagnosticsHeader: (summary) =>
-		`ty LSP diagnostics: ${summary.diagnostics} diagnostic(s) across ${summary.files} file(s).`,
-	editSummaryLabel: "ty",
-};
-
-export const ruffAdapter: LspServerAdapter = {
-	label: "Ruff",
-	statusPrefix: "🐍 ruff",
-	defaultCommand: { command: "ruff", args: ["server"] },
-	commandEnvVar: "PI_RUFF_LSP_COMMAND",
-	timeoutEnvVar: "PI_RUFF_LSP_TIMEOUT_MS",
-	missingCommandHint: "Install ruff or set PI_RUFF_LSP_COMMAND.",
-	skipDirectories: PYTHON_SKIP_DIRECTORIES,
-	isSupportedFile: isPythonFile,
-	languageIdFor: () => "python",
-	formattingOptions: { tabSize: 4, insertSpaces: true },
-	initialize: {
-		codeAction: true,
-		diagnosticDynamicRegistration: false,
+	{
+		name: "ruff",
+		command: ["ruff", "server"],
+		extensions: [".py", ".pyi"],
 	},
-	fallbackToPublishDiagnostics: false,
-	resolveUnsupportedCodeActions: false,
-	serverRequestWorkspaceFolders: false,
-	emptyDiagnosticsMessage: "Ruff LSP found no Python files to check.",
-	formatDiagnosticsHeader: (summary) =>
-		`Ruff LSP diagnostics: ${summary.diagnostics} diagnostic(s) across ${summary.files} file(s).`,
-	editSummaryLabel: "Ruff",
-	defaultFixKind: "source.fixAll.ruff",
-};
+];
+
+export function loadRuntime(cwd = process.cwd()) {
+	const config = loadConfig(cwd);
+	return {
+		adapters: config.servers.map(configToAdapter),
+		timeoutMs: config.timeout ?? 20_000,
+	};
+}
 
-export const adapters = [biomeAdapter, tyAdapter, ruffAdapter] as const;
+export function loadConfig(cwd = process.cwd()): LspConfig {
+	const configured = loadConfiguredConfig(cwd);
+	return configured ?? { servers: DEFAULT_SERVER_CONFIGS };
+}
+
+function loadConfiguredConfig(cwd: string): LspConfig | undefined {
+	const rawConfig = process.env.PI_LSP_CONFIG?.trim();
+	if (rawConfig) return parseConfigSource(rawConfig, cwd, "PI_LSP_CONFIG");
+
+	const projectConfig = path.join(cwd, ".pi", "lsp.json");
+	if (existsSync(projectConfig)) return parseConfigFile(projectConfig);
+
+	const userConfig = path.join(getAgentDir(), "lsp.json");
+	if (existsSync(userConfig)) return parseConfigFile(userConfig);
+
+	return undefined;
+}
+
+function parseConfigSource(source: string, cwd: string, label: string): LspConfig {
+	if (source.startsWith("{")) return normalizeConfig(JSON.parse(source), label);
+	const expandedSource = expandHome(source);
+	const filePath = path.isAbsolute(expandedSource) ? expandedSource : path.resolve(cwd, expandedSource);
+	return parseConfigFile(filePath);
+}
 
-function biomeLanguageIdFor(filePath: string) {
+function parseConfigFile(filePath: string): LspConfig {
+	return normalizeConfig(JSON.parse(readFileSync(filePath, "utf8")), filePath);
+}
+
+function normalizeConfig(value: unknown, label: string): LspConfig {
+	if (!isRecord(value) || Array.isArray(value)) {
+		throw new Error(`${label} must be a JSON object mapping server names to LSP server config.`);
+	}
+
+	if ("servers" in value) {
+		if (isServerEntry(value.servers)) {
+			throw new Error(
+				`${label} uses reserved top-level key 'servers'. Use the wrapper shape ` +
+					`{ "servers": { "<name>": { "command": [...], "extensions": [...] } } }` +
+					" or choose a different server name.",
+			);
+		}
+		const timeout = normalizeTimeout(value.timeout, label);
+		const servers = value.servers;
+		if (!isRecord(servers) || Array.isArray(servers)) {
+			throw new Error(`${label}.servers must be a JSON object mapping server names to LSP server config.`);
+		}
+		return { timeout, servers: normalizeServerMap(servers, `${label}.servers`) };
+	}
+
+	if ("timeout" in value) {
+		throw new Error(`${label}.timeout requires the wrapper shape with a servers object.`);
+	}
+
+	return { servers: normalizeServerMap(value, label) };
+}
+
+function normalizeServerMap(value: Record<string, unknown>, label: string) {
+	return Object.entries(value).map(([name, server]) => normalizeServer(name, server, `${label}.${name}`));
+}
+
+function isServerEntry(value: unknown) {
+	return (
+		isRecord(value) &&
+		(Array.isArray(value.command) || Array.isArray(value.extensions))
+	);
+}
+
+function normalizeServer(name: string, value: unknown, label: string): InternalLspServer {
+	if (!isRecord(value)) throw new Error(`${label} must be an object.`);
+	const command = stringArrayField(value, "command", label);
+	const extensions = stringArrayField(value, "extensions", label).map(normalizeExtension);
+	return {
+		name,
+		command,
+		extensions,
+		env: optionalStringRecordField(value, "env", label),
+		initialization: optionalRecordField(value, "initialization", label),
+	};
+}
+
+function normalizeTimeout(value: unknown, label: string) {
+	if (value === undefined) return undefined;
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+		throw new Error(`${label}.timeout must be a positive number.`);
+	}
+	return value;
+}
+
+function configToAdapter(config: InternalLspServer): LspServerAdapter {
+	const extensionSet = new Set(config.extensions.map(normalizeExtension));
+	const [command, ...args] = config.command;
+	if (!command) throw new Error(`${config.name}.command must contain at least one string.`);
+	return {
+		name: config.name,
+		defaultCommand: { command, args },
+		commandEnvVar: envName(config.name, "COMMAND"),
+		missingCommandHint: `Install ${config.name} or set ${envName(config.name, "COMMAND")}.`,
+		extensions: config.extensions,
+		env: config.env,
+		initialization: config.initialization,
+		skipDirectories: COMMON_SKIP_DIRECTORIES,
+		isSupportedFile: (filePath) => extensionSet.has(path.extname(filePath)),
+		languageIdFor: (filePath) => languageIdFor(config, filePath),
+	};
+}
+
+function languageIdFor(_config: InternalLspServer, filePath: string) {
 	const extension = path.extname(filePath);
-	if (extension === ".js" || extension === ".cjs" || extension === ".mjs") return "javascript";
-	if (extension === ".jsx") return "javascriptreact";
-	if (extension === ".ts" || extension === ".cts" || extension === ".mts") return "typescript";
-	if (extension === ".tsx") return "typescriptreact";
-	if (extension === ".gql") return "graphql";
-	if (extension === ".jsonc") return "jsonc";
-	return extension.slice(1);
+	return LANGUAGE_IDS[extension] ?? extension.slice(1);
+}
+
+const LANGUAGE_IDS: Record<string, string> = {
+	".cjs": "javascript",
+	".cts": "typescript",
+	".gql": "graphql",
+	".js": "javascript",
+	".jsx": "javascriptreact",
+	".jsonc": "jsonc",
+	".mjs": "javascript",
+	".mts": "typescript",
+	".py": "python",
+	".pyi": "python",
+	".ts": "typescript",
+	".tsx": "typescriptreact",
+};
+
+function commandFromEnvName(name: string): string {
+	return name.replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();
+}
+
+function envName(name: string, suffix: "COMMAND") {
+	return `PI_${commandFromEnvName(name)}_LSP_${suffix}`;
+}
+
+function normalizeExtension(extension: string) {
+	return extension.startsWith(".") ? extension : `.${extension}`;
+}
+
+function stringArrayField(value: Record<string, unknown>, field: string, label: string) {
+	const fieldValue = value[field];
+	if (!Array.isArray(fieldValue) || !fieldValue.every((item) => typeof item === "string")) {
+		throw new Error(`${label}.${field} must be an array of strings.`);
+	}
+	return fieldValue;
+}
+
+function optionalStringRecordField(value: Record<string, unknown>, field: string, label: string) {
+	const fieldValue = value[field];
+	if (fieldValue === undefined) return undefined;
+	if (!isRecord(fieldValue) || Array.isArray(fieldValue)) {
+		throw new Error(`${label}.${field} must be an object with string values.`);
+	}
+	if (!Object.values(fieldValue).every((item) => typeof item === "string")) {
+		throw new Error(`${label}.${field} must be an object with string values.`);
+	}
+	return fieldValue as Record<string, string>;
+}
+
+function optionalRecordField(value: Record<string, unknown>, field: string, label: string) {
+	const fieldValue = value[field];
+	if (fieldValue === undefined) return undefined;
+	if (!isRecord(fieldValue) || Array.isArray(fieldValue)) {
+		throw new Error(`${label}.${field} must be an object.`);
+	}
+	return fieldValue;
+}
+
+function expandHome(filePath: string) {
+	if (filePath === "~") return os.homedir();
+	if (filePath.startsWith("~/") || filePath.startsWith("~\\")) {
+		return path.join(os.homedir(), filePath.slice(2));
+	}
+	return filePath;
 }
 
-function isPythonFile(filePath: string) {
-	return filePath.endsWith(".py") || filePath.endsWith(".pyi");
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
 }

package/src/command.ts

@@ -13,11 +13,6 @@ export function commandFromEnv(envVar: string, fallback: ServerCommand): ServerC
 	return fallback;
 }
 
-export function timeoutFromEnv(envVar: string, defaultTimeoutMs: number) {
-	const rawValue = Number(process.env[envVar] ?? defaultTimeoutMs);
-	return Number.isFinite(rawValue) && rawValue > 0 ? rawValue : defaultTimeoutMs;
-}
-
 export function commandExists(command: string, cwd = process.cwd()) {
 	if (command.includes("/") || command.includes("\\")) {
 		return isRunnableFile(path.isAbsolute(command) ? command : path.resolve(cwd, command));

package/src/files.ts

@@ -19,13 +19,13 @@ export function directoryUri(directory: string) {
 
 export function resolveSupportedFile(adapter: LspServerAdapter, root: string, filePath: string) {
 	const resolvedPath = resolveWorkspacePath(root, filePath, "File path");
-	if (!existsSync(resolvedPath)) throw new Error(`${adapter.label} file does not exist: ${resolvedPath}`);
+	if (!existsSync(resolvedPath)) throw new Error(`${adapter.name} file does not exist: ${resolvedPath}`);
 	if (!isInsidePath(realpathSync(root), realpathSync(resolvedPath))) {
 		throw new Error(`File resolves outside workspace root: ${resolvedPath}`);
 	}
 	if (!statSync(resolvedPath).isFile()) throw new Error(`Expected a file: ${resolvedPath}`);
 	if (!adapter.isSupportedFile(resolvedPath)) {
-		throw new Error(`Expected a ${adapter.label} supported file: ${resolvedPath}`);
+		throw new Error(`Expected a ${adapter.name} supported file: ${resolvedPath}`);
 	}
 	return resolvedPath;
 }