@botconnector/bccli 0.4.2 → 0.4.3

package/dist/cli.js

@@ -3,36 +3,36 @@ import {
   resolvePrintPrompt,
   resolveWorktree,
   runPrint
-} from "./chunk-C64KM37J.js";
+} from "./chunk-WDX62DFH.js";
 import {
   createRuntime
-} from "./chunk-R72OV7RF.js";
+} from "./chunk-QNUJHKEL.js";
 import "./chunk-OK2USAXX.js";
-import "./chunk-ZEPTUKNW.js";
+import "./chunk-4W5SKQDC.js";
 import "./chunk-JXM6REER.js";
 import "./chunk-PSO7R5AD.js";
 import {
   VERSION
-} from "./chunk-266SY3MC.js";
+} from "./chunk-FUJGHCWN.js";
 import {
   helpText,
   parseCliArgs
 } from "./chunk-6UO5GX55.js";
 import "./chunk-WFZKJY3R.js";
-import "./chunk-H7XJDKJY.js";
-import "./chunk-IYR5PYA3.js";
+import "./chunk-GWVLPN4B.js";
+import "./chunk-7I2ZGPUS.js";
 import {
   readGlobalConfigFile
 } from "./chunk-HQW4BROS.js";
 import {
   defaultLoginDeps,
   runLogin
-} from "./chunk-TIMSYZIR.js";
+} from "./chunk-Z5NI5FIK.js";
 import "./chunk-3I5BW3ZT.js";
 import {
   pruneSessions
-} from "./chunk-SVD4LHJC.js";
-import "./chunk-5YJ3ZQVR.js";
+} from "./chunk-6AUROP2E.js";
+import "./chunk-XTOATEI6.js";
 import "./chunk-KPTML72Q.js";
 import "./chunk-6M55UPES.js";
 import {
@@ -86,12 +86,12 @@ async function main() {
   if (args.command === "login") return runLogin(args.loginProvider ?? "bc-cloud", cwd, args, defaultLoginDeps());
   if (args.command === "mcp") {
     const { runMcpCommand } = await import("./mcpCli-SETTCL3K.js");
-    const { readSecret } = await import("./login-RYESFZG6.js");
+    const { readSecret } = await import("./login-YXSSB2HQ.js");
     return runMcpCommand(args, { env: process.env, cwd, out: (s) => console.log(s), err: (s) => console.error(s), readSecret });
   }
   if (args.command === "provider") {
-    const { runProviderCommand } = await import("./providerCli-5OZI2GQQ.js");
-    const { readSecret } = await import("./login-RYESFZG6.js");
+    const { runProviderCommand } = await import("./providerCli-V2576JXE.js");
+    const { readSecret } = await import("./login-YXSSB2HQ.js");
     return runProviderCommand(args, { env: process.env, cwd, out: (s) => console.log(s), err: (s) => console.error(s), readSecret });
   }
   if (args.command === "connect" || args.command === "disconnect" || args.command === "integrations") {
@@ -105,20 +105,20 @@ async function main() {
     });
   }
   if (args.command === "models") {
-    const { runModelsCommand } = await import("./modelsCli-OP7CDZC7.js");
+    const { runModelsCommand } = await import("./modelsCli-656AKYZD.js");
     return runModelsCommand(args, { env: process.env, cwd, out: (s) => console.log(s), err: (s) => console.error(s), fetch: globalThis.fetch });
   }
   if (args.command === "update") {
-    const { runUpdateCommand } = await import("./update-FSS7X5WV.js");
+    const { runUpdateCommand } = await import("./update-AVZO4XID.js");
     return runUpdateCommand({ env: process.env });
   }
   if (args.command === "acp") {
-    const { runtimeAgent, runAcp } = await import("./acp-UYC6APR5.js");
+    const { runtimeAgent, runAcp } = await import("./acp-NU4HZHQO.js");
     await runAcp(process.stdin, process.stdout, { cwd, newAgent: (c) => runtimeAgent(c, args.allowAll) });
     return 0;
   }
   if (args.command === "serve") {
-    const { serveBanner, startServe } = await import("./serve-4J7HA4JO.js");
+    const { serveBanner, startServe } = await import("./serve-XPAGXIGS.js");
     const handle = await startServe({ port: args.port, host: args.host, token: args.token, cwd, env: process.env });
     process.stderr.write(serveBanner(handle, { token: args.token }));
     await new Promise((resolve) => {
@@ -146,7 +146,7 @@ async function main() {
     });
   }
   if (args.command === "gh-bot") {
-    const { runGhBotCommand } = await import("./ghBotCli-TSLRORJJ.js");
+    const { runGhBotCommand } = await import("./ghBotCli-GCIUUMKQ.js");
     return runGhBotCommand(args, { env: process.env, cwd, out: (s) => console.log(s), err: (s) => console.error(s) });
   }
   if (args.command === "completion") {
@@ -162,7 +162,7 @@ async function main() {
     );
   }
   if (args.command === "export" || args.command === "import") {
-    const { runExportCommand, runImportCommand } = await import("./transferCli-R2KEIWQR.js");
+    const { runExportCommand, runImportCommand } = await import("./transferCli-C6XS6QYH.js");
     const { bccliHome } = await import("./config-LAINORU5.js");
     const deps = { subArgs: args.subArgs, home: bccliHome(process.env), cwd };
     const io = { out: (s) => console.log(s), err: (s) => console.error(s) };
@@ -215,13 +215,13 @@ async function main() {
   let updateMessage;
   if (rt.config.updateCheck !== "off" && !process.env.BCCLI_NO_UPDATE_CHECK) {
     try {
-      const { checkForUpdate } = await import("./update-FSS7X5WV.js");
+      const { checkForUpdate } = await import("./update-AVZO4XID.js");
       const update = await checkForUpdate({ home: rt.home, fetch: globalThis.fetch, now: /* @__PURE__ */ new Date() });
       updateMessage = update;
     } catch {
     }
   }
-  const { startInteractive } = await import("./ui-36ZEK65V.js");
+  const { startInteractive } = await import("./ui-43C6Y57K.js");
   return startInteractive(rt, { initialPrompt: args.prompt, resume: args.resume, version: VERSION, updateMessage });
 }
 main().then(

package/dist/{ghBotCli-TSLRORJJ.js → ghBotCli-GCIUUMKQ.js}

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import {
   createRuntime
-} from "./chunk-R72OV7RF.js";
+} from "./chunk-QNUJHKEL.js";
 import "./chunk-OK2USAXX.js";
-import "./chunk-ZEPTUKNW.js";
+import "./chunk-4W5SKQDC.js";
 import "./chunk-JXM6REER.js";
 import "./chunk-PSO7R5AD.js";
 import {
@@ -11,12 +11,12 @@ import {
   parseCliArgs
 } from "./chunk-6UO5GX55.js";
 import "./chunk-WFZKJY3R.js";
-import "./chunk-H7XJDKJY.js";
-import "./chunk-IYR5PYA3.js";
+import "./chunk-GWVLPN4B.js";
+import "./chunk-7I2ZGPUS.js";
 import "./chunk-HQW4BROS.js";
 import "./chunk-3I5BW3ZT.js";
-import "./chunk-SVD4LHJC.js";
-import "./chunk-5YJ3ZQVR.js";
+import "./chunk-6AUROP2E.js";
+import "./chunk-XTOATEI6.js";
 import "./chunk-KPTML72Q.js";
 import "./chunk-6M55UPES.js";
 import {

package/dist/{login-RYESFZG6.js → login-YXSSB2HQ.js}

@@ -4,7 +4,7 @@ import {
   readLine,
   readSecret,
   runLogin
-} from "./chunk-TIMSYZIR.js";
+} from "./chunk-Z5NI5FIK.js";
 import "./chunk-3I5BW3ZT.js";
 import "./chunk-RX4UQX43.js";
 import "./chunk-3WHI4LN3.js";

package/dist/lsp.d.ts

@@ -11,6 +11,19 @@ export interface LspDiagnostic {
     severity: number;
     message: string;
 }
+export interface LspLocation {
+    uri: string;
+    path: string;
+    line: number;
+    character: number;
+}
+export interface WarmLspClient {
+    diagnostics(file: string, timeoutMs?: number): Promise<LspDiagnostic[]>;
+    hover(file: string, line: number, character: number, timeoutMs?: number): Promise<string>;
+    definition(file: string, line: number, character: number, timeoutMs?: number): Promise<LspLocation[]>;
+    references(file: string, line: number, character: number, timeoutMs?: number): Promise<LspLocation[]>;
+    close(): Promise<void>;
+}
 interface LspRawDiagnostic {
     range?: {
         start?: {
@@ -47,4 +60,14 @@ export declare function getDiagnostics(opts: {
     timeoutMs?: number;
     signal?: AbortSignal;
 }): Promise<LspDiagnostic[]>;
+/**
+ * Persistent warm LSP client: spawns the language server once, sends `didOpen` on first
+ * touch of a file and `didChange` on subsequent touches, and serves `diagnostics`,
+ * `hover`, `definition`, and `references` over the same warm process.
+ */
+export declare function createWarmLspClient(opts: {
+    server: LspServer;
+    cwd: string;
+    timeoutMs?: number;
+}): WarmLspClient;
 export {};

package/dist/{modelsCli-OP7CDZC7.js → modelsCli-656AKYZD.js}

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import {
   listAllModels
-} from "./chunk-IYR5PYA3.js";
+} from "./chunk-7I2ZGPUS.js";
 import "./chunk-HQW4BROS.js";
-import "./chunk-5YJ3ZQVR.js";
+import "./chunk-XTOATEI6.js";
 import "./chunk-KPTML72Q.js";
 import {
   loadConfig,

package/dist/{providerCli-5OZI2GQQ.js → providerCli-V2576JXE.js}

@@ -2,10 +2,10 @@
 import {
   addProviderKey,
   runProviderCommand
-} from "./chunk-H7XJDKJY.js";
-import "./chunk-IYR5PYA3.js";
+} from "./chunk-GWVLPN4B.js";
+import "./chunk-7I2ZGPUS.js";
 import "./chunk-HQW4BROS.js";
-import "./chunk-5YJ3ZQVR.js";
+import "./chunk-XTOATEI6.js";
 import "./chunk-KPTML72Q.js";
 import "./chunk-RX4UQX43.js";
 import "./chunk-3WHI4LN3.js";

package/dist/sdk.js

@@ -1829,7 +1829,7 @@ function createProvider(options) {
   const isBotConnectorCloud = /^https:\/\/api\.botconnector\.id\/v1\/?$/.test(baseURL) && apiKey?.startsWith("bc_live_");
   if (isBotConnectorCloud) {
     headers["x-botconnector-client"] = "bccli";
-    headers["x-botconnector-client-version"] = "0.4.2";
+    headers["x-botconnector-client-version"] = "0.4.3";
   }
   const useNativeResponses = isBotConnectorCloud && providerId === "bc-cloud" && model === "gpt-6-luna";
   const useResponsesWebSocket = useNativeResponses && Boolean(apiKey) && (fetchOverride === void 0 || responsesWebSocketFactory !== void 0);
@@ -1860,7 +1860,7 @@ function createProvider(options) {
         baseURL: baseURL.replace(/\/+$/, ""),
         defaultHeaders: {
           "x-botconnector-client": "bccli",
-          "x-botconnector-client-version": "0.4.2"
+          "x-botconnector-client-version": "0.4.3"
         }
       });
       lunaWs = responsesWebSocketFactory ? responsesWebSocketFactory(client) : new ResponsesWS(client, { reconnect: null });
@@ -2268,6 +2268,11 @@ import { join as join2 } from "path";
 import { z } from "zod";
 
 // src/tools/sandbox.ts
+function winPathToWsl(winPath) {
+  const normalized = winPath.replace(/\\/g, "/");
+  const m = /^([A-Za-z]):\/(.*)$/.exec(normalized);
+  return m ? `/mnt/${m[1].toLowerCase()}/${m[2]}` : normalized;
+}
 function darwinProfile(cwd, network) {
   const writable = [cwd, "/tmp", "/private/tmp", "/dev", "/var/folders"].map((p) => `(subpath "${p}")`).join(" ");
   return [
@@ -2311,6 +2316,33 @@ function sandboxArgv(command, opts) {
       command
     ];
   }
+  if (opts.platform === "win32" && (opts.wslBwrap || process.env.BCCLI_WIN32_WSL_SANDBOX === "1")) {
+    const wslCwd = winPathToWsl(opts.cwd);
+    return [
+      "wsl.exe",
+      "--",
+      "bwrap",
+      "--ro-bind",
+      "/",
+      "/",
+      "--dev-bind",
+      "/dev",
+      "/dev",
+      "--proc",
+      "/proc",
+      "--bind",
+      wslCwd,
+      wslCwd,
+      "--tmpfs",
+      "/tmp",
+      "--die-with-parent",
+      ...opts.network ? [] : ["--unshare-net"],
+      "--",
+      "/bin/bash",
+      "-c",
+      command
+    ];
+  }
   return void 0;
 }
 
@@ -5476,14 +5508,14 @@ function createRepoMapTool() {
 }
 
 // src/tools/diagnostics.ts
-import { extname as extname3 } from "path";
+import { extname as extname3, relative as relative3 } from "path";
 import { z as z17 } from "zod";
 
 // src/lsp.ts
 import { spawn as spawn4 } from "child_process";
 import { readFileSync as readFileSync12 } from "fs";
 import { extname as extname2 } from "path";
-import { pathToFileURL } from "url";
+import { fileURLToPath, pathToFileURL } from "url";
 var LANGUAGE_IDS = {
   ".ts": "typescript",
   ".tsx": "typescriptreact",
@@ -5551,86 +5583,253 @@ function createLspParser(onMessage) {
     }
   };
 }
-function getDiagnostics(opts) {
-  return new Promise((resolve5) => {
-    const child = spawn4(opts.server.command, opts.server.args ?? [], {
-      cwd: opts.cwd,
-      stdio: ["pipe", "pipe", "ignore"],
-      shell: useShellForLsp(opts.server.command)
+function extractHoverText(contents) {
+  if (!contents) return "";
+  if (typeof contents === "string") return contents.trim();
+  if (Array.isArray(contents)) return contents.map(extractHoverText).filter(Boolean).join("\n\n");
+  if (typeof contents === "object" && "value" in contents && typeof contents.value === "string") {
+    return contents.value.trim();
+  }
+  return "";
+}
+function normalizeLocations(raw) {
+  const items = Array.isArray(raw) ? raw : raw ? [raw] : [];
+  const out = [];
+  for (const item of items) {
+    if (!item || typeof item !== "object") continue;
+    const rec = item;
+    const uri = rec.uri ?? rec.targetUri;
+    const start = rec.range?.start ?? rec.targetSelectionRange?.start ?? rec.targetRange?.start;
+    if (!uri) continue;
+    let path = uri;
+    try {
+      if (uri.startsWith("file:")) path = fileURLToPath(uri);
+    } catch {
+    }
+    out.push({
+      uri,
+      path,
+      line: start?.line ?? 0,
+      character: start?.character ?? 0
     });
-    const uri = pathToFileURL(opts.file).href;
-    let settled = false;
-    let nextId = 2;
-    const send = (msg) => {
-      try {
-        child.stdin.write(encodeLsp(msg));
-      } catch {
-      }
-    };
-    const finish = (diags) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      opts.signal?.removeEventListener("abort", onAbort);
-      send({ jsonrpc: "2.0", id: nextId++, method: "shutdown" });
-      send({ jsonrpc: "2.0", method: "exit" });
-      const killer = setTimeout(() => {
-        try {
-          child.kill();
-        } catch {
+  }
+  return out;
+}
+function createWarmLspClient(opts) {
+  let child;
+  let initPromise;
+  let nextId = 2;
+  const opened = /* @__PURE__ */ new Map();
+  const pendingRpc = /* @__PURE__ */ new Map();
+  const diagWaiters = /* @__PURE__ */ new Map();
+  const send = (msg) => {
+    try {
+      child?.stdin?.write(encodeLsp(msg));
+    } catch {
+    }
+  };
+  const resetState = () => {
+    child = void 0;
+    initPromise = void 0;
+    opened.clear();
+    for (const [, resolve5] of pendingRpc) resolve5(void 0);
+    pendingRpc.clear();
+    for (const [, waiters] of diagWaiters) {
+      for (const w of waiters) w([]);
+    }
+    diagWaiters.clear();
+  };
+  const ensureStarted = () => {
+    if (initPromise && child && !child.killed) return initPromise;
+    opened.clear();
+    initPromise = new Promise((resolveInit) => {
+      const proc = spawn4(opts.server.command, opts.server.args ?? [], {
+        cwd: opts.cwd,
+        stdio: ["pipe", "pipe", "ignore"],
+        shell: useShellForLsp(opts.server.command)
+      });
+      child = proc;
+      let initSettled = false;
+      const settleInit = () => {
+        if (!initSettled) {
+          initSettled = true;
+          resolveInit();
         }
-      }, 500);
-      killer.unref?.();
-      resolve5(diags);
-    };
-    const onAbort = () => finish([]);
-    if (opts.signal?.aborted) return finish([]);
-    opts.signal?.addEventListener("abort", onAbort, { once: true });
-    const timer = setTimeout(() => finish([]), opts.timeoutMs ?? 8e3);
-    const parser = createLspParser((msg) => {
-      if (msg.id === 1 && msg.result) {
-        send({ jsonrpc: "2.0", method: "initialized", params: {} });
-        let text = "";
-        try {
-          text = readFileSync12(opts.file, "utf8");
-        } catch {
+      };
+      const parser = createLspParser((msg) => {
+        if (msg.id === 1 && msg.result !== void 0) {
+          send({ jsonrpc: "2.0", method: "initialized", params: {} });
+          settleInit();
+          return;
         }
-        send({
-          jsonrpc: "2.0",
-          method: "textDocument/didOpen",
-          params: { textDocument: { uri, languageId: languageIdFor(opts.file), version: 1, text } }
-        });
-      }
-      if (msg.method === "textDocument/publishDiagnostics" && msg.params?.uri === uri) {
-        finish(
-          (msg.params.diagnostics ?? []).map((d) => ({
+        if (msg.id !== void 0 && pendingRpc.has(msg.id)) {
+          const fn = pendingRpc.get(msg.id);
+          pendingRpc.delete(msg.id);
+          fn?.(msg.result);
+          return;
+        }
+        if (msg.method === "textDocument/publishDiagnostics" && msg.params?.uri) {
+          const uri = msg.params.uri;
+          const diags = (msg.params.diagnostics ?? []).map((d) => ({
             line: d.range?.start?.line ?? 0,
             character: d.range?.start?.character ?? 0,
             severity: d.severity ?? 1,
             message: String(d.message ?? "")
-          }))
-        );
-      }
+          }));
+          const list2 = diagWaiters.get(uri);
+          if (list2?.length) {
+            diagWaiters.delete(uri);
+            for (const w of list2) w(diags);
+          }
+        }
+      });
+      proc.stdout?.on("data", (c) => parser.push(c));
+      proc.on("error", () => {
+        resetState();
+        settleInit();
+      });
+      proc.on("close", () => {
+        resetState();
+        settleInit();
+      });
+      send({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: { processId: process.pid, capabilities: {}, rootUri: pathToFileURL(opts.cwd).href }
+      });
     });
-    child.stdout?.on("data", (c) => parser.push(c));
-    child.on("error", () => finish([]));
-    child.on("close", () => finish([]));
-    send({
-      jsonrpc: "2.0",
-      id: 1,
-      method: "initialize",
-      params: { processId: process.pid, capabilities: {}, rootUri: pathToFileURL(opts.cwd).href }
+    return initPromise;
+  };
+  const syncDocument = (file) => {
+    const uri = pathToFileURL(file).href;
+    let text = "";
+    try {
+      text = readFileSync12(file, "utf8");
+    } catch {
+    }
+    const prevVersion = opened.get(uri);
+    if (prevVersion === void 0) {
+      opened.set(uri, 1);
+      send({
+        jsonrpc: "2.0",
+        method: "textDocument/didOpen",
+        params: { textDocument: { uri, languageId: languageIdFor(file), version: 1, text } }
+      });
+    } else {
+      const version = prevVersion + 1;
+      opened.set(uri, version);
+      send({
+        jsonrpc: "2.0",
+        method: "textDocument/didChange",
+        params: {
+          textDocument: { uri, version },
+          contentChanges: [{ text }]
+        }
+      });
+    }
+    return uri;
+  };
+  const request = (method, params, timeoutMs = opts.timeoutMs ?? 8e3) => new Promise((resolve5) => {
+    const id = nextId++;
+    const timer = setTimeout(() => {
+      pendingRpc.delete(id);
+      resolve5(void 0);
+    }, timeoutMs);
+    pendingRpc.set(id, (res) => {
+      clearTimeout(timer);
+      resolve5(res);
     });
+    send({ jsonrpc: "2.0", id, method, params });
   });
+  return {
+    async diagnostics(file, timeoutMs = opts.timeoutMs ?? 8e3) {
+      await ensureStarted();
+      if (!child) return [];
+      const uri = pathToFileURL(file).href;
+      return new Promise((resolve5) => {
+        const timer = setTimeout(() => {
+          const list3 = diagWaiters.get(uri) ?? [];
+          diagWaiters.set(
+            uri,
+            list3.filter((w) => w !== onDiag)
+          );
+          resolve5([]);
+        }, timeoutMs);
+        const onDiag = (diags) => {
+          clearTimeout(timer);
+          resolve5(diags);
+        };
+        const list2 = diagWaiters.get(uri) ?? [];
+        list2.push(onDiag);
+        diagWaiters.set(uri, list2);
+        syncDocument(file);
+      });
+    },
+    async hover(file, line, character, timeoutMs) {
+      await ensureStarted();
+      if (!child) return "";
+      const uri = syncDocument(file);
+      const res = await request("textDocument/hover", { textDocument: { uri }, position: { line, character } }, timeoutMs);
+      return extractHoverText(res?.contents);
+    },
+    async definition(file, line, character, timeoutMs) {
+      await ensureStarted();
+      if (!child) return [];
+      const uri = syncDocument(file);
+      const res = await request("textDocument/definition", { textDocument: { uri }, position: { line, character } }, timeoutMs);
+      return normalizeLocations(res);
+    },
+    async references(file, line, character, timeoutMs) {
+      await ensureStarted();
+      if (!child) return [];
+      const uri = syncDocument(file);
+      const res = await request(
+        "textDocument/references",
+        { textDocument: { uri }, position: { line, character }, context: { includeDeclaration: true } },
+        timeoutMs
+      );
+      return normalizeLocations(res);
+    },
+    async close() {
+      if (!child) return;
+      const proc = child;
+      send({ jsonrpc: "2.0", id: nextId++, method: "shutdown" });
+      send({ jsonrpc: "2.0", method: "exit" });
+      resetState();
+      const killer = setTimeout(() => {
+        try {
+          proc.kill();
+        } catch {
+        }
+      }, 200);
+      killer.unref?.();
+    }
+  };
 }
 
 // src/tools/diagnostics.ts
 var SEVERITY = { 1: "error", 2: "warning", 3: "info", 4: "hint" };
-var SCHEMA = z17.object({ path: z17.string().describe("File to check (absolute or relative to the working directory)") });
+var SCHEMA = z17.object({
+  path: z17.string().describe("File to check (absolute or relative to the working directory)"),
+  action: z17.enum(["diagnostics", "hover", "definition", "references"]).optional().describe("LSP query action, default diagnostics"),
+  line: z17.number().int().min(1).optional().describe("1-based line number for hover, definition, or references"),
+  character: z17.number().int().min(1).optional().describe("1-based column number for hover, definition, or references")
+});
 function createDiagnosticsTool(servers) {
+  const warmPool = /* @__PURE__ */ new Map();
+  const clientFor = (server, cwd) => {
+    const key = `${cwd}::${server.command}::${(server.args ?? []).join("\0")}`;
+    let client = warmPool.get(key);
+    if (!client) {
+      client = createWarmLspClient({ server, cwd, timeoutMs: 15e3 });
+      warmPool.set(key, client);
+    }
+    return client;
+  };
   return defineTool({
     name: "diagnostics",
-    description: 'Run the configured LSP server(s) on one file and return its diagnostics (errors/warnings). Configure servers under "lsp.servers" in ~/.bccli/config.json, e.g. { "extensions": [".ts"], "command": "typescript-language-server", "args": ["--stdio"] }.',
+    description: 'Query the configured LSP server(s) on a file for diagnostics (errors/warnings), hover docs, definition, or references. Configure servers under "lsp.servers" in ~/.bccli/config.json, e.g. { "extensions": [".ts"], "command": "typescript-language-server", "args": ["--stdio"] }.',
     schema: SCHEMA,
     kind: "read",
     target: (input) => input.path,
@@ -5641,7 +5840,24 @@ function createDiagnosticsTool(servers) {
       if (!server) {
         return { output: t("No LSP server is configured for {ext} files.", { ext: ext || "(none)" }), isError: true };
       }
-      const diags = await getDiagnostics({ server, cwd: ctx.cwd, file, timeoutMs: 15e3 });
+      const client = clientFor(server, ctx.cwd);
+      const action = input.action ?? "diagnostics";
+      const line0 = Math.max(0, (input.line ?? 1) - 1);
+      const char0 = Math.max(0, (input.character ?? 1) - 1);
+      if (action === "hover") {
+        const text = await client.hover(file, line0, char0, 15e3);
+        return { output: text || "No hover information." };
+      }
+      if (action === "definition" || action === "references") {
+        const locs = action === "definition" ? await client.definition(file, line0, char0, 15e3) : await client.references(file, line0, char0, 15e3);
+        if (!locs.length) return { output: `No ${action} found.` };
+        const formatted = locs.map((l) => {
+          const rel = relative3(ctx.cwd, l.path).replace(/\\/g, "/") || input.path;
+          return `${rel}:${l.line + 1}:${l.character + 1}`;
+        });
+        return { output: formatted.join("\n") };
+      }
+      const diags = await client.diagnostics(file, 15e3);
       if (!diags.length) return { output: "No diagnostics." };
       const lines = diags.map((d) => `${input.path}:${d.line + 1}:${d.character + 1} ${SEVERITY[d.severity] ?? "error"} ${d.message}`);
       return { output: lines.join("\n"), isError: diags.some((d) => d.severity === 1) };