pi-lsp-adapter 0.1.0

package/src/tools/registerLspTools.ts

@@ -0,0 +1,241 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import type { LspExtensionState } from "../state.js";
+import { setLspStatusLine } from "../statusLine.js";
+import {
+  failure,
+  formatDefinition,
+  formatDiagnostics,
+  formatDocumentSymbols,
+  formatHover,
+  formatReferences,
+  formatWorkspaceSymbols,
+  toLspPosition,
+} from "./lspFormat.js";
+import { LSP_RESULT_ID_LENGTH, LSP_RESULT_ID_PATTERN } from "./resultCache.js";
+
+export type GetLspToolState = () => LspExtensionState | null;
+
+const FilePathParams = Type.Object({
+  filePath: Type.String({ description: "Path to the source file to inspect." }),
+});
+
+const FilePositionParams = Type.Object({
+  filePath: Type.String({ description: "Path to the source file to inspect." }),
+  line: Type.Integer({ minimum: 1, description: "1-based line number." }),
+  column: Type.Integer({
+    minimum: 1,
+    description: "1-based column/character number. For symbol queries, place it on the identifier token.",
+  }),
+});
+
+const ReferencesParams = Type.Object({
+  filePath: Type.String({ description: "Path to the source file to inspect." }),
+  line: Type.Integer({ minimum: 1, description: "1-based line number." }),
+  column: Type.Integer({
+    minimum: 1,
+    description: "1-based column/character number. For symbol queries, place it on the identifier token.",
+  }),
+  includeDeclaration: Type.Optional(
+    Type.Boolean({ description: "Whether to include the symbol declaration in the result." }),
+  ),
+});
+
+const WorkspaceSymbolsParams = Type.Object({
+  query: Type.String({ description: "Workspace symbol query string." }),
+  serverId: Type.Optional(Type.String({ description: "Optional LSP server id to query, e.g. pyright or vtsls." })),
+});
+
+const MoreParams = Type.Object({
+  resultId: Type.String({
+    description: "Exact cached LSP resultId returned by a previous paginated LSP tool result.",
+    pattern: LSP_RESULT_ID_PATTERN,
+    minLength: LSP_RESULT_ID_LENGTH,
+    maxLength: LSP_RESULT_ID_LENGTH,
+  }),
+});
+
+export function registerLspTools(pi: ExtensionAPI, getState: GetLspToolState): void {
+  pi.registerTool<typeof FilePathParams, unknown>({
+    name: "lsp_diagnostics",
+    label: "LSP Diagnostics",
+    description: "Read diagnostics for a file using its configured language server.",
+    promptSnippet: "Inspect compiler/type/lint diagnostics from configured language servers for a file.",
+    promptGuidelines: [
+      "Use lsp_diagnostics after reading or editing code when semantic errors, type errors, or language-server diagnostics would help.",
+    ],
+    parameters: FilePathParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const state = getState();
+      if (!state) return failure("lsp_diagnostics", "LSP extension is not initialized.");
+      try {
+        const result = formatDiagnostics(await state.runtimeManager.diagnostics(params.filePath), state.resultCache);
+        refreshStatus(ctx, state);
+        return result;
+      } catch (error) {
+        refreshStatus(ctx, state);
+        return failure("lsp_diagnostics", error);
+      }
+    },
+  });
+
+  pi.registerTool<typeof FilePositionParams, unknown>({
+    name: "lsp_hover",
+    label: "LSP Hover",
+    description: "Get hover/type information at a source position. line and column are 1-based.",
+    promptSnippet: "Fetch hover/type information for a symbol at a 1-based line and column.",
+    promptGuidelines: [
+      "Use lsp_hover when symbol type, signature, documentation, or inferred information would reduce guesswork. Put line/column on the identifier token itself, not whitespace or surrounding syntax.",
+    ],
+    parameters: FilePositionParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const state = getState();
+      if (!state) return failure("lsp_hover", "LSP extension is not initialized.");
+      try {
+        const position = toLspPosition(params);
+        const result = formatHover(
+          await state.runtimeManager.hover(params.filePath, position.line, position.character),
+        );
+        refreshStatus(ctx, state);
+        return result;
+      } catch (error) {
+        refreshStatus(ctx, state);
+        return failure("lsp_hover", error);
+      }
+    },
+  });
+
+  pi.registerTool<typeof FilePositionParams, unknown>({
+    name: "lsp_definition",
+    label: "LSP Definition",
+    description: "Find definition locations for the symbol at a source position. line and column are 1-based.",
+    promptSnippet: "Jump to definitions for a symbol at a 1-based line and column.",
+    promptGuidelines: [
+      "Use lsp_definition before changing unfamiliar call sites, types, or imported symbols. Put line/column on the identifier token itself, not an import path string or surrounding syntax.",
+    ],
+    parameters: FilePositionParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const state = getState();
+      if (!state) return failure("lsp_definition", "LSP extension is not initialized.");
+      try {
+        const position = toLspPosition(params);
+        const result = formatDefinition(
+          await state.runtimeManager.definition(params.filePath, position.line, position.character),
+          state.resultCache,
+        );
+        refreshStatus(ctx, state);
+        return result;
+      } catch (error) {
+        refreshStatus(ctx, state);
+        return failure("lsp_definition", error);
+      }
+    },
+  });
+
+  pi.registerTool<typeof ReferencesParams, unknown>({
+    name: "lsp_references",
+    label: "LSP References",
+    description: "Find references for the symbol at a source position. line and column are 1-based.",
+    promptSnippet: "Find references for a symbol at a 1-based line and column.",
+    promptGuidelines: [
+      "Use lsp_references to assess impact before renames, API changes, or behavior changes. Put line/column on the identifier token itself; set includeDeclaration when you need the declaration included in the results.",
+    ],
+    parameters: ReferencesParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const state = getState();
+      if (!state) return failure("lsp_references", "LSP extension is not initialized.");
+      try {
+        const position = toLspPosition(params);
+        const result = formatReferences(
+          await state.runtimeManager.references(
+            params.filePath,
+            position.line,
+            position.character,
+            params.includeDeclaration ?? false,
+          ),
+          state.resultCache,
+        );
+        refreshStatus(ctx, state);
+        return result;
+      } catch (error) {
+        refreshStatus(ctx, state);
+        return failure("lsp_references", error);
+      }
+    },
+  });
+
+  pi.registerTool<typeof FilePathParams, unknown>({
+    name: "lsp_document_symbols",
+    label: "LSP Document Symbols",
+    description: "List symbols in a source file using its configured language server.",
+    promptSnippet: "List functions, classes, variables, and other symbols in a source file.",
+    promptGuidelines: [
+      "Use lsp_document_symbols to understand a file's semantic structure before broad edits or before reading a large unfamiliar file end-to-end.",
+    ],
+    parameters: FilePathParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const state = getState();
+      if (!state) return failure("lsp_document_symbols", "LSP extension is not initialized.");
+      try {
+        const result = formatDocumentSymbols(
+          await state.runtimeManager.documentSymbols(params.filePath),
+          state.resultCache,
+        );
+        refreshStatus(ctx, state);
+        return result;
+      } catch (error) {
+        refreshStatus(ctx, state);
+        return failure("lsp_document_symbols", error);
+      }
+    },
+  });
+
+  pi.registerTool<typeof WorkspaceSymbolsParams, unknown>({
+    name: "lsp_workspace_symbols",
+    label: "LSP Workspace Symbols",
+    description:
+      "Search symbols across active LSP workspaces. Optionally provide a server id to start/query that server for the current cwd.",
+    promptSnippet: "Search workspace symbols by name across active language-server sessions.",
+    promptGuidelines: [
+      "Use lsp_workspace_symbols to locate definitions or related symbols by name when file paths are unknown. Omit serverId to query active servers only; provide a configured serverId, such as vtsls or pyright, when you want to start/query a specific server for the current cwd.",
+    ],
+    parameters: WorkspaceSymbolsParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const state = getState();
+      if (!state) return failure("lsp_workspace_symbols", "LSP extension is not initialized.");
+      try {
+        const result = formatWorkspaceSymbols(
+          await state.runtimeManager.workspaceSymbols(params.query, params.serverId),
+          state.resultCache,
+          { query: params.query },
+        );
+        refreshStatus(ctx, state);
+        return result;
+      } catch (error) {
+        refreshStatus(ctx, state);
+        return failure("lsp_workspace_symbols", error);
+      }
+    },
+  });
+
+  pi.registerTool<typeof MoreParams, unknown>({
+    name: "lsp_more",
+    label: "LSP More Results",
+    description: "Return the next cached page from a previous paginated LSP result.",
+    promptSnippet:
+      "Fetch the next sequential page for a previous LSP resultId without re-querying the language server.",
+    promptGuidelines: [
+      "Use lsp_more only when the previous LSP result explicitly says 'More available' and provides a resultId. Cached pages are sequential and may expire after cache eviction or session restart; if a resultId is missing or expired, re-run the original LSP query.",
+    ],
+    parameters: MoreParams,
+    async execute(_toolCallId, params) {
+      const state = getState();
+      if (!state) return failure("lsp_more", "LSP extension is not initialized.");
+      return state.resultCache.next(params.resultId);
+    },
+  });
+}
+
+function refreshStatus(ctx: ExtensionContext | undefined, state: LspExtensionState): void {
+  if (ctx) setLspStatusLine(ctx, state);
+}

