@wrongstack/plug-lsp 0.1.9 → 0.1.10

package/dist/index.js

@@ -1,12 +1,10 @@
-import { TOKENS, atomicWrite } from '@wrongstack/core';
+import { spawn } from 'child_process';
 import * as fs2 from 'fs/promises';
 import * as path from 'path';
-import { spawn } from 'child_process';
+import { TOKENS, atomicWrite } from '@wrongstack/core';
 import { pathToFileURL, fileURLToPath } from 'url';
-import * as fs3 from 'fs';
 import { EventEmitter } from 'events';
-
-// src/config.ts
+import * as fs3 from 'fs';
 
 // src/presets.ts
 var PRESETS = {
@@ -89,8 +87,62 @@ var PRESETS = {
     enabled: true
   }
 };
+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/config.ts
+// 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 PLUGIN_NAME = "@wrongstack/plug-lsp";
 var DEFAULT_CONFIG = {
   autoStart: "lazy",
@@ -200,62 +252,6 @@ function isSeverityName(value) {
 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",
@@ -430,6 +426,11 @@ function toTextDocumentItem(doc) {
   };
 }
 
+// src/server/lifecycle.ts
+function nextReconnectDelay(attempt) {
+  return [1e3, 4e3, 16e3][Math.max(0, Math.min(2, attempt))] ?? 16e3;
+}
+
 // src/types.ts
 var LSPError = class extends Error {
   constructor(code, message, details) {
@@ -441,29 +442,6 @@ var LSPError = class extends Error {
   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 ?? [], {
@@ -563,6 +541,11 @@ var Connection = class {
     this.events.emit("close");
   }
   onData(chunk) {
+    const MAX_BUFFER = 16 * 1024 * 1024;
+    if (this.buffer.length + chunk.length > MAX_BUFFER) {
+      this.close();
+      return;
+    }
     this.buffer = Buffer.concat([this.buffer, chunk]);
     for (; ; ) {
       const sep = this.buffer.indexOf("\r\n\r\n");
@@ -574,6 +557,10 @@ var Connection = class {
         continue;
       }
       const length = Number(match[1]);
+      if (!Number.isFinite(length) || length < 0 || length > MAX_BUFFER) {
+        this.buffer = this.buffer.subarray(sep + 4);
+        continue;
+      }
       const total = sep + 4 + length;
       if (this.buffer.length < total) return;
       const body = this.buffer.subarray(sep + 4, total).toString("utf8");
@@ -590,7 +577,8 @@ var Connection = class {
       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));
+      if (msg.error)
+        pending.reject(new LSPError("LSP_PROTOCOL_ERROR" /* ProtocolError */, msg.error.message, msg.error));
       else pending.resolve(msg.result);
       return;
     }
@@ -623,7 +611,12 @@ var CLIENT_CAPABILITIES = {
     executeCommand: { dynamicRegistration: false }
   },
   textDocument: {
-    synchronization: { didSave: false, dynamicRegistration: false, willSave: false, willSaveWaitUntil: false },
+    synchronization: {
+      didSave: false,
+      dynamicRegistration: false,
+      willSave: false,
+      willSaveWaitUntil: false
+    },
     diagnostic: { dynamicRegistration: false },
     definition: { linkSupport: true },
     references: {},
@@ -642,9 +635,19 @@ async function initializeServer(connection, serverCfg, rootPath, timeoutMs, sign
     rootUri,
     capabilities: CLIENT_CAPABILITIES,
     initializationOptions: serverCfg.initializationOptions,
-    workspaceFolders: [{ uri: rootUri, name: rootPath.split(/[\\/]/).pop() ?? rootPath }]
+    workspaceFolders: [
+      {
+        uri: rootUri,
+        name: rootPath.split(/[\\/]/).pop() ?? rootPath
+      }
+    ]
   };
-  const result = await connection.sendRequest("initialize", params, timeoutMs, signal);
+  const result = await connection.sendRequest(
+    "initialize",
+    params,
+    timeoutMs,
+    signal
+  );
   connection.sendNotification("initialized", {});
   return result.capabilities;
 }
@@ -674,7 +677,8 @@ var LSPServer = class {
     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.state === "ready" || this.state === "starting" || this.state === "initializing")
+      return;
     if (this.config.enabled === false) {
       this.state = "disabled";
       return;
@@ -850,14 +854,18 @@ function startupFailure(child) {
   const promise = new Promise((_, reject) => {
     const onError = (err) => {
       cleanup();
-      reject(new LSPError("LSP_SERVER_FAILED" /* ServerFailed */, `LSP server failed to start: ${err.message}`, err));
+      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"}`
-      ));
+      reject(
+        new LSPError(
+          "LSP_SERVER_FAILED" /* ServerFailed */,
+          `LSP server exited during startup code=${code ?? "null"} signal=${signal ?? "null"}`
+        )
+      );
     };
     cleanup = () => {
       child.off("error", onError);
@@ -868,10 +876,28 @@ function startupFailure(child) {
   });
   return { promise, cancel: cleanup };
 }
-
-// src/server/lifecycle.ts
-function nextReconnectDelay(attempt) {
-  return [1e3, 4e3, 16e3][Math.max(0, Math.min(2, attempt))] ?? 16e3;
+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;
+  }
 }
 
 // src/registry.ts
@@ -899,14 +925,20 @@ var LSPRegistry = class {
     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)))
+        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))));
+    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();
@@ -949,7 +981,11 @@ var LSPRegistry = class {
     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 rootPath = findWorkspaceRoot(
+        path.join(this.cwd, "__probe__"),
+        cfg.rootPatterns,
+        this.cwd
+      );
       const server = new LSPServer(name, cfg, {
         cwd: this.cwd,
         rootPath,
@@ -960,7 +996,9 @@ var LSPRegistry = class {
       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`);
+          this.ctx.log.warn(
+            `LSP language "${language}" is claimed by multiple servers; using first`
+          );
           continue;
         }
         this.languageIndex.set(language, name);
@@ -1019,6 +1057,145 @@ async function detectProjectLanguages(root) {
   return found;
 }
 
+// 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/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/formatters/workspace-edit.ts
 function summarizeWorkspaceEdit(edit, cwd) {
   const entries = editsByPath(edit);
@@ -1095,6 +1272,25 @@ function supportsCodeAction(cap) {
 function supportsPullDiagnostics(cap) {
   return !!cap.diagnosticProvider;
 }
+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)}`;
+}
 async function applyWorkspaceEdit(edit, tracker) {
   const entries = editsByPath(edit);
   const ops = [];
@@ -1122,7 +1318,9 @@ async function applyWorkspaceEdit(edit, tracker) {
 }
 function applyTextEdits(original, edits) {
   const lineStarts = buildLineStarts(original);
-  const sorted = [...edits].sort((a, b) => offsetOf(b.range.start, lineStarts) - offsetOf(a.range.start, lineStarts));
+  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);
@@ -1142,25 +1340,6 @@ function buildLineStarts(text) {
 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) {
@@ -1189,7 +1368,10 @@ function createCodeActionsTool(deps) {
         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`);
+          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 });
@@ -1197,14 +1379,18 @@ function createCodeActionsTool(deps) {
           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);
+        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}.`;
@@ -1250,7 +1436,11 @@ function createDefinitionTool(deps) {
     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" } },
+      properties: {
+        path: { type: "string" },
+        line: { type: "integer" },
+        character: { type: "integer" }
+      },
       required: ["path", "line", "character"]
     },
     permission: "auto",
@@ -1261,11 +1451,18 @@ function createDefinitionTool(deps) {
         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`);
+          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);
+        const locs = await server.definition(
+          { textDocument: { uri: pathToUri(file) }, position },
+          5e3,
+          opts.signal
+        );
         return formatLocations(locs, ctx.cwd);
       } catch (err) {
         return stringifyToolError(err);
@@ -1274,56 +1471,16 @@ function createDefinitionTool(deps) {
   };
 }
 
-// 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" } } },
+    inputSchema: {
+      type: "object",
+      properties: { path: { type: "string" }, limit: { type: "integer" } }
+    },
     permission: "auto",
     mutating: false,
     timeoutMs: 5e3,
@@ -1386,7 +1543,11 @@ function createHoverTool(deps) {
     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" } },
+      properties: {
+        path: { type: "string" },
+        line: { type: "integer" },
+        character: { type: "integer" }
+      },
       required: ["path", "line", "character"]
     },
     permission: "auto",
@@ -1397,11 +1558,20 @@ function createHoverTool(deps) {
         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`);
+          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));
+        return formatHover(
+          await server.hover(
+            { textDocument: { uri: pathToUri(file) }, position },
+            5e3,
+            opts.signal
+          )
+        );
       } catch (err) {
         return stringifyToolError(err);
       }
@@ -1434,15 +1604,22 @@ function createReferencesTool(deps) {
         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`);
+          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);
+        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);
@@ -1476,15 +1653,22 @@ function createRenameTool(deps) {
         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`);
+          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);
+        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);
@@ -1508,7 +1692,9 @@ 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}`);
+    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");
@@ -1516,10 +1702,14 @@ function formatWorkspaceSymbols(symbols, query, cwd, limit = 100) {
 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})`);
+    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}`);
+    lines.push(
+      `${indent}${kindName(sym.kind)} ${sym.name} ${displayPath(uriToPath(sym.location.uri), cwd)}:${sym.location.range.start.line + 1}`
+    );
   }
 }
 function kindName(kind) {
@@ -1561,7 +1751,11 @@ function createSymbolsTool(deps) {
     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" } }
+      properties: {
+        path: { type: "string" },
+        query: { type: "string" },
+        limit: { type: "integer" }
+      }
     },
     permission: "auto",
     mutating: false,
@@ -1572,9 +1766,16 @@ function createSymbolsTool(deps) {
           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`);
+            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);
+          const symbols = await server.documentSymbol(
+            { textDocument: { uri: pathToUri(file) } },
+            5e3,
+            opts.signal
+          );
           return formatDocumentSymbols(file, symbols, ctx.cwd);
         }
         const query = input.query ?? "";
@@ -1606,100 +1807,6 @@ function makeLSPTools(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 = {