pi-lsp-adapter 0.1.0

package/src/registry/builtin.ts

@@ -0,0 +1,171 @@
+import type { BuiltinCatalog, FiletypeRules } from "./schema.js";
+
+export const BUILTIN_FILETYPE_RULES: Required<FiletypeRules> = {
+  exactFilenames: {},
+  extensions: {
+    ".js": "javascript",
+    ".jsx": "javascriptreact",
+    ".ts": "typescript",
+    ".tsx": "typescriptreact",
+    ".py": "python",
+    ".go": "go",
+    ".rs": "rust",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".json": "json",
+    ".jsonc": "jsonc",
+    ".java": "java",
+  },
+};
+
+export const BUILTIN_CATALOG: BuiltinCatalog = {
+  servers: {
+    vtsls: {
+      id: "vtsls",
+      displayName: "JavaScript/TypeScript Language Server (VTSLS)",
+      filetypes: ["javascript", "javascriptreact", "typescript", "typescriptreact"],
+      rootMarkers: [
+        "package.json",
+        "tsconfig.json",
+        "jsconfig.json",
+        "pnpm-workspace.yaml",
+        "bun.lock",
+        "bun.lockb",
+        "yarn.lock",
+        ".git",
+      ],
+      install: {
+        type: "npm",
+        packages: {
+          "@vtsls/language-server": "0.3.0",
+          typescript: "6.0.3",
+        },
+        bin: "vtsls",
+      },
+      command: ["{installBin}/vtsls", "--stdio"],
+      env: {},
+      settings: {},
+      initializationOptions: {},
+      lazy: true,
+    },
+    pyright: {
+      id: "pyright",
+      displayName: "Pyright",
+      filetypes: ["python"],
+      rootMarkers: ["pyproject.toml", "setup.py", "setup.cfg", "requirements.txt", "uv.lock", "poetry.lock", ".git"],
+      install: {
+        type: "npm",
+        packages: {
+          pyright: "1.1.410",
+        },
+        bin: "pyright-langserver",
+      },
+      command: ["{installBin}/pyright-langserver", "--stdio"],
+      env: {},
+      settings: {},
+      initializationOptions: {},
+      lazy: true,
+    },
+    gopls: {
+      id: "gopls",
+      displayName: "gopls",
+      filetypes: ["go"],
+      rootMarkers: ["go.work", "go.mod", ".git"],
+      install: {
+        type: "go",
+        module: "golang.org/x/tools/gopls",
+        version: "v0.22.0",
+        bin: "gopls",
+      },
+      command: ["{installBin}/gopls"],
+      env: {},
+      settings: {},
+      initializationOptions: {},
+      lazy: true,
+    },
+    "rust-analyzer": {
+      id: "rust-analyzer",
+      displayName: "rust-analyzer",
+      filetypes: ["rust"],
+      rootMarkers: ["Cargo.toml", "rust-project.json", ".git"],
+      install: {
+        type: "github",
+        repo: "rust-lang/rust-analyzer",
+        version: "2026-05-25",
+        asset: "rust-analyzer-{platform}.gz",
+        bin: "rust-analyzer",
+      },
+      command: ["{installBin}/rust-analyzer"],
+      env: {},
+      settings: {},
+      initializationOptions: {},
+      lazy: true,
+    },
+    yamlls: {
+      id: "yamlls",
+      displayName: "YAML Language Server",
+      filetypes: ["yaml"],
+      rootMarkers: [".yamlls.yaml", ".git"],
+      install: {
+        type: "npm",
+        packages: {
+          "yaml-language-server": "1.23.0",
+        },
+        bin: "yaml-language-server",
+      },
+      command: ["{installBin}/yaml-language-server", "--stdio"],
+      env: {},
+      settings: {},
+      initializationOptions: {},
+      lazy: true,
+    },
+    jsonls: {
+      id: "jsonls",
+      displayName: "JSON Language Server",
+      filetypes: ["json", "jsonc"],
+      rootMarkers: ["package.json", ".git"],
+      install: {
+        type: "npm",
+        packages: {
+          "vscode-langservers-extracted": "4.10.0",
+        },
+        bin: "vscode-json-language-server",
+      },
+      command: ["{installBin}/vscode-json-language-server", "--stdio"],
+      env: {},
+      settings: {},
+      initializationOptions: {},
+      lazy: true,
+    },
+    jdtls: {
+      id: "jdtls",
+      displayName: "Eclipse JDT LS",
+      filetypes: ["java"],
+      rootMarkers: ["pom.xml", "build.gradle", "build.gradle.kts", "settings.gradle", ".project", ".git"],
+      install: {
+        type: "github",
+        repo: "eclipse-jdtls/eclipse.jdt.ls",
+        version: "1.58.0",
+        asset: "jdt-language-server-1.58.0-202604151538.tar.gz",
+        downloadUrl: "https://download.eclipse.org/jdtls/milestones/{version}/{asset}",
+        bin: "jdtls",
+      },
+      command: [
+        "java",
+        "-Declipse.application=org.eclipse.jdt.ls.core.id1",
+        "-Dosgi.bundles.defaultStartLevel=4",
+        "-Declipse.product=org.eclipse.jdt.ls.core.product",
+        "-jar",
+        "{installDir}/plugins/org.eclipse.equinox.launcher_*.jar",
+        "-configuration",
+        "{installDir}/config_{platform}",
+        "-data",
+        "{workspaceDir}",
+      ],
+      env: {},
+      settings: {},
+      initializationOptions: {},
+      lazy: true,
+    },
+  },
+};