package/src/tools/registerLspWarmup.ts

@@ -0,0 +1,25 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { isToolCallEventType } from "@earendil-works/pi-coding-agent";
+import type { LspExtensionState } from "../state.js";
+import { setLspStatusLine } from "../statusLine.js";
+
+export type GetLspWarmupState = () => LspExtensionState | null;
+
+export function registerLspWarmup(pi: ExtensionAPI, getState: GetLspWarmupState): void {
+  pi.on("tool_call", (event, ctx) => {
+    const state = getState();
+    if (!state?.config.warmup) return;
+    if (!isToolCallEventType("read", event)) return;
+
+    const filePath = event.input.path;
+    if (typeof filePath !== "string" || filePath.length === 0) return;
+
+    const warmupState = state;
+    void warmupState.runtimeManager
+      .warmupFile(filePath)
+      .then((warmed) => {
+        if (warmed && getState() === warmupState) setLspStatusLine(ctx, warmupState);
+      })
+      .catch(() => undefined);
+  });
+}

package/src/tools/resultCache.ts

@@ -0,0 +1,162 @@
+import { randomUUID } from "node:crypto";
+
+export const MAX_LSP_RESULT_CACHE_BYTES = 64 * 1024 * 1024;
+export const MAX_LSP_RESULT_CACHE_ENTRIES = 128;
+export const LSP_RESULT_CACHE_TTL_MS = 15 * 60 * 1000;
+export const LSP_RESULT_ID_PREFIX = "lspres_";
+export const LSP_RESULT_ID_LENGTH = LSP_RESULT_ID_PREFIX.length + 36;
+export const LSP_RESULT_ID_PATTERN = `^${LSP_RESULT_ID_PREFIX}[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$`;
+
+const LSP_RESULT_ID_REGEX = new RegExp(LSP_RESULT_ID_PATTERN, "u");
+
+export interface LspCachedPage {
+  text: string;
+  details: unknown;
+}
+
+export interface StoreLspResultInput {
+  label: string;
+  pages: LspCachedPage[];
+}
+
+export interface LspResultCacheOptions {
+  maxBytes?: number;
+  maxEntries?: number;
+  ttlMs?: number;
+  now?: () => number;
+}
+
+export interface LspResultCacheStats {
+  entries: number;
+  bytes: number;
+  maxBytes: number;
+}
+
+interface CacheEntry {
+  id: string;
+  label: string;
+  pages: LspCachedPage[];
+  nextPageIndex: number;
+  bytes: number;
+  createdAt: number;
+  accessedAt: number;
+}
+
+export class LspResultCache {
+  private readonly maxBytes: number;
+  private readonly maxEntries: number;
+  private readonly ttlMs: number;
+  private readonly now: () => number;
+  private readonly entries = new Map<string, CacheEntry>();
+  private bytes = 0;
+
+  constructor(options: LspResultCacheOptions = {}) {
+    this.maxBytes = options.maxBytes ?? MAX_LSP_RESULT_CACHE_BYTES;
+    this.maxEntries = options.maxEntries ?? MAX_LSP_RESULT_CACHE_ENTRIES;
+    this.ttlMs = options.ttlMs ?? LSP_RESULT_CACHE_TTL_MS;
+    this.now = options.now ?? Date.now;
+  }
+
+  store(input: StoreLspResultInput): string | undefined {
+    this.evictExpired();
+    if (input.pages.length <= 1) return undefined;
+
+    const timestamp = this.now();
+    const entry: CacheEntry = {
+      id: `${LSP_RESULT_ID_PREFIX}${randomUUID()}`,
+      label: input.label,
+      pages: input.pages,
+      nextPageIndex: 1,
+      bytes: estimateBytes(input),
+      createdAt: timestamp,
+      accessedAt: timestamp,
+    };
+
+    if (entry.bytes > this.maxBytes) return undefined;
+
+    this.entries.set(entry.id, entry);
+    this.bytes += entry.bytes;
+    this.evictToBudget();
+    return this.entries.has(entry.id) ? entry.id : undefined;
+  }
+
+  next(resultId: string): { content: [{ type: "text"; text: string }]; details: unknown } {
+    if (!isLspResultId(resultId)) {
+      return toolResult("Invalid LSP resultId format. Use the exact resultId from a previous paginated LSP result.", {
+        ok: false,
+        error: "invalid-result-id",
+      });
+    }
+
+    this.evictExpired();
+    const entry = this.entries.get(resultId);
+    if (!entry) {
+      return toolResult(
+        "Cached LSP result not found or expired. Re-run the original LSP query to get a fresh resultId.",
+        {
+          ok: false,
+          resultId,
+          error: "not-found",
+        },
+      );
+    }
+
+    entry.accessedAt = this.now();
+    const page = entry.pages[entry.nextPageIndex];
+    if (!page) {
+      this.delete(resultId);
+      return toolResult(`No more cached LSP pages for ${resultId}.`, {
+        ok: true,
+        resultId,
+        done: true,
+      });
+    }
+
+    entry.nextPageIndex += 1;
+    return toolResult(page.text, page.details);
+  }
+
+  clear(): void {
+    this.entries.clear();
+    this.bytes = 0;
+  }
+
+  stats(): LspResultCacheStats {
+    this.evictExpired();
+    return { entries: this.entries.size, bytes: this.bytes, maxBytes: this.maxBytes };
+  }
+
+  private evictExpired(): void {
+    const cutoff = this.now() - this.ttlMs;
+    for (const [id, entry] of this.entries) {
+      if (entry.accessedAt < cutoff) this.delete(id);
+    }
+  }
+
+  private evictToBudget(): void {
+    while (this.entries.size > this.maxEntries || this.bytes > this.maxBytes) {
+      const oldest = [...this.entries.values()].sort((a, b) => a.accessedAt - b.accessedAt)[0];
+      if (!oldest) return;
+      this.delete(oldest.id);
+    }
+  }
+
+  private delete(id: string): void {
+    const entry = this.entries.get(id);
+    if (!entry) return;
+    this.entries.delete(id);
+    this.bytes = Math.max(0, this.bytes - entry.bytes);
+  }
+}
+
+export function isLspResultId(value: string): boolean {
+  return value.length === LSP_RESULT_ID_LENGTH && LSP_RESULT_ID_REGEX.test(value);
+}
+
+function estimateBytes(value: unknown): number {
+  return Buffer.byteLength(JSON.stringify(value), "utf8");
+}
+
+function toolResult(text: string, details: unknown): { content: [{ type: "text"; text: string }]; details: unknown } {
+  return { content: [{ type: "text", text }], details };
+}

