@wrongstack/plug-lsp 0.265.1 → 0.267.0

package/dist/index.js

@@ -1,13 +1,278 @@
-import { expectDefined, TOKENS, buildChildEnv, atomicWrite } from '@wrongstack/core';
 import { spawn } from 'child_process';
 import * as fs2 from 'fs/promises';
 import * as path from 'path';
+import { buildChildEnv, expectDefined, TOKENS, atomicWrite } from '@wrongstack/core';
 import { pathToFileURL, fileURLToPath } from 'url';
 import { EventEmitter } from 'events';
 import * as fs3 from 'fs';
 import { codebaseIndexDirOverride, searchCodebaseIndex, internalKindToLspKind, lspKindToInternalKind } from '@wrongstack/tools/codebase-index/index';
 
-// src/index.ts
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: 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, timeoutMs = 2e3) {
+  const probe = process.platform === "win32" ? "where.exe" : "sh";
+  const args = process.platform === "win32" ? [command] : ["-lc", `command -v ${shellQuote(command)}`];
+  return new Promise((resolve7) => {
+    const child = spawn(probe, args, { env: buildChildEnv(), stdio: "ignore", windowsHide: true });
+    const timer = setTimeout(() => {
+      child.kill();
+      resolve7(false);
+    }, timeoutMs);
+    timer.unref?.();
+    child.on("error", () => {
+      clearTimeout(timer);
+      resolve7(false);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve7(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, "'\\''")}'`;
+}
+var init_command_resolver = __esm({
+  "src/utils/command-resolver.ts"() {
+  }
+});
+
+// src/slash-commands/install.ts
+var install_exports = {};
+__export(install_exports, {
+  LANGUAGE_SERVERS: () => LANGUAGE_SERVERS,
+  SUPPORTED_LANGUAGES: () => SUPPORTED_LANGUAGES,
+  installLang: () => installLang
+});
+async function installLang(language, server, cwd, dryRun = false) {
+  const existing = await resolveServerCommand(server.binary, cwd);
+  if (existing) {
+    return { language, binary: server.binary, alreadyInstalled: true, dryRun: false };
+  }
+  if (server.toolchain) {
+    const { command, args, label } = server.toolchain;
+    if (!await commandExistsOnPath(command)) {
+      return {
+        language,
+        binary: server.binary,
+        alreadyInstalled: false,
+        dryRun,
+        installCommand: `${command} ${args.join(" ")}`,
+        error: `${label} (${command}) is not on your PATH. Install it first.`
+      };
+    }
+    const installCmd = `${command} ${args.join(" ")}`;
+    if (dryRun) {
+      return { language, binary: server.binary, alreadyInstalled: false, dryRun: true, installCommand: installCmd };
+    }
+    await runCommand(command, args, cwd, label);
+    return { language, binary: server.binary, alreadyInstalled: false, dryRun: false, packageManager: "system", installCommand: installCmd };
+  }
+  if (server.npmPackages && server.npmPackages.length > 0) {
+    const { command, args } = npmInstallCommand(server.npmPackages, cwd);
+    const installCmd = `${command} ${args.join(" ")}`;
+    if (dryRun) {
+      return { language, binary: server.binary, alreadyInstalled: false, dryRun: true, installCommand: installCmd };
+    }
+    try {
+      await runCommand(command, args, cwd, `Installing ${language} LSP server via npm`);
+      return { language, binary: server.binary, alreadyInstalled: false, dryRun: false, installCommand: installCmd };
+    } catch (err) {
+      return {
+        language,
+        binary: server.binary,
+        alreadyInstalled: false,
+        dryRun: false,
+        installCommand: installCmd,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  return {
+    language,
+    binary: server.binary,
+    alreadyInstalled: false,
+    dryRun,
+    error: "No installation method available for this server."
+  };
+}
+function npmInstallCommand(packages, cwd) {
+  const pm = detectPackageManagerSync(cwd);
+  if (pm === "pnpm") return { command: "pnpm", args: ["add", "-D", ...packages] };
+  if (pm === "yarn") return { command: "yarn", args: ["add", "-D", ...packages] };
+  if (pm === "bun") return { command: "bun", args: ["add", "-d", ...packages] };
+  return { command: "npm", args: ["install", "-D", ...packages] };
+}
+function detectPackageManagerSync(cwd) {
+  if (existsSync2(path.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync2(path.join(cwd, "bun.lockb")) || existsSync2(path.join(cwd, "bun.lock"))) return "bun";
+  if (existsSync2(path.join(cwd, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+function existsSync2(filePath) {
+  try {
+    __require("fs").accessSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function runCommand(command, args, cwd, label) {
+  return new Promise((resolve7, reject) => {
+    const isWindowsBatch = process.platform === "win32" && /\.(cmd|bat)$/i.test(command);
+    const child = spawn(command, args, {
+      cwd,
+      env: buildChildEnv(),
+      stdio: "inherit",
+      shell: isWindowsBatch,
+      windowsHide: true
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) resolve7();
+      else reject(new Error(`${label}: ${command} exited with code ${code ?? "null"}`));
+    });
+  });
+}
+var LANGUAGE_SERVERS, SUPPORTED_LANGUAGES;
+var init_install = __esm({
+  "src/slash-commands/install.ts"() {
+    init_command_resolver();
+    LANGUAGE_SERVERS = {
+      typescript: {
+        binary: "typescript-language-server",
+        npmPackages: ["typescript", "typescript-language-server"],
+        args: ["--stdio"],
+        languages: ["typescript", "typescriptreact", "javascript", "javascriptreact"],
+        rootPatterns: ["tsconfig.json", "jsconfig.json", "package.json"]
+      },
+      python: {
+        binary: "pyright-langserver",
+        npmPackages: ["pyright"],
+        args: ["--stdio"],
+        languages: ["python"],
+        rootPatterns: ["pyproject.toml", "pyrightconfig.json", "setup.py", "requirements.txt"]
+      },
+      json: {
+        binary: "vscode-json-language-server",
+        npmPackages: ["vscode-langservers-extracted"],
+        args: ["--stdio"],
+        languages: ["json"],
+        rootPatterns: ["package.json"]
+      },
+      html: {
+        binary: "vscode-html-language-server",
+        npmPackages: ["vscode-langservers-extracted"],
+        args: ["--stdio"],
+        languages: ["html"],
+        rootPatterns: ["package.json"]
+      },
+      css: {
+        binary: "vscode-css-language-server",
+        npmPackages: ["vscode-langservers-extracted"],
+        args: ["--stdio"],
+        languages: ["css", "scss"],
+        rootPatterns: ["package.json"]
+      },
+      yaml: {
+        binary: "yaml-language-server",
+        npmPackages: ["yaml-language-server"],
+        args: ["--stdio"],
+        languages: ["yaml"],
+        rootPatterns: ["package.json", ".git"]
+      },
+      shell: {
+        binary: "bash-language-server",
+        npmPackages: ["bash-language-server"],
+        args: ["start"],
+        languages: ["shellscript"],
+        rootPatterns: ["package.json", ".git"]
+      },
+      go: {
+        binary: "gopls",
+        toolchain: {
+          command: "go",
+          args: ["install", "golang.org/x/tools/gopls@latest"],
+          label: "Go toolchain"
+        },
+        languages: ["go"],
+        rootPatterns: ["go.mod", "go.work"]
+      },
+      rust: {
+        binary: "rust-analyzer",
+        toolchain: {
+          command: "rustup",
+          args: ["component", "add", "rust-analyzer"],
+          label: "Rust toolchain"
+        },
+        languages: ["rust"],
+        rootPatterns: ["Cargo.toml"]
+      },
+      ruby: {
+        binary: "ruby-lsp",
+        toolchain: {
+          command: "gem",
+          args: ["install", "ruby-lsp"],
+          label: "RubyGems"
+        },
+        languages: ["ruby"],
+        rootPatterns: ["Gemfile", ".ruby-version"]
+      }
+    };
+    SUPPORTED_LANGUAGES = Object.keys(LANGUAGE_SERVERS);
+  }
+});
 
 // src/presets.ts
 var PRESETS = {
@@ -90,64 +355,9 @@ 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, timeoutMs = 2e3) {
-  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, { env: buildChildEnv(), stdio: "ignore", windowsHide: true });
-    const timer = setTimeout(() => {
-      child.kill();
-      resolve6(false);
-    }, timeoutMs);
-    timer.unref?.();
-    child.on("error", () => {
-      clearTimeout(timer);
-      resolve6(false);
-    });
-    child.on("close", (code) => {
-      clearTimeout(timer);
-      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
+init_command_resolver();
 async function autoDiscoverServers(userServers, cwd = process.cwd()) {
   const out = { ...userServers };
   const pending = Object.entries(PRESETS).filter(([name]) => !out[name]);
@@ -473,7 +683,7 @@ function safeSpawn(cfg, cwd) {
 async function promiseWithTimeout(promise, ms, signal) {
   if (signal?.aborted) throw abortError(signal);
   let timer;
-  return await new Promise((resolve6, reject) => {
+  return await new Promise((resolve7, reject) => {
     const cleanup = () => {
       if (timer) clearTimeout(timer);
       signal?.removeEventListener("abort", onAbort);
@@ -490,7 +700,7 @@ async function promiseWithTimeout(promise, ms, signal) {
     promise.then(
       (value) => {
         cleanup();
-        resolve6(value);
+        resolve7(value);
       },
       (err) => {
         cleanup();
@@ -521,8 +731,8 @@ var Connection = class {
     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 });
+    const response = new Promise((resolve7, reject) => {
+      this.pending.set(id, { resolve: resolve7, reject });
       this.write(request);
     });
     try {
@@ -1209,10 +1419,444 @@ function stopCommand(registry) {
     }
   };
 }
+init_install();
+function parseArgs(args) {
+  const parts = args.trim().split(/\s+/).filter(Boolean);
+  if (parts.length === 0) return { type: "list" };
+  const sub = parts[0].toLowerCase();
+  if (sub === "list" || sub === "ls") return { type: "list" };
+  if (sub === "status" || sub === "stat") return { type: "status" };
+  if (sub === "help" || sub === "h" || sub === "--help") return { type: "help" };
+  if (sub === "install" || sub === "add") {
+    const lang = parts[1];
+    if (!lang) return { type: "help" };
+    return { type: "install", language: lang };
+  }
+  if (sub === "start") return { type: "start", name: parts[1] };
+  if (sub === "stop") return { type: "stop", name: parts[1] };
+  if (sub === "restart" || sub === "reload") return { type: "restart", name: parts[1] };
+  if (sub === "diagnostics" || sub === "diag") {
+    return { type: "diagnostics", file: parts[1] };
+  }
+  if (sub === "remove" || sub === "rm" || sub === "delete") {
+    const name = parts[1];
+    if (!name) return { type: "help" };
+    return { type: "remove", name };
+  }
+  if (sub === "enable") {
+    const name = parts[1];
+    if (!name) return { type: "help" };
+    return { type: "enable", name };
+  }
+  if (sub === "disable") {
+    const name = parts[1];
+    if (!name) return { type: "help" };
+    return { type: "disable", name };
+  }
+  return { type: "help" };
+}
+function colorize(text, code) {
+  const colors = {
+    green: "\x1B[32m",
+    red: "\x1B[31m",
+    yellow: "\x1B[33m",
+    cyan: "\x1B[36m",
+    bold: "\x1B[1m",
+    dim: "\x1B[2m",
+    reset: "\x1B[0m"
+  };
+  return `${colors[code] ?? ""}${text}${colors.reset}`;
+}
+function buildLspCommand(ctx) {
+  return {
+    name: "lsp",
+    category: "Inspect",
+    aliases: ["lsplsp"],
+    description: "Manage LSP language servers: /lsp [list|install <lang>|start [name]|stop [name]|restart [name]|diagnostics [file]|add|remove|enable|disable]",
+    argsHint: "[list|install <lang>|start [name]|stop [name]|restart [name]|diagnostics [file]]",
+    help: [
+      "Usage:",
+      "  /lsp                          Show server list and status (alias for list)",
+      "  /lsp list                     List all configured servers and their states",
+      "  /lsp status                   Detailed status report for all servers",
+      "  /lsp install <language>      Install the language server for a given language",
+      "                                Supported: " + SUPPORTED_LANGUAGES.join(", "),
+      "  /lsp start [name]             Start all servers, or a specific one by name",
+      "  /lsp stop [name]              Stop all servers, or a specific one by name",
+      "  /lsp restart [name]           Restart all servers, or a specific one by name",
+      "  /lsp diagnostics [file]      Show diagnostics for a file or the whole workspace",
+      "",
+      "Examples:",
+      "  /lsp                          (shows configured servers)",
+      "  /lsp list",
+      "  /lsp install typescript",
+      "  /lsp install python",
+      "  /lsp install go",
+      "  /lsp start                    (start all enabled servers)",
+      "  /lsp start gopls              (start a specific server)",
+      "  /lsp diagnostics src/index.ts",
+      "  /lsp status",
+      "",
+      "After installing, add the server to your WrongStack config under:",
+      '  extensions["@wrongstack/plug-lsp"].servers',
+      "Then restart your WrongStack session."
+    ].join("\n"),
+    async run(args) {
+      const sub = parseArgs(args);
+      switch (sub.type) {
+        case "list":
+          return runListCommand(ctx);
+        case "status":
+          return runStatusCommand(ctx);
+        case "install":
+          return runInstallCommand(ctx, sub.language);
+        case "start":
+          return runStartCommand(ctx, sub.name);
+        case "stop":
+          return runStopCommand(ctx, sub.name);
+        case "restart":
+          return runRestartCommand(ctx, sub.name);
+        case "diagnostics":
+          return runDiagnosticsCommand(ctx, sub.file);
+        case "add":
+          return { message: 'To add a custom server, edit your config and add an entry under\n`extensions["@wrongstack/plug-lsp"].servers`. Run `/lsp help` for usage.' };
+        case "remove":
+          return { message: 'To remove a server, remove its entry from `extensions["@wrongstack/plug-lsp"].servers`\nin your WrongStack config, then restart.' };
+        case "enable":
+          return { message: "To enable a server, ensure `enabled: true` is set (or absent \u2014 it defaults to true)\nin its config entry, then run `/lsp start <name>`." };
+        case "disable":
+          return { message: "To disable a server, set `enabled: false` in its config entry,\nthen run `/lsp stop <name>` to stop it." };
+        case "help":
+        default:
+          return { message: this.help ?? this.description };
+      }
+    }
+  };
+}
+function runListCommand(ctx) {
+  const servers = ctx.registry.list();
+  if (servers.length === 0) {
+    return {
+      message: [
+        `${colorize("LSP Servers", "bold")}`,
+        "No servers configured.",
+        "",
+        "Enable @wrongstack/plug-lsp in your config and add server definitions under",
+        '`extensions["@wrongstack/plug-lsp"].servers`, or run `/lsp install <language>`',
+        "to install a preset server."
+      ].join("\n")
+    };
+  }
+  const lines = [`${colorize("LSP Servers", "bold")}  (${servers.length} configured)`];
+  lines.push("\u2500".repeat(60));
+  for (const srv of servers) {
+    const state = srv.state;
+    const enabled = srv.config.enabled ?? true;
+    const stateColor = state === "ready" ? "green" : state === "failed" ? "red" : state === "disabled" ? "dim" : "yellow";
+    const stateLabel = `[${state.toUpperCase()}]`;
+    const enabledLabel = enabled ? "" : colorize(" (disabled)", "dim");
+    const langs = srv.config.languages?.join(", ") ?? "";
+    lines.push(
+      `  ${colorize(srv.name, "cyan")}  ${colorize(stateLabel, stateColor)}${enabledLabel}`
+    );
+    lines.push(`    ${colorize("Languages:", "dim")} ${langs}`);
+    lines.push(`    ${colorize("Command:", "dim")} ${srv.config.command} ${(srv.config.args ?? []).join(" ")}`);
+    lines.push("");
+  }
+  lines.push("\u2500".repeat(60));
+  lines.push("Run `/lsp help` for usage, or `/lsp install <language>` to install a server.");
+  return { message: lines.join("\n") };
+}
+function runStatusCommand(ctx) {
+  const servers = ctx.registry.list();
+  const ready = servers.filter((s) => s.state === "ready").length;
+  const failed = servers.filter((s) => s.state === "failed").length;
+  const starting = servers.filter((s) => s.state === "starting" || s.state === "initializing").length;
+  const lines = [
+    `${colorize("LSP Status Report", "bold")}`,
+    "\u2500".repeat(60),
+    `  ${colorize("Total servers:", "dim")}  ${servers.length}`,
+    `  ${colorize("Ready:", "dim")}          ${colorize(String(ready), "green")}`,
+    `  ${colorize("Starting:", "dim")}       ${colorize(String(starting), "yellow")}`,
+    `  ${colorize("Failed:", "dim")}         ${colorize(String(failed), "red")}`,
+    ""
+  ];
+  if (failed > 0) {
+    lines.push(`${colorize("Failed servers:", "red")}`);
+    for (const srv of servers.filter((s) => s.state === "failed")) {
+      const err = srv.lastStderr || "unknown error";
+      lines.push(`  ${colorize(srv.name, "cyan")} \u2014 ${err}`);
+    }
+    lines.push("");
+  }
+  const activeFiles = ctx.tracker.list().length;
+  lines.push(`  ${colorize("Active files tracked:", "dim")} ${activeFiles}`);
+  lines.push(`  ${colorize("Auto-start mode:", "dim")} ${ctx.cfg.autoStart}`);
+  lines.push("");
+  lines.push("\u2500".repeat(60));
+  lines.push("Use `/lsp diagnostics` to check for problems, or `/lsp restart <name>` to recover.");
+  return { message: lines.join("\n") };
+}
+async function runInstallCommand(ctx, language) {
+  const lang = language.toLowerCase().trim();
+  if (!SUPPORTED_LANGUAGES.includes(lang)) {
+    return {
+      message: [
+        `${colorize("Unknown language:", "red")} ${lang}`,
+        `Supported languages: ${SUPPORTED_LANGUAGES.join(", ")}`,
+        "",
+        "If the language server is already installed on your system, you can add it",
+        'manually to your WrongStack config under `extensions["@wrongstack/plug-lsp"].servers`.',
+        "Run `/lsp help` for instructions."
+      ].join("\n")
+    };
+  }
+  const server = LANGUAGE_SERVERS[lang];
+  try {
+    const { installLang: installLang2 } = await Promise.resolve().then(() => (init_install(), install_exports));
+    const result = await installLang2(lang, server, ctx.cwd);
+    if (result.alreadyInstalled) {
+      return {
+        message: [
+          `${colorize("Already installed:", "green")} ${lang}`,
+          `  Binary: ${colorize(server.binary, "cyan")}`,
+          "",
+          "The server is already available. Add it to your config to activate:",
+          "",
+          "```json",
+          JSON.stringify(
+            {
+              extensions: {
+                "@wrongstack/plug-lsp": {
+                  servers: {
+                    [lang]: {
+                      command: server.binary,
+                      args: server.args ?? ["--stdio"],
+                      languages: server.languages,
+                      rootPatterns: server.rootPatterns ?? []
+                    }
+                  }
+                }
+              }
+            },
+            null,
+            2
+          ),
+          "```",
+          "",
+          "Then restart your WrongStack session to load the server."
+        ].join("\n")
+      };
+    }
+    if (result.dryRun) {
+      return {
+        message: [
+          `${colorize("Dry run \u2014 would install:", "yellow")} ${lang}`,
+          `  ${result.installCommand}`,
+          "",
+          "Run without --dry-run to actually install."
+        ].join("\n")
+      };
+    }
+    return {
+      message: [
+        `${colorize("Installed:", "green")} ${lang}`,
+        `  Binary: ${colorize(server.binary, "cyan")}`,
+        `  Method:  ${result.packageManager === "system" ? server.toolchain.label : result.installCommand}`,
+        "",
+        "Add this to your WrongStack config to activate the server:",
+        "",
+        "```json",
+        JSON.stringify(
+          {
+            extensions: {
+              "@wrongstack/plug-lsp": {
+                servers: {
+                  [lang]: {
+                    command: server.binary,
+                    args: server.args ?? ["--stdio"],
+                    languages: server.languages,
+                    rootPatterns: server.rootPatterns ?? []
+                  }
+                }
+              }
+            }
+          },
+          null,
+          2
+        ),
+        "```",
+        "",
+        "Restart your WrongStack session to load the server, then run `/lsp start ${lang}`."
+      ].join("\n")
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+      message: `${colorize("Installation failed:", "red")} ${lang}
+  ${msg}`
+    };
+  }
+}
+async function runStartCommand(ctx, name) {
+  const targetName = name?.trim();
+  if (targetName) {
+    const srv = ctx.registry.list().find((s) => s.name === targetName);
+    if (!srv) {
+      const available = ctx.registry.list().map((s) => s.name);
+      return {
+        message: [
+          `${colorize("Server not found:", "red")} ${targetName}`,
+          available.length > 0 ? `Available: ${available.join(", ")}` : "No servers configured.",
+          "Run `/lsp install <language>` to install a server."
+        ].join("\n")
+      };
+    }
+    try {
+      await ctx.registry.start(targetName);
+      return { message: `${colorize("Started:", "green")} ${targetName}` };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { message: `${colorize("Failed to start:", "red")} ${targetName}
+  ${msg}` };
+    }
+  }
+  const allServers = ctx.registry.list();
+  const started = [];
+  const failed = [];
+  for (const srv of allServers) {
+    if (!srv.config.enabled) continue;
+    if (srv.state === "ready") {
+      started.push(srv.name);
+      continue;
+    }
+    if (srv.state === "disabled") continue;
+    try {
+      await ctx.registry.start(srv.name);
+      started.push(srv.name);
+    } catch {
+      failed.push(srv.name);
+    }
+  }
+  const lines = [];
+  if (started.length > 0) lines.push(`${colorize("Started:", "green")} ${started.join(", ")}`);
+  if (failed.length > 0) lines.push(`${colorize("Failed to start:", "red")} ${failed.join(", ")}`);
+  if (started.length === 0 && failed.length === 0) {
+    lines.push("No servers to start. Run `/lsp list` to see configured servers.");
+  }
+  return { message: lines.join("\n") };
+}
+async function runStopCommand(ctx, name) {
+  const targetName = name?.trim();
+  if (targetName) {
+    const srv = ctx.registry.list().find((s) => s.name === targetName);
+    if (!srv) {
+      return { message: `${colorize("Server not found:", "red")} ${targetName}` };
+    }
+    ctx.registry.stop(targetName);
+    return { message: `${colorize("Stopped:", "yellow")} ${targetName}` };
+  }
+  const allServers = ctx.registry.list();
+  for (const srv of allServers) {
+    ctx.registry.stop(srv.name);
+  }
+  return { message: `${colorize("Stopped", "yellow")} ${allServers.length} server(s): ${allServers.map((s) => s.name).join(", ")}` };
+}
+async function runRestartCommand(ctx, name) {
+  const targetName = name?.trim();
+  if (targetName) {
+    const srv = ctx.registry.list().find((s) => s.name === targetName);
+    if (!srv) {
+      return { message: `${colorize("Server not found:", "red")} ${targetName}` };
+    }
+    ctx.registry.stop(targetName);
+    try {
+      await ctx.registry.start(targetName);
+      return { message: `${colorize("Restarted:", "green")} ${targetName}` };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { message: `${colorize("Restart failed:", "red")} ${targetName}
+  ${msg}` };
+    }
+  }
+  const allServers = ctx.registry.list().filter((s) => s.config.enabled);
+  const restarted = [];
+  const failed = [];
+  for (const srv of allServers) {
+    ctx.registry.stop(srv.name);
+    try {
+      await ctx.registry.start(srv.name);
+      restarted.push(srv.name);
+    } catch {
+      failed.push(srv.name);
+    }
+  }
+  const lines = [];
+  if (restarted.length > 0) lines.push(`${colorize("Restarted:", "green")} ${restarted.join(", ")}`);
+  if (failed.length > 0) lines.push(`${colorize("Failed to restart:", "red")} ${failed.join(", ")}`);
+  return { message: lines.join("\n") };
+}
+async function runDiagnosticsCommand(ctx, file) {
+  const lines = [`${colorize("LSP Diagnostics", "bold")}`, "\u2500".repeat(60)];
+  const allDiags = collectServerDiagnostics(ctx.registry);
+  if (file) {
+    const resolved = path.resolve(ctx.cwd, file);
+    const fileDiags = allDiags.get(resolved);
+    if (!fileDiags || fileDiags.length === 0) {
+      return { message: lines.join("\n") + `
+No diagnostics for ${file}` };
+    }
+    lines.push(`File: ${resolved}`);
+    const diagMap = /* @__PURE__ */ new Map([[resolved, fileDiags]]);
+    lines.push(formatDiagnostics(diagMap, {
+      cwd: ctx.cwd,
+      severityFilter: ctx.cfg.severityFilter,
+      maxPerFile: ctx.cfg.maxDiagnosticsPerFile,
+      maxTotal: ctx.cfg.maxDiagnosticsTotal
+    }));
+    return { message: lines.join("\n") };
+  }
+  if (allDiags.size === 0) {
+    lines.push("No diagnostics reported by any LSP server.");
+    lines.push("");
+    lines.push("LSP diagnostics are reported by language servers after you open/edit files.");
+    lines.push("Open a file and run `/lsp diagnostics <file>` to check specific files.");
+    return { message: lines.join("\n") };
+  }
+  const total = Array.from(allDiags.values()).reduce((sum, d) => sum + d.length, 0);
+  lines.push(`Showing diagnostics for ${allDiags.size} file(s) (${total} total)`);
+  lines.push("");
+  for (const [fpath, diags] of allDiags) {
+    lines.push(`${colorize(fpath, "cyan")}`);
+    const fdiagMap = /* @__PURE__ */ new Map([[fpath, diags]]);
+    lines.push(formatDiagnostics(fdiagMap, {
+      cwd: ctx.cwd,
+      severityFilter: ctx.cfg.severityFilter,
+      maxPerFile: ctx.cfg.maxDiagnosticsPerFile,
+      maxTotal: ctx.cfg.maxDiagnosticsTotal
+    }));
+    lines.push("");
+  }
+  return { message: lines.join("\n") };
+}
+function collectServerDiagnostics(registry) {
+  const result = /* @__PURE__ */ new Map();
+  for (const srv of registry.list()) {
+    if (srv.state !== "ready") continue;
+    for (const [uri, diags] of srv.diagnostics) {
+      const filePath = uri.startsWith("file://") ? uri.slice(7) : uri;
+      const existing = result.get(filePath) ?? [];
+      result.set(filePath, [...existing, ...diags]);
+    }
+  }
+  return result;
+}
 
 // src/slash-commands/index.ts
-function registerSlashCommands(api, registry) {
+function registerSlashCommands(api, registry, tracker, cfg, cwd) {
+  const lspCommand = buildLspCommand({ registry, tracker, cfg, cwd });
   const commands = [
+    lspCommand,
     listCommand(registry),
     startCommand(registry),
     stopCommand(registry),
@@ -1223,79 +1867,47 @@ function registerSlashCommands(api, registry) {
   return commands.map((cmd) => cmd.name);
 }
 
-// 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.filter((e) => "newText" in e));
-    }
-  }
-  return out;
-}
+// src/constants.ts
+var LSP_CONSTANTS = Object.freeze({
+  /** Default timeout for LSP tool operations (5 seconds). */
+  TOOL_TIMEOUT_MS: 5e3
+});
 
-// 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;
+// src/formatters/symbols.ts
+function formatCodebaseLspResults(output, cwd) {
+  const { results, totalIndex, totalLsp, query, usedIndex, usedLsp } = output;
+  if (results.length === 0) {
+    const sources = [];
+    if (usedIndex) sources.push(`index(${totalIndex})`);
+    if (usedLsp) sources.push(`lsp(${totalLsp})`);
+    return `No symbols matching "${query}". Searched: ${sources.join(", ") || "none"}.`;
   }
-  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));
+  const lines = [];
+  lines.push(`${results.length} results for "${query}" (index:${totalIndex} lsp:${totalLsp}):`);
+  for (const r of results) {
+    const sourceTag = r.source === "index" ? "[index]" : `[lsp:${r.server ?? "?"}]`;
+    const scoreTag = r.score !== void 0 ? ` score=${r.score.toFixed(2)}` : "";
+    const location = `${displayPath(r.file, cwd)}:${r.line}`;
+    if (r.snippet) {
+      lines.push(`  ${sourceTag} ${r.kind} ${r.name} ${location}${scoreTag}`);
+      lines.push(`      ${r.snippet}`);
+    } else {
+      lines.push(`  ${sourceTag} ${r.kind} ${r.name} ${location}${scoreTag}`);
+    }
+  }
+  return lines.join("\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;
 }
@@ -1318,221 +1930,6 @@ function stringifyToolError(err) {
   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 = [];
-  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;
-}
-
-// 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)),
-              ...input.kind_filter ? { only: [input.kind_filter] } : {}
-            }
-          },
-          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/constants.ts
-var LSP_CONSTANTS = Object.freeze({
-  /** Default timeout for LSP tool operations (5 seconds). */
-  TOOL_TIMEOUT_MS: 5e3
-});
-
-// 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";
-}
-function formatCodebaseLspResults(output, cwd) {
-  const { results, totalIndex, totalLsp, query, usedIndex, usedLsp } = output;
-  if (results.length === 0) {
-    const sources = [];
-    if (usedIndex) sources.push(`index(${totalIndex})`);
-    if (usedLsp) sources.push(`lsp(${totalLsp})`);
-    return `No symbols matching "${query}". Searched: ${sources.join(", ") || "none"}.`;
-  }
-  const lines = [];
-  lines.push(`${results.length} results for "${query}" (index:${totalIndex} lsp:${totalLsp}):`);
-  for (const r of results) {
-    const sourceTag = r.source === "index" ? "[index]" : `[lsp:${r.server ?? "?"}]`;
-    const scoreTag = r.score !== void 0 ? ` score=${r.score.toFixed(2)}` : "";
-    const location = `${displayPath(r.file, cwd)}:${r.line}`;
-    if (r.snippet) {
-      lines.push(`  ${sourceTag} ${r.kind} ${r.name} ${location}${scoreTag}`);
-      lines.push(`      ${r.snippet}`);
-    } else {
-      lines.push(`  ${sourceTag} ${r.kind} ${r.name} ${location}${scoreTag}`);
-    }
-  }
-  return lines.join("\n");
-}
 
 // src/tools/codebase-lsp-search.ts
 function createCodebaseLspSearchTool(deps) {
@@ -1732,6 +2129,31 @@ function formatLocations(locations, cwd, limit = 100) {
   return lines.join("\n");
 }
 
+// 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/tools/definition.ts
 function createDefinitionTool(deps) {
   return {
@@ -1818,118 +2240,79 @@ function createDiagnosticsTool(deps) {
   };
 }
 
-// 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/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");
 }
-
-// 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: LSP_CONSTANTS.TOOL_TIMEOUT_MS,
-    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 },
-            LSP_CONSTANTS.TOOL_TIMEOUT_MS,
-            opts.signal
-          )
-        );
-      } catch (err) {
-        return stringifyToolError(err);
-      }
+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.filter((e) => "newText" in e));
     }
-  };
+  }
+  return out;
 }
-
-// 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) {
+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 {
-        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);
+        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;
 }
 
 // src/tools/rename.ts
@@ -1985,68 +2368,13 @@ Applied: ${applied.edits} edits across ${applied.files.length} files.`;
   };
 }
 
-// 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: LSP_CONSTANTS.TOOL_TIMEOUT_MS,
-    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) } },
-            LSP_CONSTANTS.TOOL_TIMEOUT_MS,
-            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 }, LSP_CONSTANTS.TOOL_TIMEOUT_MS, 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),
     createCodebaseLspSearchTool(deps),
-    createRenameTool(deps),
-    createCodeActionsTool(deps)
+    createRenameTool(deps)
   ];
 }
 
@@ -2076,7 +2404,7 @@ var plugin = {
     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 commandNames = registerSlashCommands(api, registry, tracker, cfg, cwd);
     const offs = [
       api.events.on("session.started", () => {
         const nextCwd = api.config.cwd ?? process.cwd();