package/src/registry/schema.ts

@@ -0,0 +1,185 @@
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | { [key: string]: JsonValue };
+export type JsonObject = { [key: string]: JsonValue };
+
+export type InstallMode = "prompt" | "auto" | "off";
+
+export const SUPPORTED_LANGUAGE_SERVER_IDS = [
+  "vtsls",
+  "pyright",
+  "gopls",
+  "rust-analyzer",
+  "yamlls",
+  "jsonls",
+  "jdtls",
+] as const;
+
+export type SupportedLanguageServerId = (typeof SUPPORTED_LANGUAGE_SERVER_IDS)[number];
+
+export type InstallerType = "npm" | "go" | "github" | "system";
+
+export interface BaseInstallSpec {
+  type: InstallerType;
+}
+
+export interface NpmInstallSpec extends BaseInstallSpec {
+  type: "npm";
+  packages: Record<string, string>;
+  bin: string;
+}
+
+export interface GoInstallSpec extends BaseInstallSpec {
+  type: "go";
+  module: string;
+  version?: string;
+  bin: string;
+}
+
+export interface GithubInstallSpec extends BaseInstallSpec {
+  type: "github";
+  repo: string;
+  version?: string;
+  asset?: string;
+  downloadUrl?: string;
+  bin: string;
+  stripComponents?: number;
+}
+
+export interface SystemInstallSpec extends BaseInstallSpec {
+  type: "system";
+  bin?: string;
+  command?: string[];
+}
+
+export type InstallSpec = NpmInstallSpec | GoInstallSpec | GithubInstallSpec | SystemInstallSpec;
+
+export interface ServerDefinition<TServerId extends string = string> {
+  id: TServerId;
+  displayName: string;
+  filetypes: string[];
+  rootMarkers: string[];
+  install: InstallSpec;
+  command: string[];
+  cwd?: string;
+  env?: Record<string, string>;
+  settings: JsonObject;
+  initializationOptions: JsonObject;
+  lazy: boolean;
+}
+
+export interface Catalog<TServerId extends string = string> {
+  servers: { [ServerId in TServerId]: ServerDefinition<ServerId> };
+}
+
+export type RuntimeCatalog = Catalog<string>;
+export type BuiltinCatalog = Catalog<SupportedLanguageServerId>;
+
+export interface FiletypeRules {
+  exactFilenames?: Record<string, string>;
+  extensions?: Record<string, string>;
+}
+
+export interface LspConfig {
+  installMode?: InstallMode;
+  warmup?: boolean;
+  servers?: Record<string, Partial<ServerDefinition>>;
+  trustedProjects?: string[];
+}
+
+export interface InstalledServerMetadata {
+  installer: InstallerType;
+  requestedVersion?: string;
+  packages?: Record<string, string>;
+  resolvedCommand: string[];
+  packageDir?: string;
+  binDir?: string;
+  installedAt: string;
+}
+
+export interface ResolvedServerConfig {
+  server: ServerDefinition;
+  rootDir: string;
+  rootMarker?: string;
+  command: string[];
+  cwd: string;
+  env: Record<string, string>;
+  settings: JsonObject;
+  initializationOptions: JsonObject;
+  install?: InstalledServerMetadata;
+}
+
+export type ParseResult<T> = { ok: true; value: T } | { ok: false; errors: string[] };
+
+const StringRecordSchema = Type.Record(Type.String(), Type.String());
+const JsonObjectSchema = Type.Record(Type.String(), Type.Any());
+const StringArraySchema = Type.Array(Type.String());
+
+export const InstalledServerMetadataSchema = Type.Object({
+  installer: Type.String(),
+  requestedVersion: Type.Optional(Type.String()),
+  packages: Type.Optional(StringRecordSchema),
+  resolvedCommand: StringArraySchema,
+  packageDir: Type.Optional(Type.String()),
+  binDir: Type.Optional(Type.String()),
+  installedAt: Type.String(),
+});
+
+export const InstallSpecSchema = Type.Union([
+  Type.Object({
+    type: Type.Literal("npm"),
+    packages: StringRecordSchema,
+    bin: Type.String(),
+  }),
+  Type.Object({
+    type: Type.Literal("go"),
+    module: Type.String(),
+    version: Type.Optional(Type.String()),
+    bin: Type.String(),
+  }),
+  Type.Object({
+    type: Type.Literal("github"),
+    repo: Type.String(),
+    version: Type.Optional(Type.String()),
+    asset: Type.Optional(Type.String()),
+    downloadUrl: Type.Optional(Type.String()),
+    bin: Type.String(),
+    stripComponents: Type.Optional(Type.Number()),
+  }),
+  Type.Object({
+    type: Type.Literal("system"),
+    bin: Type.Optional(Type.String()),
+    command: Type.Optional(StringArraySchema),
+  }),
+]);
+
+export const ServerDefinitionSchema = Type.Object({
+  id: Type.String(),
+  displayName: Type.String(),
+  filetypes: StringArraySchema,
+  rootMarkers: StringArraySchema,
+  install: InstallSpecSchema,
+  command: StringArraySchema,
+  cwd: Type.Optional(Type.String()),
+  env: Type.Optional(StringRecordSchema),
+  settings: JsonObjectSchema,
+  initializationOptions: JsonObjectSchema,
+  lazy: Type.Boolean(),
+});
+
+export function parseServerDefinition(value: unknown): ParseResult<ServerDefinition> {
+  if (Value.Check(ServerDefinitionSchema, value)) {
+    return { ok: true, value: value as ServerDefinition };
+  }
+
+  return { ok: false, errors: formatSchemaErrors(ServerDefinitionSchema, value) };
+}
+
+function formatSchemaErrors(schema: unknown, value: unknown): string[] {
+  return [...Value.Errors(schema as never, value)].map((error) => {
+    const path = error.instancePath === "" ? "server" : `server${error.instancePath}`;
+    return `${path} ${error.message}`;
+  });
+}

