@trim21/personal-pi-extensions 0.0.308 → 0.0.310

package/README.md

@@ -344,6 +344,50 @@ pi -e ./src/talk/index.ts
 
 ---
 
+## LSP 配置
+
+read/edit/write 工具内置 LSP 诊断（写文件后等待并报告 ERROR 级诊断）。LSP protocol 是统一的，因此服务器不需要为每个语言写 adapter：用一份 JSON 配置声明如何启动即可。
+
+配置文件（项目优先于全局，逐字段覆盖）：
+
+- `~/.pi/agent/lsp.json`（全局）
+- `.pi/lsp.json`（项目）
+
+```jsonc
+{
+  "version": 1,
+  "servers": {
+    "gopls": {
+      "include": ["**/*.go"],
+      "rootMarkers": ["go.mod"],
+      "bin": "gopls",
+      "args": [],
+      "cwd": "{root}", // 支持 {root} / {cwd} 模板
+      "languageIdByExtension": { ".go": "go" },
+      "startupTimeoutMs": 45000,
+      "diagnosticsWaitMs": 1500,
+      "initializationOptions": {}, // → initialize 请求
+      "settings": {}, // → didChangeConfiguration / workspace/configuration 请求
+    },
+  },
+}
+```
+
+字段说明：
+
+- `include`：文件 glob，相对项目根或调用 cwd，任一命中即启用；支持 `!` 否定排除，如 `["**/*.go", "!**/*_test.go"]`
+- `rootMarkers`：项目根标记文件，从文件目录向上查找；缺省用调用 cwd 作为根
+- `bin`：可执行文件——绝对路径、相对调用 cwd 的路径，或名字（先在项目内 `node_modules/.bin`、`.venv/bin`、`venv/bin` 找，再走 PATH）
+- `languageIdByExtension`：扩展名 → LSP languageId（didOpen 用）；缺省回退内置映射表
+- `startupTimeoutMs` / `diagnosticsWaitMs`：per-server 超时，覆盖全局配置与默认值
+- `initializationOptions` 与 `settings` 按 LSP 语义分离：前者进 initialize 请求，后者进 didChangeConfiguration / workspace/configuration 请求
+
+内置默认服务器（typescript / pyright / ruff / clangd）始终存在；`servers` 以 key 为服务器 id 与默认合并——同 key 覆盖、新 key 新增、`"enabled": false` 移除（如 `"clangd": { "enabled": false }`）。executable 的发现逻辑（如 tsserver 路径、venv 里的 python）不内置，需要时用 `bin` / `args` / `settings` 自行表达。
+
+旧的 `enabled`（白名单）/ `disabled`（排除）与全局超时字段（`initializeTimeoutMs` 等）继续可用。
+
+---
+
 ## 安装
 
 ### 通过 npm/git 包

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trim21/personal-pi-extensions",
-  "version": "0.0.308",
+  "version": "0.0.310",
   "type": "module",
   "description": "Custom pi coding-agent extensions: bwrap sandbox, workspace guard, opencode edit, and more",
   "keywords": [
@@ -85,9 +85,10 @@
     "node": ">=24"
   },
   "dependencies": {
-    "@cortexkit/aft-bridge": "0.51.0",
+    "@cortexkit/aft-bridge": "0.51.2",
     "@vscode/tree-sitter-wasm": "^0.3.1",
     "jsonc-parser": "^3.3.1",
+    "minimatch": "^10.2.6",
     "vscode-jsonrpc": "^9.0.1",
     "vscode-languageserver-types": "^3.18.0",
     "web-tree-sitter": "^0.26.12"

package/src/lib/lsp/adapter.ts

@@ -12,13 +12,22 @@ import { exists, walkUp } from "./bin.js";
 
 export interface LspServerHandle {
   process: ChildProcessWithoutNullStreams;
+  /** initialize 请求的 initializationOptions。 */
   initialization?: Record<string, unknown>;
+  /** didChangeConfiguration / workspace/configuration 的 settings；缺省回退 initialization。 */
+  settings?: Record<string, unknown>;
+  /** didOpen 的 per-server languageId 映射；缺省回退内置 LANGUAGE_EXTENSIONS 表。 */
+  languageIds?: Record<string, string>;
 }
 
 export interface LspServerAdapter {
   readonly id: string;
   /** 关联的文件扩展名（含点，小写）；空数组表示匹配所有文件。 */
   readonly extensions: readonly string[];
+  /** per-server initialize 握手超时（ms）；缺省用全局配置 / client 默认。 */
+  readonly startupTimeoutMs?: number;
+  /** per-server 诊断等待时长（ms）；缺省用全局配置 / client 默认。 */
+  readonly diagnosticsWaitMs?: number;
   findRoot(file: string, cwd: string): Promise<string | undefined>;
   spawn(root: string, cwd: string): Promise<LspServerHandle | undefined>;
 }

package/src/lib/lsp/bin.ts

@@ -62,19 +62,6 @@ export function findBinaryInWorkspace(
   return Promise.resolve(undefined);
 }
 
-/** 从 fromDir 向上（到 stopDir）找 node_modules/<modulePath>（如 typescript/lib/tsserver.js）。 */
-export function findModuleInWorkspace(
-  modulePath: string,
-  fromDir: string,
-  stopDir: string,
-): Promise<string | undefined> {
-  for (const dir of walkUp(fromDir, stopDir)) {
-    const candidate = join(dir, "node_modules", modulePath);
-    if (exists(candidate)) return Promise.resolve(candidate);
-  }
-  return Promise.resolve(undefined);
-}
-
 /** PATH 查找（同步，逻辑简单；调用频率低，无需缓存）。 */
 export function which(cmd: string): string | undefined {
   const pathDirs = (process.env.PATH ?? "").split(delimiter).filter(Boolean);

package/src/lib/lsp/client.ts

@@ -232,7 +232,9 @@ export async function create(input: CreateInput): Promise<LspClient> {
   connection.onRequest("window/workDoneProgress/create", () => null);
   connection.onRequest("workspace/configuration", (params) => {
     const items = (params as { items?: { section?: string }[] }).items ?? [];
-    return items.map((item) => configurationValue(input.server.initialization, item.section));
+    return items.map((item) =>
+      configurationValue(input.server.settings ?? input.server.initialization, item.section),
+    );
   });
   connection.onRequest("client/registerCapability", (params) => {
     const registrations =
@@ -296,10 +298,9 @@ export async function create(input: CreateInput): Promise<LspClient> {
 
   await connection.sendNotification("initialized", {});
 
-  if (input.server.initialization) {
-    await connection.sendNotification("workspace/didChangeConfiguration", {
-      settings: input.server.initialization,
-    });
+  const settings = input.server.settings ?? input.server.initialization;
+  if (settings) {
+    await connection.sendNotification("workspace/didChangeConfiguration", { settings });
   }
 
   const files: Record<string, { version: number; text: string }> = {};
@@ -618,7 +619,9 @@ export async function create(input: CreateInput): Promise<LspClient> {
           isAbsolute(request.path) ? request.path : resolve(input.directory, request.path),
         );
         const text = await readFile(resolvedPath, "utf8");
-        const languageId = LANGUAGE_EXTENSIONS[extname(resolvedPath)] ?? "plaintext";
+        const extension = extname(resolvedPath);
+        const languageId =
+          input.server.languageIds?.[extension] ?? LANGUAGE_EXTENSIONS[extension] ?? "plaintext";
         const uri = pathToFileURL(resolvedPath).href;
 
         const document = files[resolvedPath];

package/src/lib/lsp/lsp.ts

@@ -4,8 +4,9 @@
  * - state（client 缓存、broken 集合、spawning 去重）是 createLspService 的
  *   闭包变量，不做成模块级全局；
  * - 配置来源：全局 `~/.pi/agent/lsp.json` + 本地 `<cwd>/.pi/lsp.json`
- *   （本地逐字段覆盖全局）：`enabled` 白名单（缺省全部）、`disabled` 排除
- *   （缺省无），以及各超时参数；配置在每个工具的调用 cwd 下惰性读取；
+ *   （本地逐字段覆盖全局）：`servers` 数组配置驱动地定义语言服务器
+ *   （按 id 与内置默认服务器合并），`enabled`/`disabled` 白名单与各超时
+ *   参数继续生效；配置在每个工具的调用 cwd 下惰性读取；
  * - client 按 (root, serverID) 缓存，并发 spawn 去重，启动失败记入 broken
  *   集合（服务实例生命周期内不再重试）；
  * - 工具只与 touchFile / diagnostics / lspDiagnosticsForFile 三个方法打交道。
@@ -20,15 +21,19 @@ import { type Static, Type } from "typebox";
 import { Value } from "typebox/value";
 
 import { type LspServerAdapter } from "./adapter.js";
-import { createAdapters } from "./adapters/index.js";
 import { create, type CreateInput, type Diagnostic, type Info as LspClient } from "./client.js";
 import { report } from "./diagnostic.js";
+import { createAdapters, serverConfigSchema } from "./server-config.js";
 
 /** 超时值：number（毫秒，>=1）或字符串（"500"、"5s"、"1m"），Parse 后由 toMs 统一换算。 */
 const timeoutValue = Type.Union([Type.Number({ minimum: 1 }), Type.String()]);
 
 /** lsp.json 的配置项（全局与本地同构）。 */
 const lspConfigSchema = Type.Object({
+  /** 配置文件版本（当前 1）；未知版本会被 typebox 严格校验拒绝并回退空配置。 */
+  version: Type.Optional(Type.Number()),
+  /** 配置驱动的语言服务器定义（id → 配置）；按 id 与内置默认服务器合并（覆盖/enabled:false 禁用）。 */
+  servers: Type.Optional(Type.Record(Type.String(), serverConfigSchema)),
   /** 只启用列出的服务器 id（缺省 = 全部启用）。 */
   enabled: Type.Optional(Type.Array(Type.String())),
   /** 从启用集中排除的服务器 id（缺省 = 无）。 */
@@ -123,7 +128,6 @@ export function filterAdapters(
 
 interface LspState {
   clients: LspClient[];
-  adapters: LspServerAdapter[];
   broken: Set<string>;
   spawning: Map<string, Promise<LspClient | undefined>>;
 }
@@ -144,16 +148,16 @@ function containsPath(file: string, cwd: string): boolean {
 
 /**
  * 创建 LSP 服务实例。state 由闭包持有；adapters 可注入（测试传 [] 或
- * mock adapters 即可隔离真实服务器）。globalConfigPath 供测试注入
- * 固定的全局配置路径，避免被本机 ~/.pi/agent/lsp.json 影响。
+ * mock adapters 即可隔离真实服务器），不注入时按配置文件 servers 与
+ * 内置默认服务器合并构建。globalConfigPath 供测试注入固定的全局配置
+ * 路径，避免被本机 ~/.pi/agent/lsp.json 影响。
  */
 export function createLspService(
-  adapters: LspServerAdapter[] = createAdapters(),
+  adapters?: LspServerAdapter[],
   globalConfigPath?: string,
 ): LspService {
   const state: LspState = {
     clients: [],
-    adapters,
     broken: new Set(),
     spawning: new Map(),
   };
@@ -162,11 +166,11 @@ export function createLspService(
     if (!containsPath(file, cwd)) return [];
     const config = await loadLspConfig(cwd, globalConfigPath);
     const timeout = timeoutOptions(config);
-    const adapters = filterAdapters(state.adapters, config);
+    const active = filterAdapters(adapters ?? createAdapters(config.servers), config);
     const extension = extname(file) || file;
     const result: LspClient[] = [];
 
-    for (const adapter of adapters) {
+    for (const adapter of active) {
       if (adapter.extensions.length > 0 && !adapter.extensions.includes(extension)) continue;
       const root = await adapter.findRoot(file, cwd);
       if (!root) continue;
@@ -199,6 +203,9 @@ export function createLspService(
             root,
             directory: cwd,
             ...timeout,
+            initializeTimeoutMs: adapter.startupTimeoutMs ?? timeout.initializeTimeoutMs,
+            diagnosticsDocumentWaitTimeoutMs:
+              adapter.diagnosticsWaitMs ?? timeout.diagnosticsDocumentWaitTimeoutMs,
           });
           const duplicate = state.clients.find((c) => c.root === root && c.serverID === adapter.id);
           if (duplicate) {

package/src/lib/lsp/server-config.ts

@@ -0,0 +1,219 @@
+/**
+ * 配置驱动的 LSP 服务器：一份 JSON 配置定义一个语言服务器（bin/args/rootMarkers/
+ * languageId/超时等），替代为每个语言写一个 adapter class。
+ *
+ * 配置文件沿用 lsp.json（全局 ~/.pi/agent/lsp.json + 本地 <cwd>/.pi/lsp.json）：
+ * 顶层 `servers` 是 id → 配置的 record，按 id 与内置默认服务器合并
+ * （覆盖同名、新增 id、enabled:false 禁用），之后仍受现有 enabled/disabled
+ * 白名单过滤。
+ *
+ * executable 发现统一由用户配置：bin 支持绝对路径 / 项目工作区
+ * （node_modules/.bin、.venv/bin、venv/bin）/ PATH，不再内置各语言的
+ * 特殊探测逻辑（tsserver 路径、venv python 等）。
+ */
+
+import { existsSync } from "node:fs";
+import { isAbsolute, join, relative, sep } from "node:path";
+
+import { minimatch } from "minimatch";
+import { type Static, Type } from "typebox";
+
+import { type LspServerAdapter, type LspServerHandle, nearestRoot } from "./adapter.js";
+import { exists, findBinaryInWorkspace, which } from "./bin.js";
+import { spawnProcess } from "./launch.js";
+
+export const serverConfigSchema = Type.Object({
+  /** false = 从启用集中移除（覆盖同名内置服务器）；缺省启用。 */
+  enabled: Type.Optional(Type.Boolean()),
+  /** 文件 glob（相对项目根或调用 cwd，任一命中即可）；缺省匹配所有文件。 */
+  include: Type.Optional(Type.Array(Type.String())),
+  /** 项目根标记文件（从文件目录向上查找）；缺省用调用 cwd 作为根。 */
+  rootMarkers: Type.Optional(Type.Array(Type.String())),
+  /** 可执行文件：绝对路径、相对调用 cwd 的路径，或名字（项目工作区优先，PATH 兜底）。 */
+  bin: Type.Optional(Type.String()),
+  args: Type.Optional(Type.Array(Type.String())),
+  /** 启动工作目录，支持 {root} / {cwd} 模板；缺省 {root}。 */
+  cwd: Type.Optional(Type.String()),
+  /** 文件扩展名（含点）→ LSP languageId，didOpen 用；缺省回退内置映射表。 */
+  languageIdByExtension: Type.Optional(Type.Record(Type.String(), Type.String())),
+  /** initialize 握手超时（ms）；缺省用全局配置 / client 默认。 */
+  startupTimeoutMs: Type.Optional(Type.Number({ minimum: 1 })),
+  /** 写文件后等待诊断的时长（ms）；缺省用全局配置 / client 默认。 */
+  diagnosticsWaitMs: Type.Optional(Type.Number({ minimum: 1 })),
+  /** initialize 请求的 initializationOptions。 */
+  initializationOptions: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+  /** didChangeConfiguration / workspace/configuration 请求的 settings。 */
+  settings: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+});
+
+export type ServerConfig = Static<typeof serverConfigSchema>;
+
+/** 内置默认服务器（id → 配置，可被用户配置按 id 覆盖，全量字段均可配置化表达）。 */
+export const defaultServers: Record<string, ServerConfig> = {
+  typescript: {
+    include: ["**/*.{ts,tsx,js,jsx,mjs,cjs,mts,cts}"],
+    rootMarkers: ["package-lock.json", "pnpm-lock.yaml", "yarn.lock", "bun.lock", "bun.lockb"],
+    bin: "typescript-language-server",
+    args: ["--stdio"],
+    cwd: "{root}",
+    languageIdByExtension: {
+      ".ts": "typescript",
+      ".tsx": "typescriptreact",
+      ".js": "javascript",
+      ".jsx": "javascriptreact",
+      ".mjs": "javascript",
+      ".cjs": "javascript",
+      ".mts": "typescript",
+      ".cts": "typescript",
+    },
+  },
+  pyright: {
+    include: ["**/*.py", "**/*.pyi"],
+    rootMarkers: [
+      "pyproject.toml",
+      "setup.py",
+      "setup.cfg",
+      "requirements.txt",
+      "Pipfile",
+      "pyrightconfig.json",
+    ],
+    bin: "pyright-langserver",
+    args: ["--stdio"],
+    cwd: "{root}",
+    languageIdByExtension: { ".py": "python", ".pyi": "python" },
+  },
+  ruff: {
+    include: ["**/*.py", "**/*.pyi"],
+    rootMarkers: ["pyproject.toml", "ruff.toml", ".ruff.toml"],
+    bin: "ruff",
+    args: ["server"],
+    cwd: "{root}",
+    languageIdByExtension: { ".py": "python", ".pyi": "python" },
+  },
+  clangd: {
+    include: ["**/*.{c,h,cpp,hpp,cc,cxx,c++,hh,hxx,h++}"],
+    rootMarkers: ["compile_commands.json", "compile_flags.txt", ".clangd"],
+    bin: "clangd",
+    args: ["--background-index", "--clang-tidy"],
+    cwd: "{root}",
+    languageIdByExtension: {
+      ".c": "c",
+      ".h": "c",
+      ".cpp": "cpp",
+      ".hpp": "cpp",
+      ".cc": "cpp",
+      ".cxx": "cpp",
+      ".c++": "cpp",
+      ".hh": "cpp",
+      ".hxx": "cpp",
+      ".h++": "cpp",
+    },
+  },
+};
+
+/** 用户 servers（id → 配置）与默认配置合并：覆盖同名、新增 id、enabled:false 移除。 */
+export function mergeServerConfigs(
+  defaults: Readonly<Record<string, ServerConfig>>,
+  user: Readonly<Record<string, ServerConfig>> | undefined,
+): Record<string, ServerConfig> {
+  if (!user) return { ...defaults };
+  const merged = { ...defaults };
+  for (const [id, server] of Object.entries(user)) {
+    if (server.enabled === false) {
+      delete merged[id];
+      continue;
+    }
+    merged[id] = server;
+  }
+  return merged;
+}
+
+/** {root} / {cwd} 模板替换（bin / cwd 字段均支持）。 */
+function resolveTemplate(template: string, root: string, cwd: string): string {
+  return template.split("{root}").join(root).split("{cwd}").join(cwd);
+}
+
+/** 解析可执行文件：绝对/相对路径直接用；名字走项目工作区（node_modules/.bin 等）→ PATH。 */
+async function resolveBinary(bin: string, root: string, cwd: string): Promise<string | undefined> {
+  if (isAbsolute(bin)) return existsSync(bin) ? bin : undefined;
+  if (bin.includes("/") || bin.includes("\\")) {
+    const relativePath = join(cwd, bin);
+    return exists(relativePath) ? relativePath : undefined;
+  }
+  return (await findBinaryInWorkspace(bin, root, cwd)) ?? which(bin);
+}
+
+/**
+ * include glob 匹配：相对项目根或调用 cwd 的路径，任一命中即可。
+ * 支持 `!` 否定模式排除；多 pattern 数组拆开判断（任意 positive 命中且
+ * 不被任何 negative 排除），避免库对混合数组的语义差异。
+ */
+function matchesInclude(
+  patterns: readonly string[],
+  file: string,
+  root: string,
+  cwd: string,
+): boolean {
+  if (patterns.length === 0) return true;
+  const positives: string[] = [];
+  const negatives: string[] = [];
+  for (const pattern of patterns) {
+    if (pattern.startsWith("!")) negatives.push(pattern.slice(1));
+    else positives.push(pattern);
+  }
+  if (positives.length === 0) positives.push("**");
+  const candidates = [relative(root, file), relative(cwd, file)]
+    .map((p) => p.split(sep).join("/"))
+    .filter((p) => !p.startsWith(".."));
+  const matches = (candidate: string): boolean =>
+    positives.some((pattern) => minimatch(candidate, pattern)) &&
+    negatives.every((pattern) => !minimatch(candidate, pattern));
+  return candidates.some((candidate) => matches(candidate));
+}
+
+/** 由配置构建的通用 adapter；include 精确过滤在 findRoot 完成，extensions 不设扩展名过滤。 */
+export class ConfigAdapter implements LspServerAdapter {
+  readonly id: string;
+  readonly extensions: readonly string[] = [];
+  readonly startupTimeoutMs: number | undefined;
+  readonly diagnosticsWaitMs: number | undefined;
+  readonly config: ServerConfig;
+
+  constructor(id: string, config: ServerConfig) {
+    this.id = id;
+    this.config = config;
+    this.startupTimeoutMs = config.startupTimeoutMs;
+    this.diagnosticsWaitMs = config.diagnosticsWaitMs;
+  }
+
+  findRoot(file: string, cwd: string): Promise<string | undefined> {
+    const root = nearestRoot(this.config.rootMarkers ?? [], file, cwd);
+    return root.then((resolved) =>
+      matchesInclude(this.config.include ?? [], file, resolved, cwd) ? resolved : undefined,
+    );
+  }
+
+  async spawn(root: string, cwd: string): Promise<LspServerHandle | undefined> {
+    const bin = this.config.bin;
+    if (!bin) return undefined;
+    const resolved = await resolveBinary(bin, root, cwd);
+    if (!resolved) return undefined;
+    return {
+      process: spawnProcess(resolved, this.config.args ?? [], {
+        cwd: resolveTemplate(this.config.cwd ?? "{root}", root, cwd),
+      }),
+      initialization: this.config.initializationOptions,
+      settings: this.config.settings,
+      languageIds: this.config.languageIdByExtension,
+    };
+  }
+}
+
+/** 组装启用的服务器列表：默认配置 + 用户 servers（id → 配置）合并。 */
+export function createAdapters(
+  userServers?: Readonly<Record<string, ServerConfig>>,
+): LspServerAdapter[] {
+  return Object.entries(mergeServerConfigs(defaultServers, userServers)).map(
+    ([id, config]) => new ConfigAdapter(id, config),
+  );
+}

package/src/lib/lsp/adapters/clangd.ts

@@ -1,26 +0,0 @@
-/**
- * C/C++ LSP 服务器（clangd，随 LLVM/clang 工具链安装，走 PATH）。
- */
-
-import { type LspServerAdapter, type LspServerHandle, nearestRoot } from "../adapter.js";
-import { which } from "../bin.js";
-import { spawnProcess } from "../launch.js";
-
-const PROJECT_MARKERS = ["compile_commands.json", "compile_flags.txt", ".clangd"];
-
-export class ClangdAdapter implements LspServerAdapter {
-  readonly id = "clangd";
-  readonly extensions = [".c", ".cpp", ".cc", ".cxx", ".c++", ".h", ".hpp", ".hh", ".hxx", ".h++"];
-
-  findRoot(file: string, cwd: string): Promise<string> {
-    return nearestRoot(PROJECT_MARKERS, file, cwd);
-  }
-
-  spawn(root: string): Promise<LspServerHandle | undefined> {
-    const bin = which("clangd");
-    if (!bin) return Promise.resolve(undefined);
-    return Promise.resolve({
-      process: spawnProcess(bin, ["--background-index", "--clang-tidy"], { cwd: root }),
-    });
-  }
-}

package/src/lib/lsp/adapters/index.ts

@@ -1,11 +0,0 @@
-import { ClangdAdapter } from "./clangd.js";
-import { PyrightAdapter } from "./pyright.js";
-import { RuffAdapter } from "./ruff.js";
-import { TypescriptAdapter } from "./typescript.js";
-
-export type { LspServerAdapter, LspServerHandle } from "../adapter.js";
-
-/** 组装启用的服务器列表（新增语言：实现 adapter 后在这里注册）。 */
-export function createAdapters() {
-  return [new TypescriptAdapter(), new PyrightAdapter(), new RuffAdapter(), new ClangdAdapter()];
-}

package/src/lib/lsp/adapters/pyright.ts

@@ -1,50 +0,0 @@
-/**
- * Python 类型检查 LSP 服务器（pyright-langserver）。
- * pythonPath 优先取 VIRTUAL_ENV，其次项目 .venv / venv 里的解释器。
- */
-
-import { join } from "node:path";
-
-import { type LspServerAdapter, nearestRoot } from "../adapter.js";
-import { exists, findBinaryInWorkspace, which } from "../bin.js";
-import { spawnProcess } from "../launch.js";
-
-const PROJECT_MARKERS = [
-  "pyproject.toml",
-  "setup.py",
-  "setup.cfg",
-  "requirements.txt",
-  "Pipfile",
-  "pyrightconfig.json",
-];
-
-export class PyrightAdapter implements LspServerAdapter {
-  readonly id = "pyright";
-  readonly extensions = [".py", ".pyi"];
-
-  findRoot(file: string, cwd: string): Promise<string> {
-    return nearestRoot(PROJECT_MARKERS, file, cwd);
-  }
-
-  async spawn(root: string, cwd: string) {
-    const bin =
-      (await findBinaryInWorkspace("pyright-langserver", root, cwd)) ?? which("pyright-langserver");
-    if (!bin) return;
-
-    const initialization: Record<string, string> = {};
-    const venvs = [process.env.VIRTUAL_ENV, join(root, ".venv"), join(root, "venv")];
-    for (const venv of venvs) {
-      if (!venv) continue;
-      const python = join(venv, process.platform === "win32" ? "Scripts" : "bin", "python");
-      if (exists(python)) {
-        initialization.pythonPath = python;
-        break;
-      }
-    }
-
-    return {
-      process: spawnProcess(bin, ["--stdio"], { cwd: root }),
-      initialization,
-    };
-  }
-}

package/src/lib/lsp/adapters/ruff.ts

@@ -1,27 +0,0 @@
-/**
- * Python lint LSP 服务器（ruff 内置的 `ruff server`）。
- * 二进制优先项目 .venv / venv，其次 PATH。
- */
-
-import { type LspServerAdapter, nearestRoot } from "../adapter.js";
-import { findBinaryInWorkspace, which } from "../bin.js";
-import { spawnProcess } from "../launch.js";
-
-const PROJECT_MARKERS = ["pyproject.toml", "ruff.toml", ".ruff.toml"];
-
-export class RuffAdapter implements LspServerAdapter {
-  readonly id = "ruff";
-  readonly extensions = [".py", ".pyi"];
-
-  findRoot(file: string, cwd: string): Promise<string> {
-    return nearestRoot(PROJECT_MARKERS, file, cwd);
-  }
-
-  async spawn(root: string, cwd: string) {
-    const bin = (await findBinaryInWorkspace("ruff", root, cwd)) ?? which("ruff");
-    if (!bin) return;
-    return {
-      process: spawnProcess(bin, ["server"], { cwd: root }),
-    };
-  }
-}

package/src/lib/lsp/adapters/typescript.ts

@@ -1,34 +0,0 @@
-/**
- * TypeScript / JavaScript LSP 服务器（typescript-language-server）。
- * tsserver 路径解析自项目工作区的 node_modules，语言服务器二进制同样
- * 工作区优先、PATH 兜底。
- */
-
-import { type LspServerAdapter, nearestRoot } from "../adapter.js";
-import { findBinaryInWorkspace, findModuleInWorkspace, which } from "../bin.js";
-import { spawnProcess } from "../launch.js";
-
-const LOCK_FILES = ["package-lock.json", "pnpm-lock.yaml", "yarn.lock", "bun.lock", "bun.lockb"];
-
-export class TypescriptAdapter implements LspServerAdapter {
-  readonly id = "typescript";
-  readonly extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"];
-
-  findRoot(file: string, cwd: string): Promise<string> {
-    return nearestRoot(LOCK_FILES, file, cwd);
-  }
-
-  async spawn(root: string, cwd: string) {
-    // typescript-language-server 依赖项目里的 tsserver（本身不带）
-    const tsserver = await findModuleInWorkspace("typescript/lib/tsserver.js", root, cwd);
-    if (!tsserver) return;
-    const bin =
-      (await findBinaryInWorkspace("typescript-language-server", root, cwd)) ??
-      which("typescript-language-server");
-    if (!bin) return;
-    return {
-      process: spawnProcess(bin, ["--stdio"], { cwd: root }),
-      initialization: { tsserver: { path: tsserver } },
-    };
-  }
-}