@trim21/personal-pi-extensions 0.0.299 → 0.0.301

package/src/lib/lsp/diagnostic.ts

@@ -0,0 +1,35 @@
+/**
+ * 诊断报告格式化（移植自 opencode lsp/diagnostic.ts）：只报告 ERROR
+ * 级诊断，每个文件最多 20 条。
+ */
+
+import type { Diagnostic } from "./client.js";
+
+const MAX_PER_FILE = 20;
+
+const SEVERITY_LABELS: Record<number, string> = {
+  1: "ERROR",
+  2: "WARN",
+  3: "INFO",
+  4: "HINT",
+};
+
+export function prettyDiagnostic(diagnostic: Diagnostic): string {
+  const severity = SEVERITY_LABELS[diagnostic.severity || 1] ?? "ERROR";
+  const line = diagnostic.range.start.line + 1;
+  const col = diagnostic.range.start.character + 1;
+  // 3.18 起 message 可能是 MarkupContent（客户端未声明 markupMessageSupport 时不会出现）
+  const message =
+    typeof diagnostic.message === "string" ? diagnostic.message : diagnostic.message.value;
+  return `${severity} [${line}:${col}] ${message}`;
+}
+
+/** 返回空字符串表示没有 ERROR 级诊断。 */
+export function report(file: string, issues: Diagnostic[]): string {
+  const errors = issues.filter((item) => item.severity === 1);
+  if (errors.length === 0) return "";
+  const limited = errors.slice(0, MAX_PER_FILE);
+  const more = errors.length - MAX_PER_FILE;
+  const suffix = more > 0 ? `\n... and ${more} more` : "";
+  return `<diagnostics file="${file}">\n${limited.map((d) => prettyDiagnostic(d)).join("\n")}${suffix}\n</diagnostics>`;
+}

package/src/lib/lsp/language.ts

@@ -0,0 +1,125 @@
+/**
+ * 文件扩展名 → LSP languageId 映射，用于 didOpen 通知。
+ * 移植自 opencode packages/opencode/src/lsp/language.ts。
+ */
+export const LANGUAGE_EXTENSIONS: Record<string, string> = {
+  ".abap": "abap",
+  ".bat": "bat",
+  ".bib": "bibtex",
+  ".bibtex": "bibtex",
+  ".clj": "clojure",
+  ".cljs": "clojure",
+  ".cljc": "clojure",
+  ".edn": "clojure",
+  ".coffee": "coffeescript",
+  ".c": "c",
+  ".cpp": "cpp",
+  ".cxx": "cpp",
+  ".cc": "cpp",
+  ".c++": "cpp",
+  ".cs": "csharp",
+  ".csx": "csharp",
+  ".css": "css",
+  ".d": "d",
+  ".pas": "pascal",
+  ".pascal": "pascal",
+  ".diff": "diff",
+  ".patch": "diff",
+  ".dart": "dart",
+  ".dockerfile": "dockerfile",
+  ".ex": "elixir",
+  ".exs": "elixir",
+  ".erl": "erlang",
+  ".ets": "typescript",
+  ".hrl": "erlang",
+  ".fs": "fsharp",
+  ".fsi": "fsharp",
+  ".fsx": "fsharp",
+  ".fsscript": "fsharp",
+  ".gitcommit": "git-commit",
+  ".gitrebase": "git-rebase",
+  ".go": "go",
+  ".groovy": "groovy",
+  ".gleam": "gleam",
+  ".hbs": "handlebars",
+  ".handlebars": "handlebars",
+  ".hs": "haskell",
+  ".lhs": "haskell",
+  ".html": "html",
+  ".htm": "html",
+  ".ini": "ini",
+  ".java": "java",
+  ".jl": "julia",
+  ".js": "javascript",
+  ".kt": "kotlin",
+  ".kts": "kotlin",
+  ".jsx": "javascriptreact",
+  ".json": "json",
+  ".tex": "latex",
+  ".latex": "latex",
+  ".less": "less",
+  ".lua": "lua",
+  ".makefile": "makefile",
+  makefile: "makefile",
+  ".md": "markdown",
+  ".markdown": "markdown",
+  ".m": "objective-c",
+  ".mm": "objective-cpp",
+  ".pl": "perl",
+  ".pm": "perl",
+  ".pm6": "perl6",
+  ".php": "php",
+  ".ps1": "powershell",
+  ".psm1": "powershell",
+  ".pug": "jade",
+  ".jade": "jade",
+  ".py": "python",
+  ".r": "r",
+  ".cshtml": "razor",
+  ".razor": "razor",
+  ".rb": "ruby",
+  ".rake": "ruby",
+  ".gemspec": "ruby",
+  ".ru": "ruby",
+  ".erb": "erb",
+  ".html.erb": "erb",
+  ".js.erb": "erb",
+  ".css.erb": "erb",
+  ".json.erb": "erb",
+  ".rs": "rust",
+  ".scss": "scss",
+  ".sass": "sass",
+  ".scala": "scala",
+  ".shader": "shaderlab",
+  ".sh": "shellscript",
+  ".bash": "shellscript",
+  ".zsh": "shellscript",
+  ".ksh": "shellscript",
+  ".sql": "sql",
+  ".svelte": "svelte",
+  ".swift": "swift",
+  ".ts": "typescript",
+  ".tsx": "typescriptreact",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  ".mtsx": "typescriptreact",
+  ".ctsx": "typescriptreact",
+  ".xml": "xml",
+  ".xsl": "xsl",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".vue": "vue",
+  ".zig": "zig",
+  ".zon": "zig",
+  ".astro": "astro",
+  ".ml": "ocaml",
+  ".mli": "ocaml",
+  ".tf": "terraform",
+  ".tfvars": "terraform-vars",
+  ".hcl": "hcl",
+  ".nix": "nix",
+  ".typ": "typst",
+  ".typc": "typst",
+} as const;