package/src/resolve/languages.ts

@@ -0,0 +1,96 @@
+import { delimiter, join, resolve } from "node:path";
+import { getWorkspacesDir } from "../config/paths.js";
+import type { JsonObject, ServerDefinition } from "../registry/schema.js";
+import { deepClone } from "../util/deepMerge.js";
+import { hashPath } from "../util/hash.js";
+import { isPythonServerId, pathExists } from "../util/helpers.js";
+
+export interface LanguageDefaultsInput {
+  server: ServerDefinition;
+  rootDir: string;
+  env: Record<string, string>;
+  settings: JsonObject;
+  initializationOptions: JsonObject;
+}
+
+export interface LanguageDefaultsResult {
+  env: Record<string, string>;
+  settings: JsonObject;
+  initializationOptions: JsonObject;
+  workspaceDir?: string;
+}
+
+export async function applyLanguageDefaults(input: LanguageDefaultsInput): Promise<LanguageDefaultsResult> {
+  const env = { ...input.env };
+  const settings = deepClone(input.settings);
+  const initializationOptions = deepClone(input.initializationOptions);
+  let workspaceDir: string | undefined;
+
+  if (isPythonServer(input.server)) {
+    await applyPythonDefaults(input.rootDir, env, settings);
+  }
+
+  if (input.server.id === "jdtls") {
+    workspaceDir = join(getWorkspacesDir(), "jdtls", hashPath(input.rootDir));
+  }
+
+  return { env, settings, initializationOptions, workspaceDir };
+}
+
+async function applyPythonDefaults(rootDir: string, env: Record<string, string>, settings: JsonObject): Promise<void> {
+  const venvDir = await selectPythonVirtualEnv(rootDir, env);
+  if (!venvDir) return;
+
+  const binDir = getVirtualEnvBinDir(venvDir);
+  env.PATH = prependPath(binDir, env.PATH ?? "");
+
+  if (!hasPythonInterpreterSetting(settings)) {
+    settings["python.defaultInterpreterPath"] = join(binDir, getPythonExecutableName());
+  }
+}
+
+async function selectPythonVirtualEnv(rootDir: string, env: Record<string, string>): Promise<string | undefined> {
+  if (env.VIRTUAL_ENV) {
+    return resolve(rootDir, env.VIRTUAL_ENV);
+  }
+
+  for (const dirname of [".venv", "venv"]) {
+    const candidate = join(rootDir, dirname);
+    if (await pathExists(candidate)) {
+      return candidate;
+    }
+  }
+
+  return undefined;
+}
+
+function isPythonServer(server: ServerDefinition): boolean {
+  return isPythonServerId(server.id) || server.filetypes.includes("python");
+}
+
+function getVirtualEnvBinDir(venvDir: string): string {
+  return join(venvDir, process.platform === "win32" ? "Scripts" : "bin");
+}
+
+function getPythonExecutableName(): string {
+  return process.platform === "win32" ? "python.exe" : "python";
+}
+
+function prependPath(path: string, currentPath: string): string {
+  if (!currentPath) return path;
+  return `${path}${delimiter}${currentPath}`;
+}
+
+function hasPythonInterpreterSetting(settings: JsonObject): boolean {
+  if (typeof settings["python.defaultInterpreterPath"] === "string") {
+    return true;
+  }
+
+  const python = settings.python;
+  return (
+    typeof python === "object" &&
+    python !== null &&
+    !Array.isArray(python) &&
+    typeof (python as Record<string, unknown>).defaultInterpreterPath === "string"
+  );
+}