package/src/ui/lspPanel.ts

@@ -0,0 +1,123 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import type { LspStatusSnapshot } from "../commands/status.js";
+
+export type LspPanelAction =
+  | { type: "doctor"; serverId: string }
+  | { type: "install"; serverId: string }
+  | { type: "update"; serverId: string }
+  | { type: "uninstall"; serverId: string }
+  | { type: "stop"; serverId?: string }
+  | { type: "refresh" }
+  | { type: "close" };
+
+export class LspPanel {
+  private selected = 0;
+  private readonly serverIds: string[];
+
+  constructor(
+    private readonly snapshot: LspStatusSnapshot,
+    private readonly theme: Theme,
+    private readonly done: (action: LspPanelAction) => void,
+  ) {
+    this.serverIds = Object.keys(snapshot.config.catalog.servers).sort();
+  }
+
+  handleInput(data: string): void {
+    if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
+      this.done({ type: "close" });
+      return;
+    }
+
+    if (matchesKey(data, "up")) {
+      this.selected = Math.max(0, this.selected - 1);
+      return;
+    }
+
+    if (matchesKey(data, "down")) {
+      this.selected = Math.min(Math.max(0, this.serverIds.length - 1), this.selected + 1);
+      return;
+    }
+
+    if (matchesKey(data, "return") || matchesKey(data, "enter")) {
+      this.withSelectedServer((serverId) => this.done({ type: "doctor", serverId }));
+      return;
+    }
+
+    if (data === "i") this.withSelectedServer((serverId) => this.done({ type: "install", serverId }));
+    if (data === "u") this.withSelectedServer((serverId) => this.done({ type: "update", serverId }));
+    if (data === "x") this.withSelectedServer((serverId) => this.done({ type: "uninstall", serverId }));
+    if (data === "s") this.withSelectedServer((serverId) => this.done({ type: "stop", serverId }));
+    if (data === "S") this.done({ type: "stop" });
+    if (data === "r") this.done({ type: "refresh" });
+  }
+
+  render(width: number): string[] {
+    const panelWidth = Math.min(Math.max(60, width), 100);
+    const innerWidth = panelWidth - 2;
+    const lines: string[] = [];
+    const border = (text: string) => this.theme.fg("border", text);
+    const row = (content = "") => border("│") + padVisible(` ${content}`, innerWidth) + border("│");
+
+    lines.push(border(`╭${centerTitle(" LSP ", innerWidth)}╮`));
+    lines.push(
+      row(
+        `installMode: ${this.snapshot.config.installMode}  warmup: ${this.snapshot.config.warmup ? "on" : "off"}  tracked pids: ${this.snapshot.processes.length}`,
+      ),
+    );
+
+    if (this.snapshot.config.warnings.length > 0) {
+      lines.push(row(this.theme.fg("warning", `${this.snapshot.config.warnings.length} config warning(s)`)));
+    }
+
+    lines.push(border(`├${"─".repeat(innerWidth)}┤`));
+
+    if (this.serverIds.length === 0) {
+      lines.push(row(this.theme.fg("dim", "No LSP servers configured")));
+    } else {
+      for (const [index, serverId] of this.serverIds.entries()) {
+        const server = this.snapshot.config.catalog.servers[serverId]!;
+        const installed = this.snapshot.lockfile.servers[serverId]
+          ? this.theme.fg("success", "installed")
+          : this.theme.fg("warning", "missing");
+        const pidCount = this.snapshot.processes.filter((process) => process.serverId === serverId).length;
+        const pointer = index === this.selected ? this.theme.fg("accent", "▶") : " ";
+        const label = index === this.selected ? this.theme.fg("accent", serverId) : serverId;
+        lines.push(
+          row(`${pointer} ${label} ${this.theme.fg("dim", server.displayName)} ${installed} pids:${pidCount}`),
+        );
+      }
+    }
+
+    lines.push(border(`├${"─".repeat(innerWidth)}┤`));
+    lines.push(
+      row(
+        this.theme.fg(
+          "dim",
+          "↑↓ select • enter doctor • i install • u update • x uninstall • s stop • r refresh • esc close",
+        ),
+      ),
+    );
+    lines.push(border(`╰${"─".repeat(innerWidth)}╯`));
+
+    return lines.map((line) => truncateToWidth(line, width));
+  }
+
+  invalidate(): void {}
+
+  private withSelectedServer(callback: (serverId: string) => void): void {
+    const serverId = this.serverIds[this.selected];
+    if (serverId) callback(serverId);
+  }
+}
+
+function centerTitle(title: string, width: number): string {
+  const left = Math.max(0, Math.floor((width - visibleWidth(title)) / 2));
+  const right = Math.max(0, width - visibleWidth(title) - left);
+  return `${"─".repeat(left)}${title}${"─".repeat(right)}`;
+}
+
+function padVisible(value: string, width: number): string {
+  const truncated = truncateToWidth(value, width, "…", true);
+  return truncated + " ".repeat(Math.max(0, width - visibleWidth(truncated)));
+}