package/src/lib/lsp/launch.ts

@@ -0,0 +1,22 @@
+/**
+ * LSP 服务器子进程启动封装：stdin/stdout/stderr 全 pipe 交给 JSON-RPC 层使用。
+ */
+
+import { type ChildProcessWithoutNullStreams, spawn as nodeSpawn } from "node:child_process";
+
+export interface SpawnOptions {
+  cwd?: string;
+  env?: NodeJS.ProcessEnv;
+}
+
+export function spawnProcess(
+  cmd: string,
+  args: string[],
+  options: SpawnOptions = {},
+): ChildProcessWithoutNullStreams {
+  return nodeSpawn(cmd, args, {
+    cwd: options.cwd,
+    env: options.env ? { ...process.env, ...options.env } : process.env,
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+}

package/src/lib/lsp/lsp.ts

@@ -0,0 +1,289 @@
+/**
+ * LSP 管理器：所有语言服务器连接的注册表与统一入口。
+ *
+ * - state（client 缓存、broken 集合、spawning 去重）是 createLspService 的
+ *   闭包变量，不做成模块级全局；
+ * - 配置来源：全局 `~/.pi/agent/lsp.json` + 本地 `<cwd>/.pi/lsp.json`
+ *   （本地逐字段覆盖全局）：`enabled` 白名单（缺省全部）、`disabled` 排除
+ *   （缺省无），以及各超时参数；配置在每个工具的调用 cwd 下惰性读取；
+ * - client 按 (root, serverID) 缓存，并发 spawn 去重，启动失败记入 broken
+ *   集合（服务实例生命周期内不再重试）；
+ * - 工具只与 touchFile / diagnostics / lspDiagnosticsForFile 三个方法打交道。
+ */
+
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { extname, join, normalize, sep } from "node:path";
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+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";
+
+/** 超时值：number（毫秒，>=1）或字符串（"500"、"5s"、"1m"），Parse 后由 toMs 统一换算。 */
+const timeoutValue = Type.Union([Type.Number({ minimum: 1 }), Type.String()]);
+
+/** lsp.json 的配置项（全局与本地同构）。 */
+const lspConfigSchema = Type.Object({
+  /** 只启用列出的服务器 id（缺省 = 全部启用）。 */
+  enabled: Type.Optional(Type.Array(Type.String())),
+  /** 从启用集中排除的服务器 id（缺省 = 无）。 */
+  disabled: Type.Optional(Type.Array(Type.String())),
+  /** push 诊断去抖（ms，缺省 150）。 */
+  diagnosticsDebounceMs: Type.Optional(timeoutValue),
+  /** document 模式诊断等待上限（ms，缺省 5_000）。 */
+  diagnosticsDocumentWaitTimeoutMs: Type.Optional(timeoutValue),
+  /** full 模式诊断等待上限（ms，缺省 10_000）。 */
+  diagnosticsFullWaitTimeoutMs: Type.Optional(timeoutValue),
+  /** 单次 pull 诊断请求超时（ms，缺省 3_000）。 */
+  diagnosticsRequestTimeoutMs: Type.Optional(timeoutValue),
+  /** 服务器 initialize 握手超时（ms，缺省 45_000）。 */
+  initializeTimeoutMs: Type.Optional(timeoutValue),
+});
+
+/** 配置值；超时字段为原始写法（number 或字符串），换算发生在 timeoutOptions。 */
+export type LspConfig = Static<typeof lspConfigSchema>;
+
+/** "500" → 500、"5s" → 5000、"1m" → 60000；无效字符串返回 NaN（由 toMs 过滤）。 */
+function parseTimeoutString(value: string): number {
+  const match = /^(\d+(?:\.\d+)?)\s*(ms|s|m|h)?$/.exec(value.trim());
+  if (!match) return NaN;
+  const amount = Number(match[1]);
+  const unit = match[2] ?? "ms";
+  const factors: Record<string, number> = { ms: 1, s: 1_000, m: 60_000, h: 3_600_000 };
+  return amount * (factors[unit] ?? 1);
+}
+
+function toMs(value: number | string | undefined): number | undefined {
+  if (value === undefined) return undefined;
+  const ms = typeof value === "number" ? value : parseTimeoutString(value);
+  return Number.isFinite(ms) && ms > 0 ? ms : undefined;
+}
+
+/** 从配置里取超时字段（缺省 undefined，create 用自身默认值）。 */
+function timeoutOptions(
+  config: LspConfig,
+): Pick<
+  CreateInput,
+  | "diagnosticsDebounceMs"
+  | "diagnosticsDocumentWaitTimeoutMs"
+  | "diagnosticsFullWaitTimeoutMs"
+  | "diagnosticsRequestTimeoutMs"
+  | "initializeTimeoutMs"
+> {
+  return {
+    diagnosticsDebounceMs: toMs(config.diagnosticsDebounceMs),
+    diagnosticsDocumentWaitTimeoutMs: toMs(config.diagnosticsDocumentWaitTimeoutMs),
+    diagnosticsFullWaitTimeoutMs: toMs(config.diagnosticsFullWaitTimeoutMs),
+    diagnosticsRequestTimeoutMs: toMs(config.diagnosticsRequestTimeoutMs),
+    initializeTimeoutMs: toMs(config.initializeTimeoutMs),
+  };
+}
+
+/** 读取并解析单个配置文件；文件不存在或解析失败时返回空配置。 */
+async function readConfigFile(filePath: string): Promise<LspConfig> {
+  try {
+    const raw = await readFile(filePath, "utf8");
+    return Value.Parse(lspConfigSchema, JSON.parse(raw) as unknown);
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * 合并后的生效配置：全局 `~/.pi/agent/lsp.json` 为基底，本地
+ * `<cwd>/.pi/lsp.json` 逐字段覆盖。
+ */
+export async function loadLspConfig(
+  cwd: string,
+  globalConfigPath: string = join(homedir(), ".pi", "agent", "lsp.json"),
+): Promise<LspConfig> {
+  const [globalConfig, localConfig] = await Promise.all([
+    readConfigFile(globalConfigPath),
+    readConfigFile(join(cwd, ".pi", "lsp.json")),
+  ]);
+  return { ...globalConfig, ...localConfig };
+}
+
+/** 按配置过滤 adapter 列表。 */
+export function filterAdapters(
+  adapters: LspServerAdapter[],
+  config: LspConfig,
+): LspServerAdapter[] {
+  return adapters.filter((adapter) => {
+    if (config.enabled && !config.enabled.includes(adapter.id)) return false;
+    if (config.disabled?.includes(adapter.id)) return false;
+    return true;
+  });
+}
+
+interface LspState {
+  clients: LspClient[];
+  adapters: LspServerAdapter[];
+  broken: Set<string>;
+  spawning: Map<string, Promise<LspClient | undefined>>;
+}
+
+export interface LspService {
+  touchFile(file: string, cwd: string, diagnostics?: "document" | "full"): Promise<void>;
+  diagnostics(): Promise<Record<string, Diagnostic[]>>;
+  lspDiagnosticsForFile(file: string, cwd: string): Promise<string>;
+  shutdownAll(): Promise<void>;
+}
+
+/** 文件必须在工作目录内才启用 LSP（对齐 opencode 的 containsPath）。 */
+function containsPath(file: string, cwd: string): boolean {
+  const dir = normalize(cwd);
+  const target = normalize(file);
+  return target === dir || target.startsWith(dir + sep);
+}
+
+/**
+ * 创建 LSP 服务实例。state 由闭包持有；adapters 可注入（测试传 [] 或
+ * mock adapters 即可隔离真实服务器）。globalConfigPath 供测试注入
+ * 固定的全局配置路径，避免被本机 ~/.pi/agent/lsp.json 影响。
+ */
+export function createLspService(
+  adapters: LspServerAdapter[] = createAdapters(),
+  globalConfigPath?: string,
+): LspService {
+  const state: LspState = {
+    clients: [],
+    adapters,
+    broken: new Set(),
+    spawning: new Map(),
+  };
+
+  async function getClients(file: string, cwd: string): Promise<LspClient[]> {
+    if (!containsPath(file, cwd)) return [];
+    const config = await loadLspConfig(cwd, globalConfigPath);
+    const timeout = timeoutOptions(config);
+    const adapters = filterAdapters(state.adapters, config);
+    const extension = extname(file) || file;
+    const result: LspClient[] = [];
+
+    for (const adapter of adapters) {
+      if (adapter.extensions.length > 0 && !adapter.extensions.includes(extension)) continue;
+      const root = await adapter.findRoot(file, cwd);
+      if (!root) continue;
+      const key = root + adapter.id;
+      if (state.broken.has(key)) continue;
+
+      const existing = state.clients.find((c) => c.root === root && c.serverID === adapter.id);
+      if (existing) {
+        result.push(existing);
+        continue;
+      }
+
+      const inflight = state.spawning.get(key);
+      if (inflight) {
+        const client = await inflight;
+        if (client) result.push(client);
+        continue;
+      }
+
+      const task = (async () => {
+        try {
+          const handle = await adapter.spawn(root, cwd);
+          if (!handle) {
+            state.broken.add(key);
+            return;
+          }
+          const client = await create({
+            serverID: adapter.id,
+            server: handle,
+            root,
+            directory: cwd,
+            ...timeout,
+          });
+          const duplicate = state.clients.find((c) => c.root === root && c.serverID === adapter.id);
+          if (duplicate) {
+            await client.shutdown();
+            return duplicate;
+          }
+          state.clients.push(client);
+          return client;
+        } catch {
+          state.broken.add(key);
+          return;
+        }
+      })();
+      state.spawning.set(key, task);
+      void task.finally(() => {
+        if (state.spawning.get(key) === task) state.spawning.delete(key);
+      });
+
+      const client = await task;
+      if (client) result.push(client);
+    }
+
+    return result;
+  }
+
+  /**
+   * 打开文档让服务器索引 / 产出诊断。diagnostics 传 "document" 时最多等 5s，
+   * "full" 最多等 10s；不传则只通知不等待（read 的 warm-up 用）。
+   */
+  async function touchFile(
+    file: string,
+    cwd: string,
+    diagnostics?: "document" | "full",
+  ): Promise<void> {
+    const clients = await getClients(file, cwd);
+    await Promise.all(
+      clients.map(async (client) => {
+        const after = Date.now();
+        const version = await client.notify.open({ path: file });
+        if (!diagnostics) return;
+        await client.waitForDiagnostics({ path: file, version, mode: diagnostics, after });
+      }),
+    ).catch(() => {
+      // 诊断等待失败不影响写操作本身
+    });
+  }
+
+  /** 聚合所有 client 的当前诊断（path → diagnostics）。 */
+  function diagnostics(): Promise<Record<string, Diagnostic[]>> {
+    const results: Record<string, Diagnostic[]> = {};
+    for (const client of state.clients) {
+      for (const [filePath, diags] of client.diagnostics) {
+        (results[filePath] ??= []).push(...diags);
+      }
+    }
+    return Promise.resolve(results);
+  }
+
+  /**
+   * edit/write 用：等待文档诊断并返回该文件的 ERROR 报告（空串表示无错误）。
+   * 内部所有 LSP 失败都会被吞掉，不干扰写操作本身。
+   */
+  async function lspDiagnosticsForFile(file: string, cwd: string): Promise<string> {
+    await touchFile(file, cwd, "document");
+    const all = await diagnostics();
+    const normalized = normalize(file);
+    return report(normalized, all[normalized] ?? []);
+  }
+
+  /** 终止全部服务器进程（session_shutdown 时调用）。 */
+  async function shutdownAll(): Promise<void> {
+    await Promise.all(state.clients.map((client) => client.shutdown())).catch(() => {
+      // 个别进程退出失败不阻止清理流程
+    });
+    state.clients = [];
+    state.broken.clear();
+  }
+
+  return { touchFile, diagnostics, lspDiagnosticsForFile, shutdownAll };
+}
+
+/** 注册进程级生命周期：session_shutdown 时清理全部服务器进程。 */
+export function initLsp(pi: ExtensionAPI, service: LspService): void {
+  // 测试里的 fake pi 没有事件订阅；生产环境 pi.on 必然存在
+  pi.on?.("session_shutdown", () => {
+    void service.shutdownAll();
+  });
+}