@wrongstack/plug-lsp 0.1.7

package/dist/index.js

@@ -0,0 +1,1766 @@
+import { TOKENS, atomicWrite } from '@wrongstack/core';
+import * as fs2 from 'fs/promises';
+import * as path from 'path';
+import { spawn } from 'child_process';
+import { pathToFileURL, fileURLToPath } from 'url';
+import * as fs3 from 'fs';
+import { EventEmitter } from 'events';
+
+// src/config.ts
+
+// src/presets.ts
+var PRESETS = {
+  typescript: {
+    command: "typescript-language-server",
+    args: ["--stdio"],
+    languages: ["typescript", "typescriptreact", "javascript", "javascriptreact"],
+    rootPatterns: ["tsconfig.json", "jsconfig.json", "package.json"],
+    startupTimeoutMs: 15e3,
+    enabled: true
+  },
+  gopls: {
+    command: "gopls",
+    args: ["serve"],
+    languages: ["go"],
+    rootPatterns: ["go.mod", "go.work"],
+    startupTimeoutMs: 15e3,
+    enabled: true
+  },
+  "rust-analyzer": {
+    command: "rust-analyzer",
+    languages: ["rust"],
+    rootPatterns: ["Cargo.toml"],
+    startupTimeoutMs: 15e3,
+    enabled: true
+  },
+  pyright: {
+    command: "pyright-langserver",
+    args: ["--stdio"],
+    languages: ["python"],
+    rootPatterns: ["pyproject.toml", "pyrightconfig.json", "setup.py", "requirements.txt"],
+    startupTimeoutMs: 15e3,
+    enabled: true
+  },
+  json: {
+    command: "vscode-json-language-server",
+    args: ["--stdio"],
+    languages: ["json"],
+    rootPatterns: ["package.json"],
+    startupTimeoutMs: 15e3,
+    enabled: true
+  },
+  html: {
+    command: "vscode-html-language-server",
+    args: ["--stdio"],
+    languages: ["html"],
+    rootPatterns: ["package.json"],
+    startupTimeoutMs: 15e3,
+    enabled: true
+  },
+  css: {
+    command: "vscode-css-language-server",
+    args: ["--stdio"],
+    languages: ["css", "scss"],
+    rootPatterns: ["package.json"],
+    startupTimeoutMs: 15e3,
+    enabled: true
+  },
+  yaml: {
+    command: "yaml-language-server",
+    args: ["--stdio"],
+    languages: ["yaml"],
+    rootPatterns: ["package.json", ".git"],
+    startupTimeoutMs: 15e3,
+    enabled: true
+  },
+  bash: {
+    command: "bash-language-server",
+    args: ["start"],
+    languages: ["shellscript"],
+    rootPatterns: ["package.json", ".git"],
+    startupTimeoutMs: 15e3,
+    enabled: true
+  },
+  "ruby-lsp": {
+    command: "ruby-lsp",
+    languages: ["ruby"],
+    rootPatterns: ["Gemfile", ".ruby-version"],
+    startupTimeoutMs: 15e3,
+    enabled: true
+  }
+};
+
+// src/config.ts
+var PLUGIN_NAME = "@wrongstack/plug-lsp";
+var DEFAULT_CONFIG = {
+  autoStart: "lazy",
+  diagnosticsAfterEdit: "background",
+  diagnosticsWaitMs: 1500,
+  severityFilter: ["error", "warning"],
+  maxDiagnosticsPerFile: 5,
+  maxDiagnosticsTotal: 50,
+  autoDiscover: true,
+  logServerOutput: false
+};
+var plugLspConfigSchema = {
+  type: "object",
+  properties: {
+    servers: { type: "object" },
+    autoStart: { type: "string", enum: ["lazy", "eager", "never"] },
+    diagnosticsAfterEdit: { type: "string", enum: ["background", "manual"] },
+    diagnosticsWaitMs: { type: "integer" },
+    severityFilter: {
+      type: "array",
+      items: { type: "string", enum: ["error", "warning", "info", "hint"] }
+    },
+    maxDiagnosticsPerFile: { type: "integer" },
+    maxDiagnosticsTotal: { type: "integer" },
+    autoDiscover: { type: "boolean" },
+    logServerOutput: { type: "boolean" }
+  }
+};
+function readPlugLSPConfig(api) {
+  const fromStore = readFromConfigStore(api);
+  const raw = fromStore ?? api.config.extensions?.[PLUGIN_NAME] ?? {};
+  return mergeConfig(raw);
+}
+function mergeConfig(raw) {
+  const servers = normalizeServers(raw.servers);
+  const severity = Array.isArray(raw.severityFilter) ? raw.severityFilter.filter(isSeverityName) : DEFAULT_CONFIG.severityFilter;
+  return {
+    servers,
+    autoStart: oneOf(raw.autoStart, ["lazy", "eager", "never"], DEFAULT_CONFIG.autoStart),
+    diagnosticsAfterEdit: oneOf(
+      raw.diagnosticsAfterEdit,
+      ["background", "manual"],
+      DEFAULT_CONFIG.diagnosticsAfterEdit
+    ),
+    diagnosticsWaitMs: positiveInt(raw.diagnosticsWaitMs, DEFAULT_CONFIG.diagnosticsWaitMs),
+    severityFilter: severity.length > 0 ? severity : DEFAULT_CONFIG.severityFilter,
+    maxDiagnosticsPerFile: positiveInt(
+      raw.maxDiagnosticsPerFile,
+      DEFAULT_CONFIG.maxDiagnosticsPerFile
+    ),
+    maxDiagnosticsTotal: positiveInt(raw.maxDiagnosticsTotal, DEFAULT_CONFIG.maxDiagnosticsTotal),
+    autoDiscover: typeof raw.autoDiscover === "boolean" ? raw.autoDiscover : DEFAULT_CONFIG.autoDiscover,
+    logServerOutput: typeof raw.logServerOutput === "boolean" ? raw.logServerOutput : DEFAULT_CONFIG.logServerOutput
+  };
+}
+function readFromConfigStore(api) {
+  if (!api.container.has(TOKENS.ConfigStore)) return void 0;
+  try {
+    return api.container.resolve(TOKENS.ConfigStore).getExtension(PLUGIN_NAME);
+  } catch {
+    return void 0;
+  }
+}
+function normalizeServers(value) {
+  if (!isRecord(value)) return {};
+  const out = {};
+  for (const [name, raw] of Object.entries(value)) {
+    if (!isRecord(raw)) continue;
+    if (typeof raw.command !== "string") continue;
+    if (!Array.isArray(raw.languages) || raw.languages.some((x) => typeof x !== "string")) {
+      continue;
+    }
+    out[name] = {
+      command: raw.command,
+      args: stringArray(raw.args),
+      env: stringRecord(raw.env),
+      languages: raw.languages,
+      rootPatterns: stringArray(raw.rootPatterns),
+      initializationOptions: raw.initializationOptions,
+      settings: raw.settings,
+      startupTimeoutMs: positiveInt(raw.startupTimeoutMs, 15e3),
+      enabled: typeof raw.enabled === "boolean" ? raw.enabled : true
+    };
+  }
+  return out;
+}
+function oneOf(value, allowed, fallback) {
+  return typeof value === "string" && allowed.includes(value) ? value : fallback;
+}
+function positiveInt(value, fallback) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : fallback;
+}
+function stringArray(value) {
+  return Array.isArray(value) && value.every((x) => typeof x === "string") ? value : void 0;
+}
+function stringRecord(value) {
+  if (!isRecord(value)) return void 0;
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    if (typeof v === "string") out[k] = v;
+  }
+  return out;
+}
+function isSeverityName(value) {
+  return value === "error" || value === "warning" || value === "info" || value === "hint";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function resolveServerCommand(command, cwd) {
+  const local = await findLocalBinary(cwd, command);
+  if (local) return local;
+  return await commandExistsOnPath(command) ? command : null;
+}
+async function findLocalBinary(cwd, command) {
+  if (path.isAbsolute(command)) return await fileExists(command) ? path.normalize(command) : null;
+  let dir = path.resolve(cwd);
+  for (; ; ) {
+    const binDir = path.join(dir, "node_modules", ".bin");
+    for (const candidate of commandCandidates(command)) {
+      const full = path.join(binDir, candidate);
+      if (await fileExists(full)) return full;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+async function commandExistsOnPath(command) {
+  const probe = process.platform === "win32" ? "where.exe" : "sh";
+  const args = process.platform === "win32" ? [command] : ["-lc", `command -v ${shellQuote(command)}`];
+  return new Promise((resolve6) => {
+    const child = spawn(probe, args, { stdio: "ignore", windowsHide: true });
+    child.on("error", () => resolve6(false));
+    child.on("close", (code) => resolve6(code === 0));
+  });
+}
+function commandCandidates(command) {
+  if (process.platform !== "win32") return [command];
+  const ext = path.extname(command).toLowerCase();
+  if (ext) return [command];
+  return [`${command}.cmd`, `${command}.exe`, `${command}.bat`, command, `${command}.ps1`];
+}
+async function fileExists(filePath) {
+  try {
+    await fs2.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+
+// src/auto-discover.ts
+async function autoDiscoverServers(userServers, cwd = process.cwd()) {
+  const out = { ...userServers };
+  for (const [name, cfg] of Object.entries(PRESETS)) {
+    if (out[name]) continue;
+    const command = await resolveServerCommand(cfg.command, cwd);
+    if (command) out[name] = { ...cfg, command };
+  }
+  return out;
+}
+var LANGUAGE_MAP = {
+  ".ts": "typescript",
+  ".tsx": "typescriptreact",
+  ".js": "javascript",
+  ".jsx": "javascriptreact",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".go": "go",
+  ".rs": "rust",
+  ".py": "python",
+  ".pyi": "python",
+  ".rb": "ruby",
+  ".java": "java",
+  ".kt": "kotlin",
+  ".swift": "swift",
+  ".c": "c",
+  ".h": "c",
+  ".cpp": "cpp",
+  ".cc": "cpp",
+  ".cxx": "cpp",
+  ".hpp": "cpp",
+  ".cs": "csharp",
+  ".lua": "lua",
+  ".zig": "zig",
+  ".php": "php",
+  ".json": "json",
+  ".html": "html",
+  ".css": "css",
+  ".scss": "scss",
+  ".yml": "yaml",
+  ".yaml": "yaml",
+  ".sh": "shellscript",
+  ".bash": "shellscript"
+};
+var FILENAME_MAP = {
+  Dockerfile: "dockerfile",
+  Makefile: "makefile",
+  "CMakeLists.txt": "cmake",
+  "tsconfig.json": "json",
+  "package.json": "json"
+};
+function languageIdFor(filePath) {
+  const base = path.basename(filePath);
+  const exact = FILENAME_MAP[base];
+  if (exact) return exact;
+  if (base.endsWith(".test.ts") || base.endsWith(".spec.ts")) return "typescript";
+  if (base.endsWith(".test.tsx") || base.endsWith(".spec.tsx")) return "typescriptreact";
+  if (base.endsWith(".test.js") || base.endsWith(".spec.js")) return "javascript";
+  if (base.endsWith(".test.jsx") || base.endsWith(".spec.jsx")) return "javascriptreact";
+  return LANGUAGE_MAP[path.extname(base)] ?? null;
+}
+function pathToUri(filePath) {
+  return pathToFileURL(path.resolve(filePath)).toString();
+}
+function uriToPath(uri) {
+  return fileURLToPath(uri);
+}
+function displayPath(filePath, cwd) {
+  const rel = path.relative(cwd, filePath);
+  return rel && !rel.startsWith("..") && !path.isAbsolute(rel) ? rel.replace(/\\/g, "/") : filePath;
+}
+
+// src/document-tracker.ts
+var DocumentTracker = class {
+  constructor(registry, log, cwd, events) {
+    this.registry = registry;
+    this.log = log;
+    this.events = events;
+    this.cwd = cwd;
+  }
+  registry;
+  log;
+  events;
+  docs = /* @__PURE__ */ new Map();
+  cwd;
+  setCwd(cwd) {
+    this.cwd = cwd;
+  }
+  async handleToolExecuted(event) {
+    if (!event.ok) return;
+    if (event.name !== "read" && event.name !== "edit" && event.name !== "write") return;
+    const input = event.input;
+    if (!input || typeof input.path !== "string") return;
+    const absPath = this.resolve(input.path);
+    if (event.name === "read") await this.open(absPath);
+    else await this.fileWritten(absPath);
+  }
+  async fileWritten(filePath) {
+    const absPath = this.resolve(filePath);
+    const languageId = languageIdFor(absPath);
+    if (!languageId) return;
+    let text;
+    try {
+      text = await fs2.readFile(absPath, "utf8");
+    } catch (err) {
+      this.log.debug(`LSP tracker could not read changed file ${absPath}`, err);
+      return;
+    }
+    const doc = this.docs.get(absPath);
+    if (!doc) {
+      await this.open(absPath, text);
+      return;
+    }
+    doc.version++;
+    doc.text = text;
+    for (const server of this.registry().list()) {
+      if (server.state !== "ready" || !server.config.languages.includes(languageId)) continue;
+      server.notifyDidChange({ uri: doc.uri, version: doc.version }, text);
+      doc.serverNames.add(server.name);
+    }
+  }
+  async open(filePath, knownText) {
+    const absPath = this.resolve(filePath);
+    const languageId = languageIdFor(absPath);
+    if (!languageId) return;
+    const text = knownText ?? await fs2.readFile(absPath, "utf8");
+    let doc = this.docs.get(absPath);
+    if (!doc) {
+      doc = {
+        uri: pathToUri(absPath),
+        path: absPath,
+        languageId,
+        version: 1,
+        text,
+        serverNames: /* @__PURE__ */ new Set()
+      };
+      this.docs.set(absPath, doc);
+      this.events?.emit("lsp.document.opened", { path: absPath, language: languageId });
+    }
+    for (const server of this.registry().list()) {
+      if (server.state !== "ready" || !server.config.languages.includes(languageId)) continue;
+      if (doc.serverNames.has(server.name)) continue;
+      server.notifyDidOpen(toTextDocumentItem(doc));
+      doc.serverNames.add(server.name);
+    }
+  }
+  async reopenForServer(server) {
+    if (server.state !== "ready") return;
+    for (const doc of this.docs.values()) {
+      if (!server.config.languages.includes(doc.languageId)) continue;
+      server.notifyDidOpen(toTextDocumentItem(doc));
+      doc.serverNames.add(server.name);
+    }
+  }
+  async forceCloseAll() {
+    for (const doc of this.docs.values()) {
+      for (const server of this.registry().list()) {
+        if (server.state === "ready" && doc.serverNames.has(server.name)) {
+          server.notifyDidClose(doc.uri);
+          this.events?.emit("lsp.document.closed", { path: doc.path });
+        }
+      }
+    }
+    this.docs.clear();
+  }
+  get(filePath) {
+    return this.docs.get(this.resolve(filePath)) ?? null;
+  }
+  list() {
+    return Array.from(this.docs.values());
+  }
+  resolve(filePath) {
+    return path.isAbsolute(filePath) ? path.normalize(filePath) : path.resolve(this.cwd, filePath);
+  }
+};
+function toTextDocumentItem(doc) {
+  return {
+    uri: doc.uri,
+    languageId: doc.languageId,
+    version: doc.version,
+    text: doc.text
+  };
+}
+
+// src/types.ts
+var LSPError = class extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "LSPError";
+  }
+  code;
+  details;
+};
+function findWorkspaceRoot(filePath, rootPatterns, fallback) {
+  const patterns = rootPatterns?.length ? rootPatterns : [];
+  if (patterns.length === 0) return path.resolve(fallback);
+  let dir = path.dirname(path.resolve(filePath));
+  const stop = path.parse(dir).root;
+  for (; ; ) {
+    for (const pattern of patterns) {
+      if (matchesAt(dir, pattern)) return dir;
+    }
+    if (dir === stop) return path.resolve(fallback);
+    dir = path.dirname(dir);
+  }
+}
+function matchesAt(dir, pattern) {
+  if (!pattern.includes("*")) return fs3.existsSync(path.join(dir, pattern));
+  const escaped = pattern.split("*").map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join(".*");
+  const re = new RegExp(`^${escaped}$`);
+  try {
+    return fs3.readdirSync(dir).some((name) => re.test(name));
+  } catch {
+    return false;
+  }
+}
+function safeSpawn(cfg, cwd) {
+  const shell = process.platform === "win32" && /\.(cmd|bat)$/i.test(cfg.command);
+  return spawn(cfg.command, cfg.args ?? [], {
+    cwd,
+    env: { ...process.env, ...cfg.env ?? {} },
+    stdio: ["pipe", "pipe", "pipe"],
+    shell,
+    windowsHide: true
+  });
+}
+
+// src/utils/timeout.ts
+async function promiseWithTimeout(promise, ms, signal) {
+  if (signal?.aborted) throw abortError(signal);
+  let timer;
+  return await new Promise((resolve6, reject) => {
+    const cleanup = () => {
+      if (timer) clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+    };
+    const onAbort = () => {
+      cleanup();
+      reject(abortError(signal));
+    };
+    timer = setTimeout(() => {
+      cleanup();
+      reject(new LSPError("LSP_REQUEST_TIMEOUT" /* RequestTimeout */, `LSP request timed out after ${ms}ms`));
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (value) => {
+        cleanup();
+        resolve6(value);
+      },
+      (err) => {
+        cleanup();
+        reject(err);
+      }
+    );
+  });
+}
+function abortError(signal) {
+  return signal?.reason instanceof Error ? signal.reason : new Error("aborted");
+}
+
+// src/server/connection.ts
+var Connection = class {
+  constructor(stdin, stdout) {
+    this.stdin = stdin;
+    stdout.on("data", (chunk) => this.onData(chunk));
+    stdout.on("close", () => this.close());
+    stdout.on("error", (err) => this.failAll(err));
+  }
+  stdin;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  events = new EventEmitter();
+  buffer = Buffer.alloc(0);
+  closed = false;
+  async sendRequest(method, params, timeoutMs, signal) {
+    this.assertOpen();
+    const id = this.nextId++;
+    const request = { jsonrpc: "2.0", id, method, params };
+    const response = new Promise((resolve6, reject) => {
+      this.pending.set(id, { resolve: resolve6, reject });
+      this.write(request);
+    });
+    try {
+      return await promiseWithTimeout(response, timeoutMs, signal);
+    } catch (err) {
+      this.pending.delete(id);
+      if (signal.aborted) {
+        try {
+          this.sendNotification("$/cancelRequest", { id });
+        } catch {
+        }
+      }
+      throw normalizeError(err);
+    }
+  }
+  sendNotification(method, params) {
+    this.assertOpen();
+    this.write({ jsonrpc: "2.0", method, params });
+  }
+  onNotification(method, handler) {
+    this.events.on(method, handler);
+    return () => this.events.off(method, handler);
+  }
+  onClose(handler) {
+    this.events.on("close", handler);
+    return () => this.events.off("close", handler);
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.failAll(new LSPError("LSP_PROTOCOL_ERROR" /* ProtocolError */, "LSP connection closed"));
+    this.events.emit("close");
+  }
+  onData(chunk) {
+    this.buffer = Buffer.concat([this.buffer, chunk]);
+    for (; ; ) {
+      const sep = this.buffer.indexOf("\r\n\r\n");
+      if (sep === -1) return;
+      const header = this.buffer.subarray(0, sep).toString("ascii");
+      const match = /Content-Length:\s*(\d+)/i.exec(header);
+      if (!match) {
+        this.buffer = this.buffer.subarray(sep + 4);
+        continue;
+      }
+      const length = Number(match[1]);
+      const total = sep + 4 + length;
+      if (this.buffer.length < total) return;
+      const body = this.buffer.subarray(sep + 4, total).toString("utf8");
+      this.buffer = this.buffer.subarray(total);
+      try {
+        this.handleMessage(JSON.parse(body));
+      } catch {
+      }
+    }
+  }
+  handleMessage(msg) {
+    if (msg.id !== void 0 && msg.id !== null && !msg.method) {
+      const id = Number(msg.id);
+      const pending = this.pending.get(id);
+      if (!pending) return;
+      this.pending.delete(id);
+      if (msg.error) pending.reject(new LSPError("LSP_PROTOCOL_ERROR" /* ProtocolError */, msg.error.message, msg.error));
+      else pending.resolve(msg.result);
+      return;
+    }
+    if (msg.method) this.events.emit(msg.method, msg.params);
+  }
+  write(message) {
+    const body = JSON.stringify(message);
+    const bytes = Buffer.byteLength(body, "utf8");
+    this.stdin.write(`Content-Length: ${bytes}\r
+\r
+${body}`, "utf8");
+  }
+  assertOpen() {
+    if (this.closed) throw new LSPError("LSP_PROTOCOL_ERROR" /* ProtocolError */, "LSP connection is closed");
+  }
+  failAll(err) {
+    for (const pending of this.pending.values()) pending.reject(normalizeError(err));
+    this.pending.clear();
+  }
+};
+function normalizeError(err) {
+  if (err instanceof Error) return err;
+  return new LSPError("LSP_PROTOCOL_ERROR" /* ProtocolError */, String(err));
+}
+var CLIENT_CAPABILITIES = {
+  workspace: {
+    workspaceFolders: true,
+    didChangeWatchedFiles: { dynamicRegistration: false },
+    symbol: {},
+    executeCommand: { dynamicRegistration: false }
+  },
+  textDocument: {
+    synchronization: { didSave: false, dynamicRegistration: false, willSave: false, willSaveWaitUntil: false },
+    diagnostic: { dynamicRegistration: false },
+    definition: { linkSupport: true },
+    references: {},
+    hover: { contentFormat: ["markdown", "plaintext"] },
+    documentSymbol: { hierarchicalDocumentSymbolSupport: true },
+    rename: { prepareSupport: true },
+    codeAction: {}
+  },
+  general: { positionEncodings: ["utf-16"] }
+};
+async function initializeServer(connection, serverCfg, rootPath, timeoutMs, signal) {
+  const rootUri = pathToFileURL(rootPath).toString();
+  const params = {
+    processId: process.pid,
+    rootPath,
+    rootUri,
+    capabilities: CLIENT_CAPABILITIES,
+    initializationOptions: serverCfg.initializationOptions,
+    workspaceFolders: [{ uri: rootUri, name: rootPath.split(/[\\/]/).pop() ?? rootPath }]
+  };
+  const result = await connection.sendRequest("initialize", params, timeoutMs, signal);
+  connection.sendNotification("initialized", {});
+  return result.capabilities;
+}
+
+// src/server/lsp-server.ts
+var LSPServer = class {
+  constructor(name, config, ctx) {
+    this.name = name;
+    this.config = config;
+    this.ctx = ctx;
+    if (config.enabled === false) this.state = "disabled";
+  }
+  name;
+  config;
+  ctx;
+  state = "exited";
+  capabilities = null;
+  diagnostics = /* @__PURE__ */ new Map();
+  child = null;
+  connection = null;
+  processReachedReady = false;
+  stderrRing = [];
+  get rootPath() {
+    return this.ctx.rootPath;
+  }
+  get lastStderr() {
+    return this.stderrRing.slice(-20).join("\n");
+  }
+  async start(signal = new AbortController().signal) {
+    if (this.state === "ready" || this.state === "starting" || this.state === "initializing") return;
+    if (this.config.enabled === false) {
+      this.state = "disabled";
+      return;
+    }
+    this.state = "starting";
+    this.processReachedReady = false;
+    this.ctx.events.emit("lsp.server.starting", { name: this.name, command: this.config.command });
+    const child = safeSpawn(this.config, this.ctx.rootPath);
+    this.child = child;
+    child.stderr.on("data", (chunk) => this.captureStderr(chunk));
+    child.on("exit", (code, sig) => {
+      const shouldReconnect = this.processReachedReady;
+      this.connection?.close();
+      this.connection = null;
+      this.child = null;
+      if (this.state !== "shutting_down" && this.state !== "exited") {
+        this.state = "failed";
+        this.ctx.events.emit("lsp.server.crashed", {
+          name: this.name,
+          error: `process exited code=${code ?? "null"} signal=${sig ?? "null"}`
+        });
+        if (shouldReconnect) this.ctx.onCrash?.(this);
+      }
+      this.ctx.events.emit("lsp.server.exited", { name: this.name, code, signal: sig });
+      this.processReachedReady = false;
+    });
+    child.on("error", (err) => {
+      const shouldReconnect = this.processReachedReady;
+      this.state = "failed";
+      this.ctx.events.emit("lsp.server.crashed", { name: this.name, error: err.message });
+      if (shouldReconnect) this.ctx.onCrash?.(this);
+      this.processReachedReady = false;
+    });
+    this.connection = new Connection(child.stdin, child.stdout);
+    this.connection.onNotification("textDocument/publishDiagnostics", (params) => {
+      const p = params;
+      if (!p.uri || !Array.isArray(p.diagnostics)) return;
+      this.diagnostics.set(p.uri, p.diagnostics);
+      this.ctx.events.emit("lsp.diagnostics.updated", {
+        path: p.uri.startsWith("file:") ? uriToPath(p.uri) : p.uri,
+        count: p.diagnostics.length
+      });
+    });
+    this.connection.onNotification("window/logMessage", (params) => {
+      if (this.config.enabled !== false && params && this.config) {
+        this.ctx.log.debug(`LSP ${this.name} log`, params);
+      }
+    });
+    this.connection.onClose(() => {
+      if (this.state === "ready") this.state = "failed";
+    });
+    this.state = "initializing";
+    const startup = startupFailure(child);
+    try {
+      this.capabilities = await Promise.race([
+        initializeServer(
+          this.connection,
+          this.config,
+          this.ctx.rootPath,
+          this.config.startupTimeoutMs ?? 15e3,
+          signal
+        ),
+        startup.promise
+      ]);
+      startup.cancel();
+      this.state = "ready";
+      this.processReachedReady = true;
+      this.ctx.events.emit("lsp.server.ready", {
+        name: this.name,
+        languages: this.config.languages
+      });
+    } catch (err) {
+      startup.cancel();
+      this.state = "failed";
+      this.connection?.close();
+      this.child?.kill();
+      this.processReachedReady = false;
+      throw err;
+    }
+  }
+  async shutdown() {
+    if (this.state === "exited" || this.state === "disabled") return;
+    this.state = "shutting_down";
+    try {
+      if (this.connection) {
+        const ctrl = new AbortController();
+        await this.connection.sendRequest("shutdown", null, 3e3, ctrl.signal).catch(() => void 0);
+        this.connection.sendNotification("exit", null);
+      }
+    } finally {
+      this.connection?.close();
+      this.connection = null;
+      if (this.child && !this.child.killed) this.child.kill();
+      this.child = null;
+      this.processReachedReady = false;
+      this.state = "exited";
+    }
+  }
+  async definition(params, timeoutMs, signal) {
+    return await this.request("textDocument/definition", params, timeoutMs, signal);
+  }
+  async references(params, timeoutMs, signal) {
+    return await this.request("textDocument/references", params, timeoutMs, signal);
+  }
+  async hover(params, timeoutMs, signal) {
+    return await this.request("textDocument/hover", params, timeoutMs, signal);
+  }
+  async documentSymbol(params, timeoutMs, signal) {
+    return await this.request("textDocument/documentSymbol", params, timeoutMs, signal);
+  }
+  async workspaceSymbol(params, timeoutMs, signal) {
+    return await this.request("workspace/symbol", params, timeoutMs, signal);
+  }
+  async prepareRename(params, timeoutMs, signal) {
+    return await this.request("textDocument/prepareRename", params, timeoutMs, signal);
+  }
+  async rename(params, timeoutMs, signal) {
+    return await this.request("textDocument/rename", params, timeoutMs, signal);
+  }
+  async codeAction(params, timeoutMs, signal) {
+    return await this.request("textDocument/codeAction", params, timeoutMs, signal) ?? [];
+  }
+  async executeCommand(params, timeoutMs, signal) {
+    return await this.request("workspace/executeCommand", params, timeoutMs, signal);
+  }
+  async pullDiagnostics(uri, timeoutMs, signal) {
+    const result = await this.request(
+      "textDocument/diagnostic",
+      { textDocument: { uri } },
+      timeoutMs,
+      signal
+    );
+    const items = result?.items ?? [];
+    this.diagnostics.set(uri, items);
+    return items;
+  }
+  getDiagnostics(uri) {
+    return this.diagnostics.get(uri) ?? [];
+  }
+  notifyDidOpen(doc) {
+    this.notification("textDocument/didOpen", { textDocument: doc });
+  }
+  notifyDidChange(doc, text) {
+    this.notification("textDocument/didChange", {
+      textDocument: doc,
+      contentChanges: [{ text }]
+    });
+  }
+  notifyDidClose(uri) {
+    this.notification("textDocument/didClose", { textDocument: { uri } });
+  }
+  textDocumentIdentifier(filePath) {
+    return { uri: pathToUri(filePath) };
+  }
+  async request(method, params, timeoutMs, signal) {
+    if (this.state !== "ready" || !this.connection) {
+      throw new LSPError("LSP_SERVER_NOT_READY" /* ServerNotReady */, `Server "${this.name}" is not ready`);
+    }
+    return await this.connection.sendRequest(method, params, timeoutMs, signal);
+  }
+  notification(method, params) {
+    if (this.state !== "ready" || !this.connection) return;
+    this.connection.sendNotification(method, params);
+  }
+  captureStderr(chunk) {
+    const lines = chunk.toString("utf8").split(/\r?\n/).filter(Boolean);
+    this.stderrRing.push(...lines);
+    if (this.stderrRing.length > 100) this.stderrRing = this.stderrRing.slice(-100);
+  }
+};
+function startupFailure(child) {
+  let cleanup = () => void 0;
+  const promise = new Promise((_, reject) => {
+    const onError = (err) => {
+      cleanup();
+      reject(new LSPError("LSP_SERVER_FAILED" /* ServerFailed */, `LSP server failed to start: ${err.message}`, err));
+    };
+    const onExit = (code, signal) => {
+      cleanup();
+      reject(new LSPError(
+        "LSP_SERVER_FAILED" /* ServerFailed */,
+        `LSP server exited during startup code=${code ?? "null"} signal=${signal ?? "null"}`
+      ));
+    };
+    cleanup = () => {
+      child.off("error", onError);
+      child.off("exit", onExit);
+    };
+    child.once("error", onError);
+    child.once("exit", onExit);
+  });
+  return { promise, cancel: cleanup };
+}
+
+// src/server/lifecycle.ts
+function nextReconnectDelay(attempt) {
+  return [1e3, 4e3, 16e3][Math.max(0, Math.min(2, attempt))] ?? 16e3;
+}
+
+// src/registry.ts
+var LSPRegistry = class {
+  constructor(cfg, tracker, ctx) {
+    this.cfg = cfg;
+    this.tracker = tracker;
+    this.ctx = ctx;
+    this.cwd = ctx.cwd;
+    this.autoStart = cfg.autoStart;
+  }
+  cfg;
+  tracker;
+  ctx;
+  servers = /* @__PURE__ */ new Map();
+  languageIndex = /* @__PURE__ */ new Map();
+  reconnectAttempts = /* @__PURE__ */ new Map();
+  reconnectTimers = /* @__PURE__ */ new Map();
+  cwd;
+  autoStart;
+  async bind(cwd, autoStart = this.cfg.autoStart) {
+    this.cwd = cwd;
+    this.autoStart = autoStart;
+    this.rebuildServers();
+    if (autoStart === "eager") {
+      const languages = await detectProjectLanguages(cwd);
+      await Promise.all(
+        this.list().filter((s) => s.config.languages.some((lang) => languages.has(lang))).map((s) => s.start().catch((err) => this.ctx.log.warn(`LSP ${s.name} failed to start`, err)))
+      );
+    }
+  }
+  async shutdown() {
+    for (const timer of this.reconnectTimers.values()) clearTimeout(timer);
+    this.reconnectTimers.clear();
+    await Promise.all(this.list().map((s) => s.shutdown().catch((err) => this.ctx.log.warn(`LSP ${s.name} shutdown failed`, err))));
+  }
+  async findForPath(filePath, signal) {
+    if (this.servers.size === 0) this.rebuildServers();
+    const language = languageIdFor(filePath);
+    if (!language) return null;
+    const name = this.languageIndex.get(language);
+    if (!name) return null;
+    const server = this.servers.get(name);
+    if (!server) return null;
+    if (server.state !== "ready" && this.autoStart === "lazy") {
+      await server.start(signal);
+      await this.tracker.reopenForServer(server);
+    }
+    return server.state === "ready" ? server : null;
+  }
+  get(name) {
+    if (this.servers.size === 0) this.rebuildServers();
+    return this.servers.get(name) ?? null;
+  }
+  list() {
+    if (this.servers.size === 0) this.rebuildServers();
+    return Array.from(this.servers.values());
+  }
+  async start(name) {
+    const server = this.getOrThrow(name);
+    await server.start();
+    await this.tracker.reopenForServer(server);
+  }
+  async stop(name) {
+    await this.getOrThrow(name).shutdown();
+  }
+  async restart(name) {
+    const server = this.getOrThrow(name);
+    await server.shutdown();
+    await server.start();
+    await this.tracker.reopenForServer(server);
+  }
+  rebuildServers() {
+    this.servers.clear();
+    this.languageIndex.clear();
+    for (const [name, cfg] of Object.entries(this.cfg.servers)) {
+      if (cfg.enabled === false) continue;
+      const rootPath = findWorkspaceRoot(path.join(this.cwd, "__probe__"), cfg.rootPatterns, this.cwd);
+      const server = new LSPServer(name, cfg, {
+        cwd: this.cwd,
+        rootPath,
+        log: this.ctx.log,
+        events: this.ctx.events,
+        onCrash: (crashed) => this.scheduleReconnect(crashed)
+      });
+      this.servers.set(name, server);
+      for (const language of cfg.languages) {
+        if (this.languageIndex.has(language)) {
+          this.ctx.log.warn(`LSP language "${language}" is claimed by multiple servers; using first`);
+          continue;
+        }
+        this.languageIndex.set(language, name);
+      }
+    }
+  }
+  getOrThrow(name) {
+    const server = this.get(name);
+    if (!server) throw new LSPError("LSP_SERVER_NOT_FOUND" /* ServerNotFound */, `No LSP server named "${name}"`);
+    return server;
+  }
+  scheduleReconnect(server) {
+    if (this.reconnectTimers.has(server.name)) return;
+    const attempt = this.reconnectAttempts.get(server.name) ?? 0;
+    if (attempt >= 3) {
+      this.ctx.log.warn(`LSP ${server.name} reconnect attempts exhausted`);
+      return;
+    }
+    this.reconnectAttempts.set(server.name, attempt + 1);
+    server.state = "reconnecting";
+    const timer = setTimeout(() => {
+      this.reconnectTimers.delete(server.name);
+      void server.start().then(() => {
+        this.reconnectAttempts.delete(server.name);
+        return this.tracker.reopenForServer(server);
+      }).catch((err) => {
+        this.ctx.log.warn(`LSP ${server.name} reconnect attempt ${attempt + 1} failed`, err);
+        server.state = "failed";
+        this.scheduleReconnect(server);
+      });
+    }, nextReconnectDelay(attempt));
+    this.reconnectTimers.set(server.name, timer);
+  }
+};
+async function detectProjectLanguages(root) {
+  const found = /* @__PURE__ */ new Set();
+  const visit = async (dir, depth) => {
+    if (depth > 3) return;
+    let entries;
+    try {
+      entries = await fs2.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git") continue;
+      const p = path.join(dir, entry.name);
+      if (entry.isDirectory()) await visit(p, depth + 1);
+      else {
+        const lang = languageIdFor(p);
+        if (lang) found.add(lang);
+      }
+    }
+  };
+  await visit(root, 0);
+  return found;
+}
+
+// src/formatters/workspace-edit.ts
+function summarizeWorkspaceEdit(edit, cwd) {
+  const entries = editsByPath(edit);
+  if (entries.size === 0) return "WorkspaceEdit contains no text edits.";
+  let total = 0;
+  const lines = ["Workspace edit:"];
+  for (const [file, edits] of entries) {
+    total += edits.length;
+    lines.push(`  ${displayPath(file, cwd)} ${edits.length} edit(s)`);
+  }
+  lines.push(`Total: ${total} edits across ${entries.size} files.`);
+  return lines.join("\n");
+}
+function editsByPath(edit) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [uri, edits] of Object.entries(edit.changes ?? {})) {
+    out.set(uriToPath(uri), edits);
+  }
+  for (const change of edit.documentChanges ?? []) {
+    if ("textDocument" in change && Array.isArray(change.edits)) {
+      out.set(uriToPath(change.textDocument.uri), change.edits);
+    }
+  }
+  return out;
+}
+
+// src/position.ts
+function humanToLSP(content, pos) {
+  const lines = splitLines(content);
+  const lineIdx = clamp(pos.line - 1, 0, Math.max(0, lines.length - 1));
+  const line = lines[lineIdx] ?? "";
+  const byteCol = clamp(pos.character - 1, 0, Buffer.byteLength(line, "utf8"));
+  let bytes = 0;
+  let utf16 = 0;
+  for (const ch of line) {
+    const b = Buffer.byteLength(ch, "utf8");
+    if (bytes + b > byteCol) break;
+    bytes += b;
+    utf16 += ch.length;
+  }
+  return { line: lineIdx, character: utf16 };
+}
+function splitLines(content) {
+  if (content.length === 0) return [""];
+  return content.split(/\r\n|\r|\n/);
+}
+function clamp(n, min, max) {
+  if (!Number.isFinite(n)) return min;
+  return Math.max(min, Math.min(max, n));
+}
+
+// src/server/capabilities.ts
+function supportsHover(cap) {
+  return !!cap.hoverProvider;
+}
+function supportsDefinition(cap) {
+  return !!cap.definitionProvider;
+}
+function supportsReferences(cap) {
+  return !!cap.referencesProvider;
+}
+function supportsDocumentSymbol(cap) {
+  return !!cap.documentSymbolProvider;
+}
+function supportsWorkspaceSymbol(cap) {
+  return !!cap.workspaceSymbolProvider;
+}
+function supportsRename(cap) {
+  return !!cap.renameProvider;
+}
+function supportsCodeAction(cap) {
+  return !!cap.codeActionProvider;
+}
+function supportsPullDiagnostics(cap) {
+  return !!cap.diagnosticProvider;
+}
+async function applyWorkspaceEdit(edit, tracker) {
+  const entries = editsByPath(edit);
+  const ops = [];
+  for (const [file, edits] of entries) {
+    const original = await fs2.readFile(file, "utf8");
+    ops.push({ path: file, original, next: applyTextEdits(original, edits), edits: edits.length });
+  }
+  const written = [];
+  try {
+    for (const op of ops) {
+      await atomicWrite(op.path, op.next);
+      written.push(op);
+    }
+  } catch (err) {
+    for (const op of written) {
+      try {
+        await atomicWrite(op.path, op.original);
+      } catch {
+      }
+    }
+    throw new LSPError("LSP_APPLY_EDIT_FAILED" /* ApplyEditFailed */, "Failed to apply workspace edit", err);
+  }
+  for (const op of ops) await tracker.fileWritten(op.path);
+  return { files: ops.map((op) => op.path), edits: ops.reduce((sum, op) => sum + op.edits, 0) };
+}
+function applyTextEdits(original, edits) {
+  const lineStarts = buildLineStarts(original);
+  const sorted = [...edits].sort((a, b) => offsetOf(b.range.start, lineStarts) - offsetOf(a.range.start, lineStarts));
+  let out = original;
+  for (const edit of sorted) {
+    const start = offsetOf(edit.range.start, lineStarts);
+    const end = offsetOf(edit.range.end, lineStarts);
+    out = out.slice(0, start) + edit.newText + out.slice(end);
+  }
+  return out;
+}
+function buildLineStarts(text) {
+  const starts = [0];
+  for (let i = 0; i < text.length; i++) {
+    const ch = text.charCodeAt(i);
+    if (ch === 10) starts.push(i + 1);
+  }
+  return starts;
+}
+function offsetOf(pos, lineStarts) {
+  return (lineStarts[pos.line] ?? lineStarts[lineStarts.length - 1] ?? 0) + pos.character;
+}
+function resolveInputPath(inputPath, ctx) {
+  return path.isAbsolute(inputPath) ? path.normalize(inputPath) : path.resolve(ctx.cwd, inputPath);
+}
+async function requireServer(registry, filePath, signal) {
+  const server = await registry.findForPath(filePath, signal);
+  if (!server) {
+    throw new LSPError("LSP_SERVER_NOT_FOUND" /* ServerNotFound */, `No LSP server is configured for ${filePath}`);
+  }
+  return server;
+}
+async function readDocumentContent(filePath, tracker) {
+  const tracked = tracker.get(filePath);
+  return tracked?.text ?? await fs2.readFile(filePath, "utf8");
+}
+function stringifyToolError(err) {
+  if (err instanceof LSPError) return `[${err.code}] ${err.message}`;
+  if (err instanceof Error) return `[${"LSP_PROTOCOL_ERROR" /* ProtocolError */}] ${err.message}`;
+  return `[${"LSP_PROTOCOL_ERROR" /* ProtocolError */}] ${String(err)}`;
+}
+
+// src/tools/code-actions.ts
+function createCodeActionsTool(deps) {
+  return {
+    name: "lsp_code_actions",
+    description: "List or apply LSP code actions.",
+    usageHint: "Use to inspect quick fixes and refactors. This tool is confirm-gated because apply mode can mutate files.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string" },
+        line: { type: "integer" },
+        character: { type: "integer" },
+        end_line: { type: "integer" },
+        end_character: { type: "integer" },
+        apply: { type: "integer" },
+        kind_filter: { type: "string" }
+      },
+      required: ["path", "line"]
+    },
+    permission: "confirm",
+    mutating: true,
+    timeoutMs: 1e4,
+    async execute(input, ctx, opts) {
+      try {
+        const file = resolveInputPath(input.path, ctx);
+        const server = await requireServer(deps.registry, file, opts.signal);
+        if (server.capabilities && !supportsCodeAction(server.capabilities)) {
+          throw new LSPError("LSP_CAPABILITY_MISSING" /* CapabilityMissing */, `Server "${server.name}" does not support code actions`);
+        }
+        const content = await readDocumentContent(file, deps.tracker);
+        const start = humanToLSP(content, { line: input.line, character: input.character ?? 1 });
+        const end = humanToLSP(content, {
+          line: input.end_line ?? input.line,
+          character: input.end_character ?? input.character ?? 1
+        });
+        const actions = await server.codeAction({
+          textDocument: { uri: pathToUri(file) },
+          range: { start, end },
+          context: {
+            diagnostics: server.getDiagnostics(pathToUri(file)),
+            only: input.kind_filter ? [input.kind_filter] : void 0
+          }
+        }, 1e4, opts.signal);
+        if (input.apply === void 0) return formatActions(actions);
+        const action = actions[input.apply];
+        if (!action) return `No code action at index ${input.apply}.`;
+        const parts = [`Applying [${input.apply}] ${action.title}`];
+        if (action.edit) {
+          parts.push(summarizeWorkspaceEdit(action.edit, ctx.cwd));
+          const applied = await applyWorkspaceEdit(action.edit, deps.tracker);
+          parts.push(`Applied: ${applied.edits} edits across ${applied.files.length} files.`);
+        }
+        if (action.command) {
+          await server.executeCommand(action.command, 1e4, opts.signal);
+          parts.push(`Executed command: ${action.command.command}`);
+        }
+        return parts.join("\n");
+      } catch (err) {
+        return stringifyToolError(err);
+      }
+    }
+  };
+}
+function formatActions(actions) {
+  if (actions.length === 0) return "No code actions available.";
+  return actions.map((a, i) => `[${i}] ${a.kind ?? "action"} ${a.title}`).join("\n");
+}
+
+// src/formatters/location.ts
+function formatLocations(locations, cwd, limit = 100) {
+  if (!locations || locations.length === 0) return "No locations found.";
+  const lines = locations.slice(0, limit).map((loc) => {
+    const uri = "uri" in loc ? loc.uri : loc.targetUri;
+    const range = "range" in loc ? loc.range : loc.targetSelectionRange;
+    return `${displayPath(uriToPath(uri), cwd)}:${range.start.line + 1}:${range.start.character + 1}`;
+  });
+  if (locations.length > limit) lines.push(`... truncated ${locations.length - limit} more`);
+  return lines.join("\n");
+}
+
+// src/tools/definition.ts
+function createDefinitionTool(deps) {
+  return {
+    name: "lsp_definition",
+    description: "Find where a symbol is defined.",
+    usageHint: "Use for semantic navigation when you know the symbol position. Lines and columns are 1-based.",
+    inputSchema: {
+      type: "object",
+      properties: { path: { type: "string" }, line: { type: "integer" }, character: { type: "integer" } },
+      required: ["path", "line", "character"]
+    },
+    permission: "auto",
+    mutating: false,
+    timeoutMs: 5e3,
+    async execute(input, ctx, opts) {
+      try {
+        const file = resolveInputPath(input.path, ctx);
+        const server = await requireServer(deps.registry, file, opts.signal);
+        if (server.capabilities && !supportsDefinition(server.capabilities)) {
+          throw new LSPError("LSP_CAPABILITY_MISSING" /* CapabilityMissing */, `Server "${server.name}" does not support definition`);
+        }
+        const content = await readDocumentContent(file, deps.tracker);
+        const position = humanToLSP(content, { line: input.line, character: input.character });
+        const locs = await server.definition({ textDocument: { uri: pathToUri(file) }, position }, 5e3, opts.signal);
+        return formatLocations(locs, ctx.cwd);
+      } catch (err) {
+        return stringifyToolError(err);
+      }
+    }
+  };
+}
+
+// src/formatters/diagnostics.ts
+var SEVERITY = {
+  1: "error",
+  2: "warning",
+  3: "info",
+  4: "hint"
+};
+var LABEL = {
+  error: "ERROR",
+  warning: "WARN",
+  info: "INFO",
+  hint: "HINT"
+};
+function formatDiagnostics(byFile, opts) {
+  const allowed = new Set(opts.severityFilter);
+  const sections = [];
+  let total = 0;
+  let files = 0;
+  for (const [file, diagnostics] of byFile.entries()) {
+    const filtered = diagnostics.filter((d) => allowed.has(SEVERITY[d.severity ?? 1] ?? "error")).sort(compareDiagnostics).slice(0, opts.maxPerFile);
+    if (filtered.length === 0) continue;
+    files++;
+    total += filtered.length;
+    const lines = filtered.map((d) => formatDiagnostic(d));
+    sections.push(`${displayPath(file, opts.cwd)} (${filtered.length}):
+${lines.map((l) => `  ${l}`).join("\n")}`);
+    if (total >= opts.maxTotal) break;
+  }
+  if (sections.length === 0) return "No LSP diagnostics.";
+  return `${sections.join("\n\n")}
+
+Total: ${total} diagnostics in ${files} files.`;
+}
+function formatDiagnostic(d) {
+  const sev = SEVERITY[d.severity ?? 1] ?? "error";
+  const source = d.source ? ` ${d.source}${d.code !== void 0 ? `(${String(d.code)})` : ""}` : "";
+  const msg = d.message.replace(/\s*\r?\n\s*/g, " | ");
+  return `L${d.range.start.line + 1}:${d.range.start.character + 1} ${LABEL[sev]}${source}: ${msg}`;
+}
+function compareDiagnostics(a, b) {
+  return (a.severity ?? 1) - (b.severity ?? 1) || a.range.start.line - b.range.start.line || a.range.start.character - b.range.start.character;
+}
+
+// src/tools/diagnostics.ts
+function createDiagnosticsTool(deps) {
+  return {
+    name: "lsp_diagnostics",
+    description: "Get diagnostics from configured language servers.",
+    usageHint: "Use after reading or editing a file when an LSP server is configured. Pass `path` for file diagnostics or omit it for tracked workspace diagnostics.",
+    inputSchema: { type: "object", properties: { path: { type: "string" }, limit: { type: "integer" } } },
+    permission: "auto",
+    mutating: false,
+    timeoutMs: 5e3,
+    maxOutputBytes: 65536,
+    async execute(input, ctx, opts) {
+      try {
+        const byFile = /* @__PURE__ */ new Map();
+        if (input.path) {
+          const file = resolveInputPath(input.path, ctx);
+          const server = await requireServer(deps.registry, file, opts.signal);
+          const uri = pathToUri(file);
+          const diagnostics = server.capabilities && supportsPullDiagnostics(server.capabilities) ? await server.pullDiagnostics(uri, 5e3, opts.signal) : server.getDiagnostics(uri);
+          byFile.set(file, diagnostics);
+        } else {
+          for (const doc of deps.tracker.list()) {
+            const server = await deps.registry.findForPath(doc.path, opts.signal);
+            if (!server) continue;
+            byFile.set(uriToPath(doc.uri), server.getDiagnostics(doc.uri));
+          }
+        }
+        return formatDiagnostics(byFile, {
+          cwd: ctx.cwd,
+          severityFilter: deps.cfg.severityFilter,
+          maxPerFile: deps.cfg.maxDiagnosticsPerFile,
+          maxTotal: input.limit ?? deps.cfg.maxDiagnosticsTotal
+        });
+      } catch (err) {
+        return stringifyToolError(err);
+      }
+    }
+  };
+}
+
+// src/formatters/hover.ts
+function formatHover(hover, maxChars = 4096) {
+  if (!hover) return "No hover information.";
+  const text = hoverContentsToString(hover.contents).trim();
+  if (!text) return "No hover information.";
+  return text.length > maxChars ? `${text.slice(0, maxChars)}
+...[truncated]` : text;
+}
+function hoverContentsToString(contents) {
+  if (typeof contents === "string") return contents;
+  if (Array.isArray(contents)) return contents.map(markedStringToString).join("\n\n");
+  if ("kind" in contents && "value" in contents) return contents.value;
+  return markedStringToString(contents);
+}
+function markedStringToString(value) {
+  if (typeof value === "string") return value;
+  return `\`\`\`${value.language}
+${value.value}
+\`\`\``;
+}
+
+// src/tools/hover.ts
+function createHoverTool(deps) {
+  return {
+    name: "lsp_hover",
+    description: "Get type information and documentation for a symbol.",
+    usageHint: "Use when you need a type/signature without opening the definition.",
+    inputSchema: {
+      type: "object",
+      properties: { path: { type: "string" }, line: { type: "integer" }, character: { type: "integer" } },
+      required: ["path", "line", "character"]
+    },
+    permission: "auto",
+    mutating: false,
+    timeoutMs: 5e3,
+    async execute(input, ctx, opts) {
+      try {
+        const file = resolveInputPath(input.path, ctx);
+        const server = await requireServer(deps.registry, file, opts.signal);
+        if (server.capabilities && !supportsHover(server.capabilities)) {
+          throw new LSPError("LSP_CAPABILITY_MISSING" /* CapabilityMissing */, `Server "${server.name}" does not support hover`);
+        }
+        const content = await readDocumentContent(file, deps.tracker);
+        const position = humanToLSP(content, { line: input.line, character: input.character });
+        return formatHover(await server.hover({ textDocument: { uri: pathToUri(file) }, position }, 5e3, opts.signal));
+      } catch (err) {
+        return stringifyToolError(err);
+      }
+    }
+  };
+}
+
+// src/tools/references.ts
+function createReferencesTool(deps) {
+  return {
+    name: "lsp_references",
+    description: "Find references to a symbol.",
+    usageHint: "Use instead of grep when the symbol position is known; it is syntax-aware.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string" },
+        line: { type: "integer" },
+        character: { type: "integer" },
+        include_declaration: { type: "boolean" },
+        limit: { type: "integer" }
+      },
+      required: ["path", "line", "character"]
+    },
+    permission: "auto",
+    mutating: false,
+    timeoutMs: 1e4,
+    async execute(input, ctx, opts) {
+      try {
+        const file = resolveInputPath(input.path, ctx);
+        const server = await requireServer(deps.registry, file, opts.signal);
+        if (server.capabilities && !supportsReferences(server.capabilities)) {
+          throw new LSPError("LSP_CAPABILITY_MISSING" /* CapabilityMissing */, `Server "${server.name}" does not support references`);
+        }
+        const content = await readDocumentContent(file, deps.tracker);
+        const position = humanToLSP(content, { line: input.line, character: input.character });
+        const locs = await server.references({
+          textDocument: { uri: pathToUri(file) },
+          position,
+          context: { includeDeclaration: input.include_declaration ?? true }
+        }, 1e4, opts.signal);
+        return formatLocations(locs, ctx.cwd, input.limit ?? 100);
+      } catch (err) {
+        return stringifyToolError(err);
+      }
+    }
+  };
+}
+
+// src/tools/rename.ts
+function createRenameTool(deps) {
+  return {
+    name: "lsp_rename",
+    description: "Rename a symbol semantically across the workspace.",
+    usageHint: "Prefer this over find-and-replace for functions, classes, variables, and types. This mutates files and requires confirmation.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string" },
+        line: { type: "integer" },
+        character: { type: "integer" },
+        new_name: { type: "string" }
+      },
+      required: ["path", "line", "character", "new_name"]
+    },
+    permission: "confirm",
+    mutating: true,
+    timeoutMs: 15e3,
+    maxOutputBytes: 65536,
+    async execute(input, ctx, opts) {
+      try {
+        const file = resolveInputPath(input.path, ctx);
+        const server = await requireServer(deps.registry, file, opts.signal);
+        if (server.capabilities && !supportsRename(server.capabilities)) {
+          throw new LSPError("LSP_CAPABILITY_MISSING" /* CapabilityMissing */, `Server "${server.name}" does not support rename`);
+        }
+        const content = await readDocumentContent(file, deps.tracker);
+        const position = humanToLSP(content, { line: input.line, character: input.character });
+        const edit = await server.rename({
+          textDocument: { uri: pathToUri(file) },
+          position,
+          newName: input.new_name
+        }, 15e3, opts.signal);
+        if (!edit) return "Rename produced no edits.";
+        const summary = summarizeWorkspaceEdit(edit, ctx.cwd);
+        const applied = await applyWorkspaceEdit(edit, deps.tracker);
+        return `${summary}
+Applied: ${applied.edits} edits across ${applied.files.length} files.`;
+      } catch (err) {
+        return stringifyToolError(err);
+      }
+    }
+  };
+}
+
+// src/formatters/symbols.ts
+function formatDocumentSymbols(path8, symbols, cwd) {
+  if (!symbols || symbols.length === 0) return "No symbols found.";
+  const lines = [`${displayPath(path8, cwd)}:`];
+  for (const sym of symbols) appendSymbol(lines, sym, 1, cwd);
+  return lines.join("\n");
+}
+function formatWorkspaceSymbols(symbols, query, cwd, limit = 100) {
+  if (!symbols || symbols.length === 0) return `No symbols matching "${query}".`;
+  const lines = [`${symbols.length} symbols matching "${query}":`];
+  for (const sym of symbols.slice(0, limit)) {
+    lines.push(`  ${kindName(sym.kind)} ${sym.name} ${displayPath(uriToPath(sym.location.uri), cwd)}:${sym.location.range.start.line + 1}`);
+  }
+  if (symbols.length > limit) lines.push(`  ... truncated ${symbols.length - limit} more`);
+  return lines.join("\n");
+}
+function appendSymbol(lines, sym, depth, cwd) {
+  const indent = "  ".repeat(depth);
+  if ("selectionRange" in sym) {
+    lines.push(`${indent}${kindName(sym.kind)} ${sym.name} (L${sym.selectionRange.start.line + 1})`);
+    for (const child of sym.children ?? []) appendSymbol(lines, child, depth + 1, cwd);
+  } else {
+    lines.push(`${indent}${kindName(sym.kind)} ${sym.name} ${displayPath(uriToPath(sym.location.uri), cwd)}:${sym.location.range.start.line + 1}`);
+  }
+}
+function kindName(kind) {
+  return [
+    "file",
+    "module",
+    "namespace",
+    "package",
+    "class",
+    "method",
+    "property",
+    "field",
+    "constructor",
+    "enum",
+    "interface",
+    "function",
+    "variable",
+    "constant",
+    "string",
+    "number",
+    "boolean",
+    "array",
+    "object",
+    "key",
+    "null",
+    "enumMember",
+    "struct",
+    "event",
+    "operator",
+    "typeParameter"
+  ][kind - 1] ?? "symbol";
+}
+
+// src/tools/symbols.ts
+function createSymbolsTool(deps) {
+  return {
+    name: "lsp_symbols",
+    description: "List symbols in a file or search workspace symbols.",
+    usageHint: "Pass `path` for a file outline, or `query` for workspace symbol search.",
+    inputSchema: {
+      type: "object",
+      properties: { path: { type: "string" }, query: { type: "string" }, limit: { type: "integer" } }
+    },
+    permission: "auto",
+    mutating: false,
+    timeoutMs: 5e3,
+    async execute(input, ctx, opts) {
+      try {
+        if (input.path) {
+          const file = resolveInputPath(input.path, ctx);
+          const server = await requireServer(deps.registry, file, opts.signal);
+          if (server.capabilities && !supportsDocumentSymbol(server.capabilities)) {
+            throw new LSPError("LSP_CAPABILITY_MISSING" /* CapabilityMissing */, `Server "${server.name}" does not support document symbols`);
+          }
+          const symbols = await server.documentSymbol({ textDocument: { uri: pathToUri(file) } }, 5e3, opts.signal);
+          return formatDocumentSymbols(file, symbols, ctx.cwd);
+        }
+        const query = input.query ?? "";
+        const merged = [];
+        for (const server of deps.registry.list()) {
+          if (server.state !== "ready") continue;
+          if (server.capabilities && !supportsWorkspaceSymbol(server.capabilities)) continue;
+          const result = await server.workspaceSymbol({ query }, 5e3, opts.signal);
+          if (result) merged.push(...result);
+        }
+        return formatWorkspaceSymbols(merged, query, ctx.cwd, input.limit ?? 100);
+      } catch (err) {
+        return stringifyToolError(err);
+      }
+    }
+  };
+}
+
+// src/tools/index.ts
+function makeLSPTools(deps) {
+  return [
+    createDiagnosticsTool(deps),
+    createDefinitionTool(deps),
+    createReferencesTool(deps),
+    createHoverTool(deps),
+    createSymbolsTool(deps),
+    createRenameTool(deps),
+    createCodeActionsTool(deps)
+  ];
+}
+
+// src/slash-commands/diagnostics.ts
+function diagnosticsCommand(registry) {
+  return {
+    name: "diagnostics",
+    description: "Print buffered LSP diagnostics.",
+    async run(_args, ctx) {
+      const byFile = /* @__PURE__ */ new Map();
+      for (const server of registry.list()) {
+        for (const [uri, diagnostics] of server.diagnostics.entries()) {
+          byFile.set(uriToPath(uri), diagnostics);
+        }
+      }
+      return {
+        message: formatDiagnostics(byFile, {
+          cwd: ctx.cwd,
+          severityFilter: ["error", "warning"],
+          maxPerFile: 10,
+          maxTotal: 100
+        })
+      };
+    }
+  };
+}
+
+// src/slash-commands/list.ts
+function listCommand(registry) {
+  return {
+    name: "list",
+    description: "List configured LSP servers.",
+    async run() {
+      const rows = registry.list().map((s) => {
+        const langs = s.config.languages.join(",");
+        return `${s.name.padEnd(18)} ${s.state.padEnd(14)} ${langs} ${s.rootPath}`;
+      });
+      return { message: rows.length ? rows.join("\n") : "No LSP servers configured." };
+    }
+  };
+}
+
+// src/slash-commands/restart.ts
+function restartCommand(registry) {
+  return {
+    name: "restart",
+    description: "Restart an LSP server.",
+    async run(args) {
+      const name = args.trim();
+      if (!name) return { message: "Usage: /@wrongstack/plug-lsp:restart <name>" };
+      await registry.restart(name);
+      return { message: `Restarted LSP server "${name}".` };
+    }
+  };
+}
+
+// src/slash-commands/start.ts
+function startCommand(registry) {
+  return {
+    name: "start",
+    description: "Start an LSP server.",
+    async run(args) {
+      const name = args.trim();
+      if (!name) return { message: "Usage: /@wrongstack/plug-lsp:start <name>" };
+      await registry.start(name);
+      return { message: `Started LSP server "${name}".` };
+    }
+  };
+}
+
+// src/slash-commands/stop.ts
+function stopCommand(registry) {
+  return {
+    name: "stop",
+    description: "Stop an LSP server.",
+    async run(args) {
+      const name = args.trim();
+      if (!name) return { message: "Usage: /@wrongstack/plug-lsp:stop <name>" };
+      await registry.stop(name);
+      return { message: `Stopped LSP server "${name}".` };
+    }
+  };
+}
+
+// src/slash-commands/index.ts
+function registerSlashCommands(api, registry) {
+  const commands = [
+    listCommand(registry),
+    startCommand(registry),
+    stopCommand(registry),
+    restartCommand(registry),
+    diagnosticsCommand(registry)
+  ];
+  for (const command of commands) api.slashCommands.register(command);
+  return commands.map((cmd) => cmd.name);
+}
+
+// src/index.ts
+var teardownState = null;
+var plugin = {
+  name: PLUGIN_NAME,
+  version: "0.1.0",
+  description: "Language Server Protocol tools for WrongStack.",
+  apiVersion: "^0.1.1",
+  capabilities: {
+    tools: true,
+    slashCommands: true,
+    pipelines: []
+  },
+  configSchema: plugLspConfigSchema,
+  async setup(api) {
+    const cfg = readPlugLSPConfig(api);
+    const cwd = api.config.cwd ?? process.cwd();
+    if (cfg.autoDiscover) {
+      cfg.servers = await autoDiscoverServers(cfg.servers, cwd);
+    }
+    const holder = {};
+    const tracker = new DocumentTracker(() => holder.registry, api.log, cwd, api.events);
+    const registry = new LSPRegistry(cfg, tracker, { cwd, log: api.log, events: api.events });
+    holder.registry = registry;
+    await registry.bind(cwd, cfg.autoStart);
+    const tools = makeLSPTools({ registry, tracker, cfg, log: api.log });
+    for (const tool of tools) api.tools.register(tool);
+    const commandNames = registerSlashCommands(api, registry);
+    const offs = [
+      api.events.on("session.started", () => {
+        const nextCwd = api.config.cwd ?? process.cwd();
+        tracker.setCwd(nextCwd);
+        void registry.bind(nextCwd, cfg.autoStart);
+      }),
+      api.events.on("session.ended", () => {
+        void tracker.forceCloseAll().finally(() => registry.shutdown());
+      }),
+      api.events.on("tool.executed", (event) => {
+        void tracker.handleToolExecuted(event);
+      })
+    ];
+    teardownState = {
+      offs,
+      toolNames: tools.map((t) => t.name),
+      commandNames,
+      registry,
+      tracker
+    };
+  },
+  async teardown(api) {
+    const state = teardownState;
+    if (!state) return;
+    teardownState = null;
+    for (const off of state.offs) off();
+    for (const name of state.toolNames) api.tools.unregister(name);
+    for (const name of state.commandNames) api.slashCommands.unregister(`${PLUGIN_NAME}:${name}`);
+    await state.tracker.forceCloseAll();
+    await state.registry.shutdown();
+  }
+};
+var index_default = plugin;
+
+export { index_default as default };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map