package/src/util/deepMerge.ts

@@ -0,0 +1,38 @@
+import { isPlainObject } from "./helpers.js";
+
+export function deepClone<T>(value: T): T {
+  if (Array.isArray(value)) {
+    return value.map((item) => deepClone(item)) as T;
+  }
+
+  if (isPlainObject(value)) {
+    const cloned: Record<string, unknown> = {};
+    for (const [key, item] of Object.entries(value)) {
+      cloned[key] = deepClone(item);
+    }
+    return cloned as T;
+  }
+
+  return value;
+}
+
+export function deepMerge<T>(base: T, override: unknown): T {
+  if (override === undefined) {
+    return deepClone(base);
+  }
+
+  if (Array.isArray(override) || !isPlainObject(override)) {
+    return deepClone(override) as T;
+  }
+
+  if (!isPlainObject(base)) {
+    return deepClone(override) as T;
+  }
+
+  const merged: Record<string, unknown> = deepClone(base);
+  for (const [key, value] of Object.entries(override)) {
+    merged[key] = deepMerge(merged[key], value);
+  }
+
+  return merged as T;
+}

package/src/util/errors.ts

@@ -0,0 +1,22 @@
+export class ConfigError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = new.target.name;
+  }
+}
+
+export class MissingEnvironmentVariableError extends ConfigError {
+  constructor(variableName: string, field?: string) {
+    super(
+      field
+        ? `Missing environment variable ${variableName} referenced by ${field}.`
+        : `Missing environment variable ${variableName}.`,
+    );
+  }
+}
+
+export class MissingBinaryError extends ConfigError {
+  constructor(serverId: string, command: string) {
+    super(`${serverId} binary not found: ${command}`);
+  }
+}

package/src/util/hash.ts

@@ -0,0 +1,10 @@
+import { createHash } from "node:crypto";
+import { resolve } from "node:path";
+
+export function stableHash(value: string, length = 16): string {
+  return createHash("sha256").update(value).digest("hex").slice(0, length);
+}
+
+export function hashPath(path: string, length = 16): string {
+  return stableHash(resolve(path), length);
+}

package/src/util/helpers.ts

@@ -0,0 +1,41 @@
+import { access } from "node:fs/promises";
+
+export function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function isNodeError(error: unknown): error is NodeJS.ErrnoException {
+  return typeof error === "object" && error !== null && "code" in error;
+}
+
+export function messageFromError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export function delay(ms: number): Promise<void> {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
+}
+
+export function normalizeProcessEnv(env: NodeJS.ProcessEnv): Record<string, string> {
+  const normalized: Record<string, string> = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (typeof value === "string") {
+      normalized[key] = value;
+    }
+  }
+  return normalized;
+}
+
+export async function pathExists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function isPythonServerId(serverId: string): boolean {
+  return serverId === "pyright" || serverId === "basedpyright";
+}