@epoch-agent/plugin-lsp 0.1.0

package/dist/index.js

@@ -0,0 +1,972 @@
+// src/diagnose.ts
+import { readFile, stat } from "fs/promises";
+import { extname, isAbsolute, relative, resolve as resolve2, sep } from "path";
+
+// src/client.ts
+import { basename } from "path";
+import { pathToFileURL } from "url";
+import {
+  createMessageConnection,
+  StreamMessageReader,
+  StreamMessageWriter
+} from "vscode-jsonrpc/node";
+import {
+  DidChangeTextDocumentNotification,
+  DidCloseTextDocumentNotification,
+  DidOpenTextDocumentNotification,
+  ExitNotification,
+  InitializedNotification,
+  InitializeRequest,
+  PublishDiagnosticsNotification,
+  RegistrationRequest,
+  ShutdownRequest,
+  UnregistrationRequest,
+  WorkDoneProgressCreateRequest
+} from "vscode-languageserver-protocol";
+import {
+  collectProcessTree,
+  killPids,
+  killTrackedProcess,
+  startLongLivedProcess
+} from "@epoch-agent/infra";
+var SHUTDOWN_BUDGET_MS = 2e3;
+var STDERR_KEEP = 4e3;
+var MAX_OPEN_DOCUMENTS = 64;
+var POLL_STEP_MS = 25;
+var LspServerDownError = class extends Error {
+  constructor(detail) {
+    super(`language server \u5DF2\u9000\u51FA\uFF1A${detail}`);
+    this.detail = detail;
+    this.name = "LspServerDownError";
+  }
+  detail;
+};
+function uriKey(uri, platform = process.platform) {
+  const prefix = "file://";
+  if (!uri.startsWith(prefix)) return uri;
+  let path;
+  try {
+    path = decodeURIComponent(uri.slice(prefix.length));
+  } catch {
+    return uri;
+  }
+  if (/^\/[a-zA-Z]:/.test(path)) path = path.slice(1);
+  path = path.replace(/\\/g, "/");
+  return platform === "win32" ? path.toLowerCase() : path;
+}
+var SILENT_LOGGER = {
+  error: () => {
+  },
+  warn: () => {
+  },
+  info: () => {
+  },
+  log: () => {
+  }
+};
+var LspClient = class _LspClient {
+  constructor(connection, pidValue, spec) {
+    this.connection = connection;
+    this.pidValue = pidValue;
+    this.spec = spec;
+  }
+  connection;
+  pidValue;
+  spec;
+  /** 归一键 → 打开状态。按插入顺序逐出 */
+  openDocs = /* @__PURE__ */ new Map();
+  /** 归一键 → server 最近一次推来的诊断 */
+  latest = /* @__PURE__ */ new Map();
+  /** 最近一次「有动静」的时刻 —— 我们发出去的和 server 推回来的都算 */
+  lastActivityAt = 0;
+  /** 这一批里已经答过的文件 */
+  answered = /* @__PURE__ */ new Set();
+  dead = null;
+  disposing = false;
+  stderr = "";
+  get pid() {
+    return this.pidValue;
+  }
+  /** 还能用吗。池按这个决定要不要重启（验收 9） */
+  get alive() {
+    return this.dead === null;
+  }
+  /**
+   * 起进程 + `initialize` + `initialized`。
+   *
+   * 起不来 / 初始化超时都**返回 `null` 而不抛** —— 调用方据此把这个语言标记
+   * 不可用，整轮照常出结果（验收 8）。抛出去的话一个慢 server 就能让整次工具
+   * 调用失败，而那正是这条验收要避免的。
+   */
+  static async start(options) {
+    const { spec, launch, projectRoot } = options;
+    let self = null;
+    const tracked = startLongLivedProcess({
+      file: launch.file,
+      args: launch.args,
+      cwd: projectRoot,
+      spawnOptions: {
+        // infra 的默认值是 `['ignore', 'pipe', 'pipe']`，而 LSP over stdio **要
+        // stdin**。`spawnOptions` 在 infra 里是最后展开的，所以这里盖得掉
+        stdio: ["pipe", "pipe", "pipe"],
+        ...launch.verbatim ? { windowsVerbatimArguments: true } : {},
+        // `launch.env` 只有项目本地那一档有（它拿 `execPath` 当 node 使）。
+        // **必须连 `process.env` 一起摊开**：给 `env` 赋值是整份替换而不是叠加，
+        // 只放那一格等于把 PATH / HOME 抽掉，server 当场起不来
+        ...launch.env ? { env: { ...process.env, ...launch.env } } : {}
+      },
+      onOutput: (chunk, stream) => {
+        if (stream === "stderr") self?.appendStderr(chunk);
+      },
+      onExit: (code, signal) => {
+        self?.markDead(`exit code=${code ?? "null"} signal=${signal ?? "null"}`, options.onCrash);
+      }
+    });
+    const { stdin, stdout } = tracked.child;
+    if (!stdin || !stdout) {
+      await killTrackedProcess(tracked.pid);
+      return null;
+    }
+    const connection = createMessageConnection(
+      new StreamMessageReader(stdout),
+      new StreamMessageWriter(stdin),
+      SILENT_LOGGER
+    );
+    self = new _LspClient(connection, tracked.pid, spec);
+    self.wire();
+    connection.listen();
+    if (!await self.initialize(projectRoot)) {
+      await self.dispose();
+      return null;
+    }
+    return self;
+  }
+  /** 订阅推送 + 兜住 server 反过来发的那几种请求 */
+  wire() {
+    this.connection.onNotification(
+      PublishDiagnosticsNotification.type,
+      (params) => {
+        const key = uriKey(params.uri);
+        this.latest.set(key, params.diagnostics);
+        this.answered.add(key);
+        this.lastActivityAt = Date.now();
+      }
+    );
+    this.connection.onRequest(RegistrationRequest.type, () => void 0);
+    this.connection.onRequest(UnregistrationRequest.type, () => void 0);
+    this.connection.onRequest(WorkDoneProgressCreateRequest.type, () => void 0);
+    this.connection.onError(() => this.markDead("JSON-RPC \u8FDE\u63A5\u9519\u8BEF"));
+    this.connection.onClose(() => this.markDead("JSON-RPC \u8FDE\u63A5\u5173\u95ED"));
+  }
+  appendStderr(chunk) {
+    this.stderr = (this.stderr + chunk).slice(-STDERR_KEEP);
+  }
+  markDead(detail, onCrash) {
+    if (this.dead) return;
+    const tail = this.stderr.trim();
+    this.dead = tail ? `${detail}\uFF1Bstderr: ${tail.slice(-500)}` : detail;
+    if (!this.disposing) onCrash?.(this.dead);
+  }
+  async initialize(projectRoot) {
+    const rootUri = pathToFileURL(projectRoot).toString();
+    const initOptions = this.spec.initializationOptions?.(projectRoot);
+    const params = {
+      processId: process.pid,
+      clientInfo: { name: "epoch-agent" },
+      rootUri,
+      workspaceFolders: [{ uri: rootUri, name: basename(projectRoot) || projectRoot }],
+      capabilities: {
+        workspace: { workspaceFolders: true },
+        textDocument: {
+          synchronization: {
+            dynamicRegistration: false,
+            willSave: false,
+            willSaveWaitUntil: false,
+            didSave: false
+          },
+          // **这一段不能省**：typescript-language-server 用它算
+          // `features.diagnosticsSupport`，不声明就一条诊断都不推 ——
+          // 表现成「所有文件都没问题」，最坏的那种失败
+          publishDiagnostics: { relatedInformation: true, versionSupport: false }
+        }
+      },
+      ...initOptions ? { initializationOptions: initOptions } : {}
+    };
+    try {
+      const result = await withTimeoutOrNull(
+        this.connection.sendRequest(InitializeRequest.type, params),
+        this.spec.initTimeoutMs
+      );
+      if (result === null) return false;
+      await this.connection.sendNotification(InitializedNotification.type, {});
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * 打开 / 更新这批文件，等到静默，交出诊断。
+   *
+   * @throws {LspServerDownError} 进程中途没了（验收 9 的输入）
+   */
+  async diagnose(documents, wait) {
+    if (this.dead) throw new LspServerDownError(this.dead);
+    if (documents.length === 0) return { byPath: /* @__PURE__ */ new Map(), pending: [] };
+    const wanted = documents.map((doc) => uriKey(pathToFileURL(doc.path).toString()));
+    this.answered = /* @__PURE__ */ new Set();
+    for (const doc of documents) await this.sync(doc);
+    await this.evictOverflow(new Set(wanted));
+    const deadline = Date.now() + wait.timeoutMs;
+    for (; ; ) {
+      if (this.dead) throw new LspServerDownError(this.dead);
+      const quiet = Date.now() - this.lastActivityAt;
+      if (wanted.every((key) => this.answered.has(key)) && quiet >= wait.settleMs) break;
+      if (wanted.every((key) => this.answered.has(key) || this.latest.has(key)) && quiet >= wait.fallbackMs) {
+        break;
+      }
+      if (Date.now() >= deadline) break;
+      await sleep(POLL_STEP_MS);
+    }
+    const byPath = /* @__PURE__ */ new Map();
+    const pending = [];
+    for (const key of wanted) {
+      const known = this.latest.get(key);
+      if (known) byPath.set(key, known);
+      else if (this.answered.has(key)) byPath.set(key, []);
+      else pending.push(key);
+    }
+    return { byPath, pending };
+  }
+  /** 没打开过就 `didOpen`，打开过就 `didChange`（全量） */
+  async sync(doc) {
+    const uri = pathToFileURL(doc.path).toString();
+    const key = uriKey(uri);
+    this.lastActivityAt = Date.now();
+    const open = this.openDocs.get(key);
+    if (!open) {
+      this.openDocs.set(key, { uri, version: 1 });
+      await this.connection.sendNotification(DidOpenTextDocumentNotification.type, {
+        textDocument: { uri, languageId: doc.languageId, version: 1, text: doc.text }
+      });
+      return;
+    }
+    open.version += 1;
+    await this.connection.sendNotification(DidChangeTextDocumentNotification.type, {
+      textDocument: { uri: open.uri, version: open.version },
+      // 全量替换。增量同步要自己维护一份影子文档才算得出 range，而我们每次拿到的
+      // 本来就是磁盘上的完整内容 —— 算 diff 只是把复杂度换成一个新的错误来源
+      contentChanges: [{ text: doc.text }]
+    });
+  }
+  /** 超过上限就把最早打开、且不在本批里的文档关掉 */
+  async evictOverflow(keep) {
+    for (const [key, open] of [...this.openDocs]) {
+      if (this.openDocs.size <= MAX_OPEN_DOCUMENTS) return;
+      if (keep.has(key)) continue;
+      this.openDocs.delete(key);
+      this.latest.delete(key);
+      await this.connection.sendNotification(DidCloseTextDocumentNotification.type, {
+        textDocument: { uri: open.uri }
+      });
+    }
+  }
+  /**
+   * 关掉这个 server。
+   *
+   * 先按协议 `shutdown` + `exit`，给它清临时文件的机会；超预算就直接杀树。
+   * **杀树那一步不能省** —— `typescript-language-server` 自己还 fork 了一个
+   * `tsserver.js`，只杀父进程会留下孤儿（验收 7）。
+   *
+   * ## ⚠️ 三步的**顺序**是判据：拍快照 → 优雅关 → 清扫快照
+   *
+   * 这里原来只有两步（优雅关 → `killTrackedProcess`），而那是**漏的**：
+   * `killTrackedProcess` 底下是 `killProcessTree`，靠的是**现场遍历**
+   * （`pgrep -P` / `taskkill /t`）。等我们优雅关完，直接子进程已经退了 ——
+   * 树的根没了，孙进程的 PPID 指向一个死 pid，遍历再也找不到它们。
+   * 于是 `tsserver` 那一层在 POSIX 上被 init 收养、在 Windows 上直接常驻到关机。
+   *
+   * 所以快照必须在**动手之前**拍。这不是新发明：`plugin-mcp` 的
+   * `closeTransportAndReap` 就是这三步，而它有一条会红的用例守着；
+   * 我们这边验收 #7 一直挂着「双平台手验」没人做，于是漏了一年半。
+   * 2026-08-12 补的 [orphan-reap.test.ts](../__tests__/orphan-reap.test.ts)
+   * 把这条钉死了 —— 把下面的快照挪到 `killTrackedProcess` 之后，它当场红。
+   */
+  async dispose() {
+    if (this.disposing) return;
+    this.disposing = true;
+    const tree = await collectProcessTree(this.pidValue).catch(() => []);
+    try {
+      await withTimeoutOrNull(
+        (async () => {
+          await this.connection.sendRequest(ShutdownRequest.type);
+          await this.connection.sendNotification(ExitNotification.type);
+        })(),
+        SHUTDOWN_BUDGET_MS
+      );
+    } catch {
+    }
+    try {
+      this.connection.dispose();
+    } catch {
+    }
+    this.dead ??= "\u5DF2\u4E3B\u52A8\u5173\u95ED";
+    await killTrackedProcess(this.pidValue);
+    if (tree.length > 0) await killPids(tree, { escalate: true });
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve3) => {
+    setTimeout(resolve3, ms).unref?.();
+  });
+}
+async function withTimeoutOrNull(promise, ms) {
+  let timer;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((resolve3) => {
+        timer = setTimeout(() => resolve3(null), ms);
+        timer.unref?.();
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+// src/servers.ts
+import { dirname as dirname2, join as join2 } from "path";
+
+// src/find-up.ts
+import { existsSync } from "fs";
+import { dirname, join, resolve } from "path";
+function findUp(startDir, relativePath, options = {}) {
+  const exists = options.exists ?? existsSync;
+  const maxDepth = options.maxDepth ?? 64;
+  let dir = resolve(startDir);
+  for (let depth = 0; depth < maxDepth; depth += 1) {
+    const candidate = join(dir, relativePath);
+    if (exists(candidate)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+// src/servers.ts
+var TS_LANGUAGE_IDS = {
+  ".ts": "typescript",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  ".tsx": "typescriptreact",
+  ".js": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".jsx": "javascriptreact"
+};
+function tsserverPath(projectRoot) {
+  const manifest = findUp(projectRoot, join2("node_modules", "typescript", "package.json"));
+  if (!manifest) return void 0;
+  return join2(dirname2(manifest), "lib", "tsserver.js");
+}
+var TYPESCRIPT = {
+  id: "typescript",
+  label: "TypeScript / JavaScript",
+  pkg: "typescript-language-server",
+  bin: "typescript-language-server",
+  args: ["--stdio"],
+  install: "npm i -D typescript-language-server typescript\uFF08\u6216\u5168\u5C40 npm i -g\uFF09",
+  initTimeoutMs: 3e4,
+  initializationOptions: (projectRoot) => {
+    const path = tsserverPath(projectRoot);
+    return path ? { tsserver: { path } } : void 0;
+  }
+};
+var SERVERS = [TYPESCRIPT];
+function serverForExtension(ext) {
+  const languageId = TS_LANGUAGE_IDS[ext.toLowerCase()];
+  return languageId ? { spec: TYPESCRIPT, languageId } : null;
+}
+function supportedExtensions() {
+  return Object.keys(TS_LANGUAGE_IDS).sort();
+}
+
+// src/diagnose.ts
+var MAX_FILES_PER_CALL = 50;
+var DEFAULT_WAIT = {
+  // tsserver 一个文件分三次推（语法 / 语义 / 建议），各带 50ms 去抖。
+  // 400ms 静默足够让三次都落地，又不会平白给每次调用加一秒
+  settleMs: 400,
+  // 内容没变时 server 干脆不推（见 client.ts）。这时要等的是
+  // typescript-language-server 那个 300–800ms 的触发延迟走完，确认它真的不打算说话
+  fallbackMs: 1500,
+  timeoutMs: 15e3
+};
+function severityOf(value) {
+  switch (value) {
+    case 2:
+      return "warning";
+    case 3:
+      return "information";
+    case 4:
+      return "hint";
+    default:
+      return "error";
+  }
+}
+function toDisplayPath(absPath, workDir) {
+  const rel = relative(workDir, absPath);
+  return (rel || absPath).split(sep).join("/");
+}
+function messageOf(message) {
+  return typeof message === "string" ? message : message.value;
+}
+function toItem(diag, file) {
+  const item = {
+    file,
+    // LSP 的行列都是 0 起的，人和其它工具用的是 1 起
+    line: diag.range.start.line + 1,
+    column: diag.range.start.character + 1,
+    severity: severityOf(diag.severity),
+    message: messageOf(diag.message)
+  };
+  if (diag.source) item.source = diag.source;
+  if (diag.code !== void 0 && diag.code !== null) item.code = String(diag.code);
+  return item;
+}
+var SEVERITY_ORDER = {
+  error: 0,
+  warning: 1,
+  information: 2,
+  hint: 3
+};
+function sortItems(items) {
+  return items.sort(
+    (a, b) => a.file.localeCompare(b.file) || a.line - b.line || a.column - b.column || SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity] || a.message.localeCompare(b.message)
+  );
+}
+async function classify(paths, workDir, outcome) {
+  const root = resolve2(workDir);
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of paths) {
+    const absPath = isAbsolute(raw) ? resolve2(raw) : resolve2(root, raw);
+    const rel = relative(root, absPath);
+    if (rel !== "" && (rel.startsWith("..") || isAbsolute(rel))) {
+      outcome.rejected.push({ path: raw, reason: `\u4E0D\u5728\u5DE5\u4F5C\u533A ${root} \u5185` });
+      continue;
+    }
+    const key = uriKey(`file://${absPath.split(sep).join("/")}`);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const display = toDisplayPath(absPath, root);
+    try {
+      const info = await stat(absPath);
+      if (!info.isFile()) {
+        outcome.rejected.push({ path: display, reason: "\u4E0D\u662F\u6587\u4EF6" });
+        continue;
+      }
+    } catch {
+      outcome.rejected.push({ path: display, reason: "\u6587\u4EF6\u4E0D\u5B58\u5728" });
+      continue;
+    }
+    const match = serverForExtension(extname(absPath));
+    if (!match) {
+      outcome.unsupported.push(display);
+      continue;
+    }
+    candidates.push({ absPath, display, languageId: match.languageId, spec: match.spec });
+  }
+  return candidates;
+}
+function groupBySpec(candidates) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const c of candidates) {
+    const group = groups.get(c.spec.id) ?? { spec: c.spec, files: [] };
+    group.files.push(c);
+    groups.set(c.spec.id, group);
+  }
+  return groups;
+}
+function skip(spec, reason, files, install) {
+  return {
+    label: spec.label,
+    reason,
+    ...install ? { install } : {},
+    files: files.map((f) => f.display)
+  };
+}
+async function runGroup(spec, files, input, outcome) {
+  const acquired = await input.pool.acquire(spec, resolve2(input.workDir));
+  if (!acquired.ok) {
+    outcome.skipped.push(skip(spec, acquired.reason, files, acquired.install));
+    return;
+  }
+  const documents = [];
+  const byKey = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    let text;
+    try {
+      text = await readFile(file.absPath, "utf-8");
+    } catch (err) {
+      outcome.rejected.push({
+        path: file.display,
+        reason: `\u8BFB\u4E0D\u51FA\u6765\uFF08${err instanceof Error ? err.message : String(err)}\uFF09`
+      });
+      continue;
+    }
+    documents.push({ path: file.absPath, languageId: file.languageId, text });
+    byKey.set(uriKey(`file://${file.absPath.split(sep).join("/")}`), file);
+  }
+  if (documents.length === 0) return;
+  let batch;
+  try {
+    batch = await acquired.client.diagnose(documents, input.wait ?? DEFAULT_WAIT);
+  } catch (err) {
+    const reason = err instanceof LspServerDownError ? err.message : `\u8BCA\u65AD\u5931\u8D25\uFF08${String(err)}\uFF09`;
+    outcome.skipped.push(skip(spec, reason, files));
+    return;
+  }
+  for (const [key, diags] of batch.byPath) {
+    const file = byKey.get(key);
+    if (!file) continue;
+    outcome.checked.push(file.display);
+    for (const diag of diags) outcome.diagnostics.push(toItem(diag, file.display));
+  }
+  if (batch.pending.length > 0) {
+    const stuck = batch.pending.map((key) => byKey.get(key)).filter((f) => !!f);
+    outcome.skipped.push(
+      skip(spec, `server \u672A\u5728 ${(input.wait ?? DEFAULT_WAIT).timeoutMs}ms \u5185\u7ED9\u51FA\u7ED3\u679C`, stuck)
+    );
+  }
+}
+async function diagnosePaths(input) {
+  const outcome = {
+    checked: [],
+    diagnostics: [],
+    skipped: [],
+    unsupported: [],
+    rejected: []
+  };
+  const paths = input.paths.slice(0, MAX_FILES_PER_CALL);
+  for (const extra of input.paths.slice(MAX_FILES_PER_CALL)) {
+    outcome.rejected.push({ path: extra, reason: `\u4E00\u6B21\u6700\u591A ${MAX_FILES_PER_CALL} \u4E2A\u6587\u4EF6` });
+  }
+  const candidates = await classify(paths, resolve2(input.workDir), outcome);
+  for (const group of groupBySpec(candidates).values()) {
+    if (input.signal?.aborted) {
+      outcome.skipped.push(skip(group.spec, "\u5DF2\u53D6\u6D88", group.files));
+      continue;
+    }
+    await runGroup(group.spec, group.files, input, outcome);
+  }
+  outcome.checked.sort();
+  outcome.unsupported.sort();
+  sortItems(outcome.diagnostics);
+  return outcome;
+}
+
+// src/format.ts
+var MAX_ITEMS = 100;
+var MAX_MESSAGE = 400;
+var MAX_FILE_NAMES = 20;
+var SEVERITY_LABEL = {
+  error: "error",
+  warning: "warning",
+  information: "info",
+  hint: "hint"
+};
+var KEEP_ORDER = ["error", "warning", "information", "hint"];
+function oneLine(message) {
+  const flat = message.replace(/\s+/g, " ").trim();
+  return flat.length > MAX_MESSAGE ? `${flat.slice(0, MAX_MESSAGE)}\u2026` : flat;
+}
+function renderItem(item) {
+  const origin = `${item.source ?? ""}${item.code ? `(${item.code})` : ""}`;
+  const tag = origin ? `${SEVERITY_LABEL[item.severity]} ${origin}` : SEVERITY_LABEL[item.severity];
+  return `${item.file}:${item.line}:${item.column}  ${tag}: ${oneLine(item.message)}`;
+}
+function renderCounts(items) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const item of items) counts.set(item.severity, (counts.get(item.severity) ?? 0) + 1);
+  return KEEP_ORDER.filter((s) => counts.has(s)).map((s) => `${counts.get(s) ?? 0} ${SEVERITY_LABEL[s]}`).join(" \xB7 ");
+}
+function renderFiles(files) {
+  if (files.length <= MAX_FILE_NAMES) return files.join(", ");
+  return `${files.slice(0, MAX_FILE_NAMES).join(", ")} \u7B49 ${files.length} \u4E2A`;
+}
+function pickItems(items) {
+  if (items.length <= MAX_ITEMS) return { shown: items, dropped: 0 };
+  const keep = /* @__PURE__ */ new Set();
+  for (const severity of KEEP_ORDER) {
+    for (const item of items) {
+      if (keep.size >= MAX_ITEMS) break;
+      if (item.severity === severity) keep.add(item);
+    }
+  }
+  return { shown: items.filter((i) => keep.has(i)), dropped: items.length - keep.size };
+}
+function formatOutcome(outcome) {
+  const lines = [];
+  const { checked, diagnostics, skipped, unsupported, rejected } = outcome;
+  if (diagnostics.length === 0) {
+    lines.push(
+      checked.length > 0 ? `\u672A\u53D1\u73B0\u95EE\u9898 \xB7 \u5DF2\u68C0\u67E5 ${checked.length} \u4E2A\u6587\u4EF6\uFF1A${renderFiles(checked)}` : "\u672A\u68C0\u67E5\u4EFB\u4F55\u6587\u4EF6"
+    );
+  } else {
+    const { shown, dropped } = pickItems(diagnostics);
+    lines.push(
+      `${diagnostics.length} \u6761\u8BCA\u65AD\uFF08${renderCounts(diagnostics)}\uFF09 \xB7 \u5DF2\u68C0\u67E5 ${checked.length} \u4E2A\u6587\u4EF6`,
+      "",
+      ...shown.map(renderItem)
+    );
+    if (dropped > 0) {
+      lines.push("", `\uFF08\u8FD8\u6709 ${dropped} \u6761\u672A\u5217\u51FA\uFF0C\u5DF2\u4F18\u5148\u4FDD\u7559 error\uFF09`);
+    }
+  }
+  for (const skip2 of skipped) {
+    lines.push("", `\u8DF3\u8FC7 ${skip2.label}\uFF1A${skip2.reason}`);
+    if (skip2.install) lines.push(`  \u5B89\u88C5\uFF1A${skip2.install}`);
+    if (skip2.files.length > 0) lines.push(`  \u672A\u68C0\u67E5\uFF1A${renderFiles(skip2.files)}`);
+  }
+  if (unsupported.length > 0) {
+    lines.push("", `\u65E0\u5BF9\u5E94 language server\uFF0C\u672A\u68C0\u67E5\uFF1A${renderFiles(unsupported)}`);
+  }
+  for (const bad of rejected) {
+    lines.push("", `\u65E0\u6CD5\u68C0\u67E5 ${bad.path}\uFF1A${bad.reason}`);
+  }
+  return lines.join("\n");
+}
+
+// src/detect.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { dirname as dirname3, join as join3, posix, win32 } from "path";
+import { EXEC_PATH_AS_NODE_ENV } from "@epoch-agent/infra";
+function defaultReadManifest(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function normalize(options) {
+  return {
+    env: options.env ?? process.env,
+    platform: options.platform ?? process.platform,
+    fileExists: options.fileExists ?? existsSync2,
+    readManifest: options.readManifest ?? defaultReadManifest,
+    execPath: options.execPath ?? process.execPath
+  };
+}
+function binEntry(manifest, binName) {
+  if (typeof manifest !== "object" || manifest === null) return null;
+  const bin = manifest.bin;
+  if (typeof bin === "string") return bin;
+  if (typeof bin !== "object" || bin === null) return null;
+  const table = bin;
+  const exact = table[binName];
+  if (typeof exact === "string") return exact;
+  const values = Object.values(table).filter((v) => typeof v === "string");
+  return values.length === 1 ? values[0] ?? null : null;
+}
+function projectLaunch(spec, projectRoot, o) {
+  if (!spec.pkg) return null;
+  const manifestPath = findUp(projectRoot, join3("node_modules", spec.pkg, "package.json"), {
+    exists: o.fileExists
+  });
+  if (!manifestPath) return null;
+  const entryRel = binEntry(o.readManifest(manifestPath), spec.bin);
+  if (!entryRel) return null;
+  const packageDir = dirname3(manifestPath);
+  const entry = join3(packageDir, entryRel);
+  if (!o.fileExists(entry)) return null;
+  return {
+    tier: "project",
+    file: o.execPath,
+    args: [entry, ...spec.args],
+    origin: `\u9879\u76EE node_modules\uFF08${packageDir}\uFF09`,
+    // 嵌进 Electron 的宿主里 `execPath` 是宿主自己的可执行文件，少了这一格
+    // 起 language server 等于启动第二个 app 实例
+    env: EXEC_PATH_AS_NODE_ENV
+  };
+}
+function shimLaunch(shim, spec, o) {
+  const quote = (s) => /[\s"]/.test(s) ? `"${s}"` : s;
+  const command = [quote(shim), ...spec.args.map(quote)].join(" ");
+  return {
+    tier: "path",
+    file: o.env["ComSpec"] ?? o.env["COMSPEC"] ?? "cmd.exe",
+    // 整条命令再包一层引号是 cmd 的老规矩：`/s` 让它只剥最外层，
+    // 里面那对（路径带空格时的）引号才留得住
+    args: ["/d", "/s", "/c", `"${command}"`],
+    origin: `PATH\uFF08${shim}\uFF09`,
+    verbatim: true
+  };
+}
+function pathLaunch(spec, o) {
+  const windows = o.platform === "win32";
+  const api = windows ? win32 : posix;
+  const dirs = (o.env["PATH"] ?? o.env["Path"] ?? "").split(api.delimiter).filter(Boolean);
+  const exts = windows ? (o.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean) : [""];
+  for (const dir of dirs) {
+    for (const ext of exts) {
+      const candidate = api.join(dir, `${spec.bin}${ext.toLowerCase()}`);
+      if (!o.fileExists(candidate)) continue;
+      if (windows && /\.(cmd|bat)$/i.test(candidate)) return shimLaunch(candidate, spec, o);
+      return {
+        tier: "path",
+        file: candidate,
+        args: [...spec.args],
+        origin: `PATH\uFF08${candidate}\uFF09`
+      };
+    }
+  }
+  return null;
+}
+function resolveServer(spec, projectRoot, options = {}) {
+  const o = normalize(options);
+  const launch = projectLaunch(spec, projectRoot, o) ?? pathLaunch(spec, o);
+  if (launch) return { available: true, launch };
+  return {
+    available: false,
+    reason: `\u6CA1\u627E\u5230 ${spec.bin}\uFF08\u9879\u76EE node_modules \u548C PATH \u91CC\u90FD\u6CA1\u6709\uFF09`,
+    install: spec.install
+  };
+}
+
+// src/pool.ts
+var DEFAULT_IDLE_MS = 10 * 60 * 1e3;
+var DEFAULT_SWEEP_MS = 60 * 1e3;
+var MAX_FAILURES = 2;
+var LspServerPool = class {
+  entries = /* @__PURE__ */ new Map();
+  failures = /* @__PURE__ */ new Map();
+  /** 同一个 key 上并发的 acquire 共用一次启动，不然会起出两个 tsserver */
+  starting = /* @__PURE__ */ new Map();
+  timer = null;
+  sweeping = false;
+  idleMs;
+  sweepMs;
+  now;
+  resolve;
+  start;
+  constructor(options = {}) {
+    this.idleMs = options.idleMs ?? DEFAULT_IDLE_MS;
+    this.sweepMs = options.sweepMs ?? DEFAULT_SWEEP_MS;
+    this.now = options.now ?? Date.now;
+    this.resolve = options.resolve ?? ((spec, root) => resolveServer(spec, root));
+    this.start = options.start ?? ((opts) => LspClient.start(opts));
+  }
+  /** 活着的实例数。验收 5（懒启动）就是断言它一开始是 0 */
+  get size() {
+    return this.entries.size;
+  }
+  /** 拿一个可用的 client；拿不到就说清为什么 */
+  async acquire(spec, projectRoot) {
+    const key = `${projectRoot}\0${spec.id}`;
+    const existing = this.entries.get(key);
+    if (existing) {
+      if (existing.client.alive) {
+        existing.lastUsedAt = this.now();
+        return { ok: true, client: existing.client };
+      }
+      this.entries.delete(key);
+      this.noteFailure(key, "language server \u8FDB\u7A0B\u5DF2\u9000\u51FA");
+    }
+    const failed = this.failures.get(key);
+    if (failed && failed.count >= MAX_FAILURES) {
+      return {
+        ok: false,
+        reason: `${failed.detail}\uFF08\u5DF2\u8FDE\u7EED\u5931\u8D25 ${failed.count} \u6B21\uFF0C\u672C\u6B21\u4F1A\u8BDD\u4E0D\u518D\u91CD\u542F\uFF09`
+      };
+    }
+    const inflight = this.starting.get(key);
+    if (inflight) return inflight;
+    const pending = this.startFor(key, spec, projectRoot);
+    this.starting.set(key, pending);
+    try {
+      return await pending;
+    } finally {
+      this.starting.delete(key);
+    }
+  }
+  async startFor(key, spec, projectRoot) {
+    const resolution = this.resolve(spec, projectRoot);
+    if (!resolution.available) {
+      return { ok: false, reason: resolution.reason, install: resolution.install };
+    }
+    const client = await this.start({
+      spec,
+      launch: resolution.launch,
+      projectRoot,
+      onCrash: (detail) => {
+        this.entries.delete(key);
+        this.noteFailure(key, `language server \u5D29\u4E86\uFF08${detail}\uFF09`);
+      }
+    });
+    if (!client) {
+      this.noteFailure(key, `language server \u8D77\u4E0D\u6765\u6216\u521D\u59CB\u5316\u8D85\u65F6\uFF08>${spec.initTimeoutMs}ms\uFF09`);
+      const now = this.failures.get(key);
+      return {
+        ok: false,
+        reason: now && now.count >= MAX_FAILURES ? `${now.detail}\uFF08\u672C\u6B21\u4F1A\u8BDD\u4E0D\u518D\u91CD\u542F\uFF09` : now?.detail ?? "\u542F\u52A8\u5931\u8D25"
+      };
+    }
+    this.entries.set(key, { client, lastUsedAt: this.now() });
+    this.ensureSweeper();
+    return { ok: true, client };
+  }
+  noteFailure(key, detail) {
+    const prev = this.failures.get(key);
+    this.failures.set(key, { count: (prev?.count ?? 0) + 1, detail });
+  }
+  /**
+   * 回收空闲实例。定时器调它，测试也直接调它。
+   *
+   * 重入保护不是洁癖：`dispose()` 里有一次最多 2s 的优雅退出，而扫描间隔是
+   * 1 分钟 —— 真卡住的时候两次扫描会叠在一起，对同一个 client 调两次 dispose。
+   */
+  async sweep() {
+    if (this.sweeping) return;
+    this.sweeping = true;
+    try {
+      const cutoff = this.now() - this.idleMs;
+      const dying = [];
+      for (const [key, entry] of [...this.entries]) {
+        if (entry.lastUsedAt > cutoff && entry.client.alive) continue;
+        this.entries.delete(key);
+        dying.push(entry.client);
+      }
+      await Promise.all(dying.map((c) => c.dispose()));
+      if (this.entries.size === 0) this.stopSweeper();
+    } finally {
+      this.sweeping = false;
+    }
+  }
+  /** 全部关掉。宿主 dispose 时调；也是测试的收尾 */
+  async disposeAll() {
+    this.stopSweeper();
+    const all = [...this.entries.values()].map((e) => e.client);
+    this.entries.clear();
+    await Promise.all(all.map((c) => c.dispose()));
+  }
+  ensureSweeper() {
+    if (this.timer) return;
+    this.timer = setInterval(() => void this.sweep(), this.sweepMs);
+    this.timer.unref?.();
+  }
+  stopSweeper() {
+    if (!this.timer) return;
+    clearInterval(this.timer);
+    this.timer = null;
+  }
+};
+
+// src/index.ts
+var ERR_BAD_PATHS = 8001;
+var ERR_UNEXPECTED = 8002;
+var pool = new LspServerPool();
+async function disposeLspServers() {
+  await pool.disposeAll();
+}
+function toPaths(value) {
+  const raw = typeof value === "string" ? [value] : value;
+  if (!Array.isArray(raw)) return null;
+  const out = [];
+  for (const item of raw) {
+    if (typeof item !== "string") return null;
+    const trimmed = item.trim();
+    if (trimmed) out.push(trimmed);
+  }
+  return out.length > 0 ? out : null;
+}
+function fail(code, message, suggestion, started) {
+  return {
+    success: false,
+    output: "",
+    error: { code, message, suggestion },
+    duration: Date.now() - started
+  };
+}
+var lspPlugin = {
+  name: "@epoch-agent/plugin-lsp",
+  version: "0.0.0",
+  description: "LSP \u8BCA\u65AD\u63D2\u4EF6 \u2014 \u7528\u9879\u76EE\u81EA\u5DF1\u7684 language server \u53D6\u7C7B\u578B / \u8BED\u6CD5\u9519\u8BEF",
+  tools: [
+    {
+      name: "lsp_diagnostics",
+      description: `\u7528\u9879\u76EE\u81EA\u5DF1\u7684 language server \u68C0\u67E5\u6587\u4EF6\uFF0C\u8FD4\u56DE\u7C7B\u578B\u9519\u8BEF\u3001\u8BED\u6CD5\u9519\u8BEF\u548C\u672A\u4F7F\u7528\u53D8\u91CF\u7B49\u8BCA\u65AD\u3002\u53C2\u6570: paths(\u5FC5\u586B, \u6587\u4EF6\u8DEF\u5F84\u6570\u7EC4, \u76F8\u5BF9\u5DE5\u4F5C\u76EE\u5F55)\u3002\u5F53\u524D\u652F\u6301 ${supportedExtensions().join(" ")}\u3002**\u6539\u5B8C\u4EE3\u7801\u4E4B\u540E\u3001\u5BA3\u5E03\u5B8C\u6210\u4E4B\u524D\u8C03\u4E00\u6B21**\uFF0C\u628A\u672C\u8F6E\u65B0\u5EFA\u6216\u4FEE\u6539\u8FC7\u7684\u6E90\u6587\u4EF6\u90FD\u5217\u8FDB\u53BB \u2014\u2014 \u5B83\u6BD4\u8BA9 shell \u8DD1\u4E00\u904D tsc \u5FEB\u5F97\u591A\uFF0C\u56E0\u4E3A language server \u662F\u5E38\u9A7B\u7684\u3002\u6CE8\u610F\u5B83\u53EA\u505A\u5355\u6587\u4EF6\u7EA7\u8BCA\u65AD\uFF0C\u4E0D\u7B49\u4E8E\u4E00\u6B21\u5B8C\u6574\u6784\u5EFA\uFF1A\u6784\u5EFA\u811A\u672C\u3001\u6253\u5305\u914D\u7F6E\u3001\u8DE8\u5305\u7C7B\u578B\u89E3\u6790\u51FA\u7684\u95EE\u9898\u5B83\u770B\u4E0D\u5230\u3002\u6CA1\u88C5\u5BF9\u5E94 language server \u65F6\u4F1A\u5982\u5B9E\u62A5\u300C\u8DF3\u8FC7\u300D\u5E76\u7ED9\u51FA\u5B89\u88C5\u547D\u4EE4\uFF0C\u4E0D\u4F1A\u8BA9\u8FD9\u6B21\u8C03\u7528\u5931\u8D25\u3002`,
+      parameters: {
+        type: "object",
+        properties: {
+          paths: {
+            type: "array",
+            items: { type: "string" },
+            description: '\u8981\u68C0\u67E5\u7684\u6587\u4EF6\u8DEF\u5F84\uFF08\u76F8\u5BF9\u5DE5\u4F5C\u76EE\u5F55\u6216\u7EDD\u5BF9\u8DEF\u5F84\uFF09\uFF0C\u4F8B\u5982 ["src/a.ts", "src/b.tsx"]'
+          }
+        },
+        required: ["paths"]
+      },
+      // 只读 + 不碰网络。`idempotentHint: false` 是因为文件内容会变 ——
+      // 同一批路径这一秒和下一秒的诊断可以不一样
+      annotations: { readOnlyHint: true, idempotentHint: false, openWorldHint: false },
+      // `file_read` 而不是 `command`：这个工具对外的语义就是「读几个文件、报问题」。
+      // 底下确实起了子进程，但那个进程是**我们表里写死的**（`servers.ts`），
+      // 参数里没有任何一段来自模型 —— 归到 command 只会让每次诊断都弹一次审批，
+      // 而 system prompt 恰恰要求模型每轮改完都调它
+      operation: "file_read",
+      // 审批目标是文件清单。不给的话调度侧会退回 `JSON.stringify(args)`，
+      // 换个顺序传同样几个文件就不命中缓存了
+      describeTarget: (args) => (toPaths(args["paths"]) ?? []).join(", "),
+      execute: async (args, ctx) => {
+        const started = Date.now();
+        const paths = toPaths(args["paths"]);
+        if (!paths) {
+          return fail(
+            ERR_BAD_PATHS,
+            "paths \u5FC5\u987B\u662F\u975E\u7A7A\u7684\u6587\u4EF6\u8DEF\u5F84\u6570\u7EC4",
+            '\u628A\u672C\u8F6E\u6539\u52A8\u8FC7\u7684\u6E90\u6587\u4EF6\u5217\u8FDB\u53BB\uFF0C\u4F8B\u5982 {"paths": ["src/a.ts"]}',
+            started
+          );
+        }
+        try {
+          const outcome = await diagnosePaths({
+            paths,
+            workDir: ctx.workDir,
+            pool,
+            ...ctx.signal ? { signal: ctx.signal } : {}
+          });
+          return { success: true, output: formatOutcome(outcome), duration: Date.now() - started };
+        } catch (err) {
+          return fail(
+            ERR_UNEXPECTED,
+            `\u8BCA\u65AD\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`,
+            "\u53EF\u4EE5\u5148\u7EE7\u7EED\uFF0C\u6216\u6539\u7528 terminal \u8DD1\u9879\u76EE\u81EA\u5DF1\u7684\u7C7B\u578B\u68C0\u67E5\u547D\u4EE4",
+            started
+          );
+        }
+      }
+    }
+  ]
+};
+export {
+  DEFAULT_IDLE_MS,
+  DEFAULT_SWEEP_MS,
+  DEFAULT_WAIT,
+  LspClient,
+  LspServerDownError,
+  LspServerPool,
+  MAX_FILES_PER_CALL,
+  MAX_ITEMS,
+  SERVERS,
+  diagnosePaths,
+  disposeLspServers,
+  findUp,
+  formatOutcome,
+  lspPlugin,
+  resolveServer,
+  serverForExtension,
+  supportedExtensions,
+  uriKey
+};