pybao-cli 1.3.21 → 1.3.24

package/dist/{chunk-WU4SXVFN.js → chunk-56EE3NJ2.js}

@@ -26,42 +26,42 @@ import {
   hasPermissionsToUseTool,
   hasReadPermission,
   query
-} from "./chunk-3NZTTP2W.js";
+} from "./chunk-V5WZJEVQ.js";
 import {
   FallbackToolUseRejectedMessage,
   MCPTool,
   getClients,
   getMCPTools
-} from "./chunk-Q27MKRQ5.js";
+} from "./chunk-AIJXHCQJ.js";
 import {
   queryLLM
-} from "./chunk-KAAPCK6R.js";
+} from "./chunk-OS3PRGER.js";
 import {
   generateAgentId
-} from "./chunk-PJ2UYD4Q.js";
+} from "./chunk-4AWVNHCM.js";
 import {
   getActiveAgents,
   getAgentByType,
   getAvailableAgentTypes
-} from "./chunk-6IQ6RNSC.js";
+} from "./chunk-AGMS7BAU.js";
 import {
   INTERRUPT_MESSAGE,
   createAssistantMessage,
   createUserMessage,
   getLastAssistantMessageId
-} from "./chunk-LCN6UMC2.js";
+} from "./chunk-FHCT4F4H.js";
 import {
   getModelManager
-} from "./chunk-IA565ACR.js";
+} from "./chunk-MBYDWUYD.js";
 import {
   getContext
-} from "./chunk-PWZPQLA5.js";
+} from "./chunk-DGQOYCQ4.js";
 import {
   getTheme
-} from "./chunk-X2LHX4TN.js";
+} from "./chunk-MNSPB7QF.js";
 import {
   debug
-} from "./chunk-LTUBDTY7.js";
+} from "./chunk-O6EAVDYJ.js";
 import {
   BunShell,
   getCwd,
@@ -70,11 +70,14 @@ import {
   logError,
   overwriteLog,
   readTaskOutput
-} from "./chunk-TBU6CIW7.js";
+} from "./chunk-X2JUNUGX.js";
 import {
   formatDuration,
   formatNumber
 } from "./chunk-OUXHGDLH.js";
+import {
+  __require
+} from "./chunk-I3J4JYES.js";
 
 // src/tools/index.ts
 import { memoize as memoize2 } from "lodash-es";
@@ -1021,17 +1024,19 @@ var ListMcpResourcesTool = {
 };
 
 // src/tools/search/LspTool/LspTool.tsx
-import { existsSync as existsSync2, readFileSync as readFileSync2, statSync } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
 import { Box as Box4, Text as Text4 } from "ink";
-import { createRequire } from "node:module";
-import { extname, join as join2, relative } from "path";
+import { extname as extname3 } from "path";
 import React4 from "react";
-import { pathToFileURL } from "url";
 import { z as z4 } from "zod";
 
 // src/tools/search/LspTool/prompt.ts
 var TOOL_NAME_FOR_PROMPT2 = "LSP";
 var PROMPT3 = `Interact with Language Server Protocol (LSP) servers to get code intelligence features.
+Supports 29+ languages including Python, Go, Rust, TypeScript, JavaScript, Bash, Java, C++, PHP, and more.
+
+STRATEGY: Use this tool as an "Analyst" to *understand* code structure and relationships (symbols, definitions, calls) within already located files.
+Do NOT use this tool to search for text strings across the whole project; use the Grep tool ("Scout") for that purpose first.
 
 Supported operations:
 - goToDefinition: Find where a symbol is defined
@@ -1049,54 +1054,14 @@ All operations require:
 - line: The line number (1-based, as shown in editors)
 - character: The character offset (1-based, as shown in editors)
 
-Note: LSP servers must be configured for the file type. If no server is available, an error will be returned.`;
+Note: LSP servers are automatically managed and installed for most languages. For system-level languages (like C++, Java), ensure the corresponding tools (clangd, jdtls) are in your PATH.`;
 var DESCRIPTION3 = PROMPT3;
 
-// src/tools/search/LspTool/LspTool.tsx
-var inputSchema4 = z4.strictObject({
-  operation: z4.enum([
-    "goToDefinition",
-    "findReferences",
-    "hover",
-    "documentSymbol",
-    "workspaceSymbol",
-    "goToImplementation",
-    "prepareCallHierarchy",
-    "incomingCalls",
-    "outgoingCalls"
-  ]).describe("The LSP operation to perform"),
-  filePath: z4.string().describe("The absolute or relative path to the file"),
-  line: z4.number().int().positive().describe("The line number (1-based, as shown in editors)"),
-  character: z4.number().int().positive().describe("The character offset (1-based, as shown in editors)")
-});
-var outputSchema = z4.object({
-  operation: z4.enum([
-    "goToDefinition",
-    "findReferences",
-    "hover",
-    "documentSymbol",
-    "workspaceSymbol",
-    "goToImplementation",
-    "prepareCallHierarchy",
-    "incomingCalls",
-    "outgoingCalls"
-  ]).describe("The LSP operation that was performed"),
-  result: z4.string().describe("The formatted result of the LSP operation"),
-  filePath: z4.string().describe("The file path the operation was performed on"),
-  resultCount: z4.number().int().nonnegative().optional().describe("Number of results (definitions, references, symbols)"),
-  fileCount: z4.number().int().nonnegative().optional().describe("Number of files containing results")
-});
-var OPERATION_LABELS = {
-  goToDefinition: { singular: "definition", plural: "definitions" },
-  findReferences: { singular: "reference", plural: "references" },
-  documentSymbol: { singular: "symbol", plural: "symbols" },
-  workspaceSymbol: { singular: "symbol", plural: "symbols" },
-  hover: { singular: "hover info", plural: "hover info", special: "available" },
-  goToImplementation: { singular: "implementation", plural: "implementations" },
-  prepareCallHierarchy: { singular: "call item", plural: "call items" },
-  incomingCalls: { singular: "caller", plural: "callers" },
-  outgoingCalls: { singular: "callee", plural: "callees" }
-};
+// src/tools/search/LspTool/TypeScriptBackend.ts
+import { statSync } from "fs";
+import { createRequire } from "node:module";
+import { extname, join as join2, relative } from "path";
+import { pathToFileURL } from "url";
 function extractSymbolAtPosition(lines, zeroBasedLine, zeroBasedCharacter) {
   try {
     if (zeroBasedLine < 0 || zeroBasedLine >= lines.length) return null;
@@ -1334,10 +1299,1068 @@ function getOrCreateTsProject(projectCwd) {
   projectCache.set(projectCwd, state);
   return state;
 }
-function isFileTypeSupportedByTypescriptBackend(filePath) {
-  const ext = extname(filePath).toLowerCase();
-  return ext === ".ts" || ext === ".tsx" || ext === ".js" || ext === ".jsx" || ext === ".mts" || ext === ".cts" || ext === ".mjs" || ext === ".cjs";
+var TypeScriptBackend = {
+  tryLoadTypeScriptModule,
+  isFileTypeSupported(filePath) {
+    const ext = extname(filePath).toLowerCase();
+    return ext === ".ts" || ext === ".tsx" || ext === ".js" || ext === ".jsx" || ext === ".mts" || ext === ".cts" || ext === ".mjs" || ext === ".cjs";
+  },
+  extractSymbolAtPosition,
+  toProjectRelativeIfPossible,
+  runOperation(operation, absPath, line, character) {
+    const project = getOrCreateTsProject(getCwd());
+    if (!project) {
+      return {
+        formatted: "LSP server manager not initialized. This may indicate a startup issue.",
+        resultCount: 0,
+        fileCount: 0
+      };
+    }
+    project.rootFiles.add(absPath);
+    const ts = project.ts;
+    const service = project.languageService;
+    const program = service.getProgram?.();
+    if (!program) {
+      throw new Error("TypeScript program not available");
+    }
+    const sourceFile = program.getSourceFile(absPath);
+    if (!sourceFile) {
+      throw new Error("File is not part of the TypeScript program");
+    }
+    const pos = ts.getPositionOfLineAndCharacter(
+      sourceFile,
+      line - 1,
+      character - 1
+    );
+    switch (operation) {
+      case "goToDefinition": {
+        const defs = service.getDefinitionAtPosition?.(absPath, pos) ?? [];
+        const locations = defs.map((d) => {
+          const defSourceFile = program.getSourceFile(d.fileName);
+          if (!defSourceFile) return null;
+          const lc = ts.getLineAndCharacterOfPosition(
+            defSourceFile,
+            d.textSpan.start
+          );
+          return {
+            fileName: d.fileName,
+            line0: lc.line,
+            character0: lc.character
+          };
+        }).filter(Boolean);
+        return formatGoToDefinitionResult(locations);
+      }
+      case "goToImplementation": {
+        const impls = service.getImplementationAtPosition?.(absPath, pos) ?? [];
+        const locations = impls.map((d) => {
+          const defSourceFile = program.getSourceFile(d.fileName);
+          if (!defSourceFile) return null;
+          const lc = ts.getLineAndCharacterOfPosition(
+            defSourceFile,
+            d.textSpan.start
+          );
+          return {
+            fileName: d.fileName,
+            line0: lc.line,
+            character0: lc.character
+          };
+        }).filter(Boolean);
+        return formatGoToDefinitionResult(locations);
+      }
+      case "findReferences": {
+        const referencedSymbols = service.findReferences?.(absPath, pos) ?? [];
+        const refs = [];
+        for (const sym of referencedSymbols) {
+          for (const ref of sym.references ?? []) {
+            const refSource = program.getSourceFile(ref.fileName);
+            if (!refSource) continue;
+            const lc = ts.getLineAndCharacterOfPosition(
+              refSource,
+              ref.textSpan.start
+            );
+            refs.push({
+              fileName: ref.fileName,
+              line0: lc.line,
+              character0: lc.character
+            });
+          }
+        }
+        return formatFindReferencesResult(refs);
+      }
+      case "hover": {
+        const info = service.getQuickInfoAtPosition?.(absPath, pos);
+        let text = null;
+        let hoverLine0 = line - 1;
+        let hoverCharacter0 = character - 1;
+        if (info) {
+          const parts = [];
+          const signature = ts.displayPartsToString(info.displayParts ?? []);
+          if (signature) parts.push(signature);
+          const doc = ts.displayPartsToString(info.documentation ?? []);
+          if (doc) parts.push(doc);
+          if (info.tags && info.tags.length > 0) {
+            for (const tag of info.tags) {
+              const tagText = ts.displayPartsToString(tag.text ?? []);
+              parts.push(`@${tag.name}${tagText ? ` ${tagText}` : ""}`);
+            }
+          }
+          text = parts.filter(Boolean).join("\n\n");
+          const lc = ts.getLineAndCharacterOfPosition(
+            sourceFile,
+            info.textSpan.start
+          );
+          hoverLine0 = lc.line;
+          hoverCharacter0 = lc.character;
+        }
+        return formatHoverResult(text, hoverLine0, hoverCharacter0);
+      }
+      case "documentSymbol": {
+        const tree = service.getNavigationTree?.(absPath);
+        const lines = [];
+        let count = 0;
+        const kindLabel = (kind) => {
+          const m = {
+            class: "Class",
+            interface: "Interface",
+            enum: "Enum",
+            function: "Function",
+            method: "Method",
+            property: "Property",
+            var: "Variable",
+            let: "Variable",
+            const: "Constant",
+            module: "Module",
+            alias: "Alias",
+            type: "Type"
+          };
+          return m[kind] ?? (kind ? kind[0].toUpperCase() + kind.slice(1) : "Unknown");
+        };
+        const walk = (node, depth) => {
+          const children = node?.childItems ?? [];
+          for (const child of children) {
+            const span = child.spans?.[0];
+            if (!span) continue;
+            const lc = ts.getLineAndCharacterOfPosition(
+              sourceFile,
+              span.start
+            );
+            const indent = "  ".repeat(depth);
+            const label = kindLabel(child.kind);
+            const detail = child.kindModifiers ? ` ${child.kindModifiers}` : "";
+            lines.push(
+              `${indent}${child.text} (${label})${detail} - Line ${lc.line + 1}`
+            );
+            count += 1;
+            if (child.childItems && child.childItems.length > 0) {
+              walk(child, depth + 1);
+            }
+          }
+        };
+        walk(tree, 0);
+        return formatDocumentSymbolsResult(lines, count);
+      }
+      case "workspaceSymbol": {
+        const items = service.getNavigateToItems?.("", 100, void 0, true, true) ?? [];
+        if (!items || items.length === 0) {
+          return {
+            formatted: "No symbols found in workspace. This may occur if the workspace is empty, or if the LSP server has not finished indexing the project.",
+            resultCount: 0,
+            fileCount: 0
+          };
+        }
+        const lines = [
+          `Found ${items.length} symbol${items.length === 1 ? "" : "s"} in workspace:`
+        ];
+        const grouped = groupLocationsByFile(
+          items.map((it) => ({
+            fileName: it.fileName,
+            item: it
+          }))
+        );
+        for (const [file, itemsInFile] of grouped) {
+          lines.push(`
+${file}:`);
+          for (const wrapper of itemsInFile) {
+            const it = wrapper.item;
+            const sf = program.getSourceFile(it.fileName);
+            if (!sf) continue;
+            const span = it.textSpan;
+            const lc = span ? ts.getLineAndCharacterOfPosition(sf, span.start) : { line: 0, character: 0 };
+            const label = it.kind ? String(it.kind)[0].toUpperCase() + String(it.kind).slice(1) : "Symbol";
+            let lineStr = `  ${it.name} (${label}) - Line ${lc.line + 1}`;
+            if (it.containerName) lineStr += ` in ${it.containerName}`;
+            lines.push(lineStr);
+          }
+        }
+        return {
+          formatted: lines.join("\n"),
+          resultCount: items.length,
+          fileCount: grouped.size
+        };
+      }
+      case "prepareCallHierarchy":
+      case "incomingCalls":
+      case "outgoingCalls": {
+        return {
+          formatted: `Error performing ${operation}: Call hierarchy is not supported by the TypeScript backend`,
+          resultCount: 0,
+          fileCount: 0
+        };
+      }
+      default: {
+        return {
+          formatted: `Error performing ${operation}: Unsupported operation`,
+          resultCount: 0,
+          fileCount: 0
+        };
+      }
+    }
+  }
+};
+
+// src/tools/search/LspTool/client/generic.ts
+import { createMessageConnection, StreamMessageReader, StreamMessageWriter } from "vscode-jsonrpc/node";
+import { spawn } from "child_process";
+import { pathToFileURL as pathToFileURL2 } from "url";
+var GenericLspClient = class {
+  constructor(serverCommand, serverArgs, cwd, rootPath) {
+    this.rootPath = rootPath;
+    const env = {
+      ...process.env,
+      // Remove potentially conflicting variables
+      NODE_OPTIONS: void 0,
+      TS_NODE_PROJECT: void 0,
+      ELECTRON_RUN_AS_NODE: void 0
+    };
+    const options = {
+      cwd,
+      stdio: "pipe",
+      env,
+      shell: false
+    };
+    this.process = spawn(serverCommand, serverArgs, options);
+    this.process.stderr.on("data", (data) => {
+      console.error(`[LSP Stderr] ${data}`);
+    });
+    this.connection = createMessageConnection(
+      new StreamMessageReader(this.process.stdout),
+      new StreamMessageWriter(this.process.stdin)
+    );
+    this.connection.onNotification((method, params) => {
+      if (method === "window/logMessage" || method === "$/progress") {
+        console.log(`[LSP Notification] ${method}:`, JSON.stringify(params));
+      }
+    });
+    this.connection.onRequest((method, params) => {
+      if (method === "workspace/configuration") {
+        return Array.isArray(params.items) ? params.items.map(() => ({})) : [];
+      }
+      if (method === "client/registerCapability") {
+        return null;
+      }
+      return null;
+    });
+    this.connection.listen();
+  }
+  connection;
+  process;
+  capabilities;
+  normalizeUri(filePath) {
+    let uri = pathToFileURL2(filePath).href;
+    if (process.platform === "win32") {
+      uri = uri.replace(/^file:\/\/\/([a-zA-Z]):\//, (match, drive) => {
+        return `file:///${drive.toLowerCase()}%3A/`;
+      });
+    }
+    return uri;
+  }
+  async initialize() {
+    const rootUri = this.normalizeUri(this.rootPath);
+    console.log("[GenericLspClient] Initializing with normalized rootUri:", rootUri);
+    const params = {
+      processId: process.pid,
+      rootUri,
+      capabilities: {
+        textDocument: {
+          synchronization: {
+            didOpen: true,
+            didChange: true,
+            willSave: false,
+            willSaveWaitUntil: false,
+            didSave: true
+          },
+          hover: {
+            contentFormat: ["markdown", "plaintext"]
+          },
+          definition: {},
+          references: {}
+        },
+        workspace: {
+          workspaceFolders: true
+        }
+      },
+      workspaceFolders: [
+        {
+          name: "workspace",
+          uri: this.normalizeUri(this.rootPath)
+        }
+      ]
+    };
+    const result = await this.connection.sendRequest("initialize", params);
+    await this.connection.sendNotification("initialized", {});
+    await this.connection.sendNotification("workspace/didChangeConfiguration", { settings: {} });
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    this.capabilities = result.capabilities;
+    return result;
+  }
+  async shutdown() {
+    try {
+      await this.connection.sendRequest("shutdown");
+      await this.connection.sendNotification("exit");
+    } catch (error) {
+    }
+    this.connection.dispose();
+    this.process.kill();
+  }
+  async goToDefinition(filePath, line, character) {
+    const params = {
+      textDocument: { uri: this.normalizeUri(filePath) },
+      position: { line: line - 1, character: character - 1 }
+    };
+    return this.connection.sendRequest("textDocument/definition", params);
+  }
+  async findReferences(filePath, line, character) {
+    const params = {
+      textDocument: { uri: this.normalizeUri(filePath) },
+      position: { line: line - 1, character: character - 1 },
+      context: { includeDeclaration: true }
+    };
+    return this.connection.sendRequest("textDocument/references", params);
+  }
+  async hover(filePath, line, character) {
+    const params = {
+      textDocument: { uri: this.normalizeUri(filePath) },
+      position: { line: line - 1, character: character - 1 }
+    };
+    return this.connection.sendRequest("textDocument/hover", params);
+  }
+  async documentSymbol(filePath) {
+    const params = {
+      textDocument: { uri: this.normalizeUri(filePath) }
+    };
+    return this.connection.sendRequest("textDocument/documentSymbol", params);
+  }
+  async workspaceSymbol(query2) {
+    const params = {
+      query: query2
+    };
+    return this.connection.sendRequest("workspace/symbol", params);
+  }
+  async goToImplementation(filePath, line, character) {
+    const params = {
+      textDocument: { uri: this.normalizeUri(filePath) },
+      position: { line: line - 1, character: character - 1 }
+    };
+    return this.connection.sendRequest("textDocument/implementation", params);
+  }
+  async didOpen(filePath, content, languageId) {
+    const params = {
+      textDocument: {
+        uri: this.normalizeUri(filePath),
+        languageId,
+        version: 1,
+        text: content
+      }
+    };
+    await this.connection.sendNotification("textDocument/didOpen", params);
+  }
+  async didChange(filePath, content, version) {
+    const params = {
+      textDocument: {
+        uri: this.normalizeUri(filePath),
+        version
+      },
+      contentChanges: [{ text: content }]
+    };
+    await this.connection.sendNotification("textDocument/didChange", params);
+  }
+};
+
+// src/tools/search/LspTool/client/manager.ts
+import { extname as extname2 } from "path";
+
+// src/tools/search/LspTool/registry.ts
+import { join as join3, dirname } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { spawnSync } from "child_process";
+var BaseLspServer = class {
+  isInPath(cmd) {
+    try {
+      const where = process.platform === "win32" ? "where" : "which";
+      const result = spawnSync(where, [cmd], { encoding: "utf8" });
+      return result.status === 0;
+    } catch {
+      return false;
+    }
+  }
+  getLocalBinPath(binName) {
+    const ext = process.platform === "win32" ? ".cmd" : "";
+    const localNodeModulesBin = join3(process.cwd(), "node_modules", ".bin");
+    let localBinPath = join3(localNodeModulesBin, `${binName}${ext}`);
+    if (existsSync3(localBinPath)) {
+      return localBinPath;
+    }
+    try {
+      let pkgName = binName;
+      if (binName === "pyright-langserver") pkgName = "pyright";
+      if (binName === "intelephense") pkgName = "intelephense";
+      if (binName === "docker-langserver") pkgName = "dockerfile-language-server-nodejs";
+      if (binName === "vscode-html-language-server") pkgName = "vscode-langservers-extracted";
+      if (binName === "vscode-css-language-server") pkgName = "vscode-langservers-extracted";
+      if (binName === "vscode-json-language-server") pkgName = "vscode-langservers-extracted";
+      const pkgEntry = __require.resolve(pkgName, { paths: [process.cwd()] });
+      let current = pkgEntry;
+      let pkgRoot = "";
+      for (let i = 0; i < 5; i++) {
+        current = join3(current, "..");
+        if (existsSync3(join3(current, "package.json"))) {
+          pkgRoot = current;
+          break;
+        }
+      }
+      if (pkgRoot) {
+        const nodeModulesRoot = join3(pkgRoot, "..");
+        const potentialBin = join3(nodeModulesRoot, ".bin", `${binName}${ext}`);
+        if (existsSync3(potentialBin)) {
+          return potentialBin;
+        }
+      }
+    } catch (e) {
+    }
+    return "";
+  }
+};
+var GenericNpmServer = class extends BaseLspServer {
+  id;
+  extensions;
+  rootMarkers;
+  npmPackage;
+  binName;
+  args;
+  constructor(id, extensions, rootMarkers, npmPackage, binName, args) {
+    super();
+    this.id = id;
+    this.extensions = extensions;
+    this.rootMarkers = rootMarkers;
+    this.npmPackage = npmPackage;
+    this.binName = binName;
+    this.args = args;
+  }
+  async prepare() {
+    if (this.isInPath(this.binName)) {
+      return true;
+    }
+    const localBin = this.getLocalBinPath(this.binName);
+    if (existsSync3(localBin)) {
+      return true;
+    }
+    return false;
+  }
+  async getCommand(rootPath) {
+    if (process.platform === "win32") {
+      try {
+        const pkgJsonPath = __require.resolve(`${this.npmPackage}/package.json`, { paths: [process.cwd()] });
+        const pkgJson = __require(pkgJsonPath);
+        let binScript = "";
+        if (typeof pkgJson.bin === "string") {
+          binScript = pkgJson.bin;
+        } else if (typeof pkgJson.bin === "object" && pkgJson.bin[this.binName]) {
+          binScript = pkgJson.bin[this.binName];
+        }
+        if (binScript) {
+          if (this.npmPackage === "pyright" && binScript.endsWith("langserver.index.js")) {
+            const distScript = join3(dirname(pkgJsonPath), "dist", "pyright-langserver.js");
+            if (existsSync3(distScript)) {
+              return { command: process.execPath, args: [distScript, ...this.args] };
+            }
+          }
+          const scriptPath = join3(dirname(pkgJsonPath), binScript);
+          if (existsSync3(scriptPath)) {
+            return { command: process.execPath, args: [scriptPath, ...this.args] };
+          }
+        }
+      } catch (e) {
+      }
+    }
+    if (this.isInPath(this.binName)) {
+      return { command: this.binName, args: this.args };
+    }
+    const localBin = this.getLocalBinPath(this.binName);
+    if (existsSync3(localBin)) {
+      return { command: localBin, args: this.args };
+    }
+    return null;
+  }
+};
+var GenericBinaryServer = class extends BaseLspServer {
+  id;
+  extensions;
+  rootMarkers;
+  binNames;
+  args;
+  constructor(id, extensions, rootMarkers, binNames, args) {
+    super();
+    this.id = id;
+    this.extensions = extensions;
+    this.rootMarkers = rootMarkers;
+    this.binNames = Array.isArray(binNames) ? binNames : [binNames];
+    this.args = args;
+  }
+  async prepare() {
+    return this.binNames.some((bin) => this.isInPath(bin));
+  }
+  async getCommand(rootPath) {
+    for (const bin of this.binNames) {
+      if (this.isInPath(bin)) {
+        return { command: bin, args: this.args };
+      }
+    }
+    return null;
+  }
+};
+var GoplsServer = class extends BaseLspServer {
+  id = "gopls";
+  extensions = [".go", ".mod"];
+  rootMarkers = ["go.mod", "go.work", ".git"];
+  async prepare() {
+    if (this.isInPath("gopls")) {
+      return true;
+    }
+    if (!this.isInPath("go")) {
+      debug.error("LSP_MISSING_DEP", { server: this.id, error: "go command not found" });
+      return false;
+    }
+    return this.installGo();
+  }
+  async getCommand(rootPath) {
+    if (this.isInPath("gopls")) {
+      return { command: "gopls", args: ["serve"] };
+    }
+    return null;
+  }
+  async installGo() {
+    try {
+      debug.info("LSP_INSTALL", { server: this.id, action: "start" });
+      const result = spawnSync("go", ["install", "golang.org/x/tools/gopls@latest"], {
+        encoding: "utf8"
+      });
+      if (result.status !== 0) {
+        debug.error("LSP_INSTALL_FAILED", { server: this.id, error: result.stderr });
+        return false;
+      }
+      if (!this.isInPath("gopls")) {
+        debug.warn("LSP_INSTALL_WARNING", { server: this.id, message: "gopls installed but not found in PATH. Make sure $(go env GOPATH)/bin is in your PATH." });
+      }
+      debug.info("LSP_INSTALL", { server: this.id, action: "success" });
+      return true;
+    } catch (e) {
+      debug.error("LSP_INSTALL_ERROR", { server: this.id, error: String(e) });
+      return false;
+    }
+  }
+};
+var RustAnalyzerServer = class extends BaseLspServer {
+  id = "rust-analyzer";
+  extensions = [".rs"];
+  rootMarkers = ["Cargo.toml", "rust-project.json", ".git"];
+  async prepare() {
+    if (this.isInPath("rust-analyzer")) {
+      return true;
+    }
+    if (this.isInPath("rustup")) {
+      return this.installRustup();
+    }
+    debug.warn("LSP_MISSING_DEP", { server: this.id, message: "rust-analyzer not found and rustup not available. Please install rust-analyzer manually." });
+    return false;
+  }
+  async getCommand(rootPath) {
+    if (this.isInPath("rust-analyzer")) {
+      return { command: "rust-analyzer", args: [] };
+    }
+    return null;
+  }
+  async installRustup() {
+    try {
+      debug.info("LSP_INSTALL", { server: this.id, action: "start" });
+      const result = spawnSync("rustup", ["component", "add", "rust-analyzer"], {
+        encoding: "utf8"
+      });
+      if (result.status !== 0) {
+        debug.error("LSP_INSTALL_FAILED", { server: this.id, error: result.stderr });
+        return false;
+      }
+      debug.info("LSP_INSTALL", { server: this.id, action: "success" });
+      return true;
+    } catch (e) {
+      debug.error("LSP_INSTALL_ERROR", { server: this.id, error: String(e) });
+      return false;
+    }
+  }
+};
+var LspServerRegistry = class _LspServerRegistry {
+  static instance;
+  servers = [];
+  constructor() {
+    this.register(new GenericNpmServer(
+      "pyright",
+      [".py", ".pyi"],
+      ["pyrightconfig.json", "pyproject.toml", "setup.py", "requirements.txt", "Pipfile"],
+      "pyright",
+      "pyright-langserver",
+      ["--stdio"]
+    ));
+    this.register(new GoplsServer());
+    this.register(new RustAnalyzerServer());
+    this.register(new GenericNpmServer(
+      "bash-language-server",
+      [".sh", ".bash", ".zsh"],
+      [".git"],
+      "bash-language-server",
+      "bash-language-server",
+      ["start"]
+    ));
+    this.register(new GenericNpmServer(
+      "yaml-language-server",
+      [".yaml", ".yml"],
+      [],
+      "yaml-language-server",
+      "yaml-language-server",
+      ["--stdio"]
+    ));
+    this.register(new GenericNpmServer(
+      "dockerfile-language-server",
+      ["Dockerfile", ".dockerfile"],
+      [],
+      "dockerfile-language-server-nodejs",
+      "docker-langserver",
+      ["--stdio"]
+    ));
+    this.register(new GenericNpmServer(
+      "vue-language-server",
+      [".vue"],
+      ["package.json"],
+      "@vue/language-server",
+      "vue-language-server",
+      ["--stdio"]
+    ));
+    this.register(new GenericNpmServer(
+      "html-language-server",
+      [".html", ".htm"],
+      [],
+      "vscode-langservers-extracted",
+      "vscode-html-language-server",
+      ["--stdio"]
+    ));
+    this.register(new GenericNpmServer(
+      "css-language-server",
+      [".css", ".scss", ".less"],
+      [],
+      "vscode-langservers-extracted",
+      "vscode-css-language-server",
+      ["--stdio"]
+    ));
+    this.register(new GenericNpmServer(
+      "json-language-server",
+      [".json", ".jsonc"],
+      [],
+      "vscode-langservers-extracted",
+      "vscode-json-language-server",
+      ["--stdio"]
+    ));
+    this.register(new GenericNpmServer(
+      "intelephense",
+      [".php"],
+      ["composer.json"],
+      "intelephense",
+      "intelephense",
+      ["--stdio"]
+    ));
+    this.register(new GenericNpmServer(
+      "svelte-language-server",
+      [".svelte"],
+      ["package.json"],
+      "svelte-language-server",
+      "svelte-language-server",
+      ["--stdio"]
+    ));
+    this.register(new GenericNpmServer(
+      "astro-ls",
+      [".astro"],
+      ["package.json"],
+      "@astrojs/language-server",
+      "astro-ls",
+      ["--stdio"]
+    ));
+    this.register(new GenericNpmServer(
+      "prisma-language-server",
+      [".prisma"],
+      ["schema.prisma"],
+      "@prisma/language-server",
+      "prisma-language-server",
+      ["--stdio"]
+    ));
+    this.register(new GenericNpmServer(
+      "graphql-lsp",
+      [".graphql", ".gql"],
+      [".graphqlrc", "graphql.config.js"],
+      "graphql-language-service-cli",
+      "graphql-lsp",
+      ["server", "-m", "stream"]
+    ));
+    this.register(new GenericBinaryServer(
+      "jdtls",
+      [".java"],
+      ["pom.xml", "build.gradle"],
+      "jdtls",
+      []
+    ));
+    this.register(new GenericBinaryServer(
+      "clangd",
+      [".c", ".cpp", ".h", ".hpp", ".cc"],
+      ["compile_commands.json", ".clang-format"],
+      "clangd",
+      ["--stdio"]
+    ));
+    this.register(new GenericBinaryServer(
+      "ruby-lsp",
+      [".rb", ".rake"],
+      ["Gemfile", ".ruby-version"],
+      "ruby-lsp",
+      ["--stdio"]
+    ));
+    this.register(new GenericBinaryServer(
+      "lua-language-server",
+      [".lua"],
+      [".luarc.json"],
+      ["lua-ls", "lua-language-server"],
+      []
+    ));
+    this.register(new GenericBinaryServer(
+      "terraform-ls",
+      [".tf", ".tfvars"],
+      [],
+      "terraform-ls",
+      ["serve"]
+    ));
+    this.register(new GenericBinaryServer(
+      "kotlin-language-server",
+      [".kt", ".kts"],
+      ["build.gradle.kts"],
+      ["kotlin-ls", "kotlin-language-server"],
+      []
+    ));
+    this.register(new GenericBinaryServer(
+      "elixir-ls",
+      [".ex", ".exs"],
+      ["mix.exs"],
+      ["elixir-ls", "language_server.sh"],
+      []
+    ));
+    this.register(new GenericBinaryServer(
+      "zls",
+      [".zig"],
+      ["build.zig"],
+      "zls",
+      []
+    ));
+    this.register(new GenericBinaryServer(
+      "csharp-ls",
+      [".cs"],
+      [".csproj", ".sln"],
+      "csharp-ls",
+      []
+    ));
+    this.register(new GenericBinaryServer(
+      "fsautocomplete",
+      [".fs", ".fsi", ".fsx"],
+      [".fsproj", ".sln"],
+      "fsautocomplete",
+      ["--background-service-enabled"]
+    ));
+    this.register(new GenericBinaryServer(
+      "sourcekit-lsp",
+      [".swift"],
+      ["Package.swift"],
+      "sourcekit-lsp",
+      []
+    ));
+    this.register(new GenericBinaryServer(
+      "dart",
+      [".dart"],
+      ["pubspec.yaml"],
+      "dart",
+      ["language-server"]
+    ));
+    this.register(new GenericBinaryServer(
+      "ocamllsp",
+      [".ml", ".mli"],
+      ["dune-project"],
+      ["ocaml-lsp", "ocamllsp"],
+      []
+    ));
+    this.register(new GenericBinaryServer(
+      "gleam",
+      [".gleam"],
+      ["gleam.toml"],
+      "gleam",
+      ["lsp"]
+    ));
+    this.register(new GenericBinaryServer(
+      "clojure-lsp",
+      [".clj", ".cljs", ".cljc", ".edn"],
+      ["deps.edn", "project.clj"],
+      "clojure-lsp",
+      []
+    ));
+    this.register(new GenericBinaryServer(
+      "nixd",
+      [".nix"],
+      ["flake.nix"],
+      "nixd",
+      []
+    ));
+    this.register(new GenericBinaryServer(
+      "tinymist",
+      [".typ"],
+      [],
+      "tinymist",
+      []
+    ));
+    this.register(new GenericBinaryServer(
+      "haskell-language-server",
+      [".hs", ".lhs"],
+      ["stack.yaml", "cabal.project", "*.cabal"],
+      "haskell-language-server-wrapper",
+      ["--lsp"]
+    ));
+    this.register(new GenericBinaryServer(
+      "texlab",
+      [".tex", ".bib"],
+      [],
+      "texlab",
+      []
+    ));
+  }
+  static getInstance() {
+    if (!_LspServerRegistry.instance) {
+      _LspServerRegistry.instance = new _LspServerRegistry();
+    }
+    return _LspServerRegistry.instance;
+  }
+  register(server) {
+    this.servers.push(server);
+  }
+  getServerForExtension(ext) {
+    return this.servers.find((s) => s.extensions.includes(ext)) || null;
+  }
+};
+
+// src/tools/search/LspTool/client/manager.ts
+var LspClientManager = class _LspClientManager {
+  static instance;
+  clients = /* @__PURE__ */ new Map();
+  constructor() {
+  }
+  static getInstance() {
+    if (!_LspClientManager.instance) {
+      _LspClientManager.instance = new _LspClientManager();
+    }
+    return _LspClientManager.instance;
+  }
+  async getClient(filePath, rootPath) {
+    const ext = extname2(filePath);
+    const serverInfo = LspServerRegistry.getInstance().getServerForExtension(ext);
+    if (!serverInfo) {
+      return null;
+    }
+    try {
+      const ready = await serverInfo.prepare();
+      if (!ready) {
+        return null;
+      }
+    } catch (e) {
+      return null;
+    }
+    const cmd = await serverInfo.getCommand(rootPath);
+    if (!cmd) {
+      return null;
+    }
+    const key = `${rootPath}:${serverInfo.id}`;
+    let client = this.clients.get(key);
+    if (!client) {
+      client = new GenericLspClient(cmd.command, cmd.args, rootPath, rootPath);
+      try {
+        await client.initialize();
+        this.clients.set(key, client);
+      } catch (error) {
+        return null;
+      }
+    }
+    return client;
+  }
+  async shutdownAll() {
+    for (const client of this.clients.values()) {
+      await client.shutdown();
+    }
+    this.clients.clear();
+  }
+};
+
+// src/tools/search/LspTool/client/formatters.ts
+import { fileURLToPath } from "url";
+import { relative as relative2 } from "path";
+function toProjectRelative(filePath) {
+  const cwd = getCwd();
+  try {
+    const rel = relative2(cwd, filePath);
+    if (!rel || rel === "") return filePath;
+    if (rel.startsWith("..")) return filePath;
+    return rel;
+  } catch {
+    return filePath;
+  }
+}
+function formatLocation2(uri, range) {
+  const filePath = fileURLToPath(uri);
+  return `${toProjectRelative(filePath)}:${range.start.line + 1}:${range.start.character + 1}`;
+}
+function formatGenericDefinitionResult(result) {
+  if (!result) {
+    return { formatted: "No definition found.", resultCount: 0, fileCount: 0 };
+  }
+  const locations = Array.isArray(result) ? result : [result];
+  if (locations.length === 0) {
+    return { formatted: "No definition found.", resultCount: 0, fileCount: 0 };
+  }
+  const fileCount = new Set(locations.map((l) => l.uri)).size;
+  if (locations.length === 1) {
+    return {
+      formatted: `Defined in ${formatLocation2(locations[0].uri, locations[0].range)}`,
+      resultCount: 1,
+      fileCount
+    };
+  }
+  return {
+    formatted: `Found ${locations.length} definitions:
+${locations.map((l) => `  ${formatLocation2(l.uri, l.range)}`).join("\n")}`,
+    resultCount: locations.length,
+    fileCount
+  };
 }
+function formatGenericReferencesResult(result) {
+  if (!result || !Array.isArray(result) || result.length === 0) {
+    return { formatted: "No references found.", resultCount: 0, fileCount: 0 };
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const ref of result) {
+    const file = toProjectRelative(fileURLToPath(ref.uri));
+    if (!grouped.has(file)) grouped.set(file, []);
+    grouped.get(file).push(ref);
+  }
+  const lines = [`Found ${result.length} references across ${grouped.size} files:`];
+  for (const [file, refs] of grouped) {
+    lines.push(`
+${file}:`);
+    for (const ref of refs) {
+      lines.push(`  Line ${ref.range.start.line + 1}:${ref.range.start.character + 1}`);
+    }
+  }
+  return {
+    formatted: lines.join("\n"),
+    resultCount: result.length,
+    fileCount: grouped.size
+  };
+}
+function formatGenericHoverResult(result, line, character) {
+  if (!result || !result.contents) {
+    return { formatted: "No hover info.", resultCount: 0, fileCount: 0 };
+  }
+  let contents = "";
+  if (typeof result.contents === "string") {
+    contents = result.contents;
+  } else if (Array.isArray(result.contents)) {
+    contents = result.contents.map((c) => typeof c === "string" ? c : c.value).join("\n");
+  } else {
+    contents = result.contents.value;
+  }
+  return {
+    formatted: `Hover info at ${line}:${character}:
+
+${contents}`,
+    resultCount: 1,
+    fileCount: 1
+  };
+}
+function formatGenericDocumentSymbolResult(result) {
+  if (!result || !Array.isArray(result) || result.length === 0) {
+    return { formatted: "No symbols found.", resultCount: 0, fileCount: 0 };
+  }
+  const lines = result.map((s) => {
+    const kind = s.kind;
+    return `${s.name} (${kind}) at ${s.range.start.line + 1}:${s.range.start.character + 1}`;
+  });
+  return {
+    formatted: ["Document symbols:", ...lines].join("\n"),
+    resultCount: result.length,
+    fileCount: 1
+  };
+}
+
+// src/tools/search/LspTool/LspTool.tsx
+var inputSchema4 = z4.strictObject({
+  operation: z4.enum([
+    "goToDefinition",
+    "findReferences",
+    "hover",
+    "documentSymbol",
+    "workspaceSymbol",
+    "goToImplementation",
+    "prepareCallHierarchy",
+    "incomingCalls",
+    "outgoingCalls"
+  ]).describe("The LSP operation to perform"),
+  filePath: z4.string().describe("The absolute or relative path to the file"),
+  line: z4.number().int().positive().describe("The line number (1-based, as shown in editors)"),
+  character: z4.number().int().positive().describe("The character offset (1-based, as shown in editors)")
+});
+var outputSchema = z4.object({
+  operation: z4.enum([
+    "goToDefinition",
+    "findReferences",
+    "hover",
+    "documentSymbol",
+    "workspaceSymbol",
+    "goToImplementation",
+    "prepareCallHierarchy",
+    "incomingCalls",
+    "outgoingCalls"
+  ]).describe("The LSP operation that was performed"),
+  result: z4.string().describe("The formatted result of the LSP operation"),
+  filePath: z4.string().describe("The file path the operation was performed on"),
+  resultCount: z4.number().int().nonnegative().optional().describe("Number of results (definitions, references, symbols)"),
+  fileCount: z4.number().int().nonnegative().optional().describe("Number of files containing results")
+});
+var OPERATION_LABELS = {
+  goToDefinition: { singular: "definition", plural: "definitions" },
+  findReferences: { singular: "reference", plural: "references" },
+  documentSymbol: { singular: "symbol", plural: "symbols" },
+  workspaceSymbol: { singular: "symbol", plural: "symbols" },
+  hover: { singular: "hover info", plural: "hover info", special: "available" },
+  goToImplementation: { singular: "implementation", plural: "implementations" },
+  prepareCallHierarchy: { singular: "call item", plural: "call items" },
+  incomingCalls: { singular: "caller", plural: "callers" },
+  outgoingCalls: { singular: "callee", plural: "callees" }
+};
 function summarizeToolResult(operation, resultCount, fileCount) {
   const label = OPERATION_LABELS[operation] ?? {
     singular: "result",
@@ -1362,7 +2385,7 @@ var LspTool = {
     return "LSP";
   },
   async isEnabled() {
-    return tryLoadTypeScriptModule(getCwd()) !== null;
+    return true;
   },
   isReadOnly() {
     return true;
@@ -1384,7 +2407,7 @@ var LspTool = {
       };
     }
     const absPath = getAbsolutePath(input.filePath) ?? input.filePath;
-    if (!existsSync2(absPath)) {
+    if (!existsSync4(absPath)) {
       return {
         result: false,
         message: `File does not exist: ${input.filePath}`,
@@ -1392,7 +2415,7 @@ var LspTool = {
       };
     }
     try {
-      if (!statSync(absPath).isFile()) {
+      if (!statSync2(absPath).isFile()) {
         return {
           result: false,
           message: `Path is not a file: ${input.filePath}`,
@@ -1411,12 +2434,12 @@ var LspTool = {
   },
   renderToolUseMessage(input, { verbose }) {
     const abs = getAbsolutePath(input.filePath) ?? input.filePath;
-    const filePathForDisplay = verbose ? abs : toProjectRelativeIfPossible(abs);
+    const filePathForDisplay = verbose ? abs : TypeScriptBackend.toProjectRelativeIfPossible(abs);
     const parts = [];
     if ((input.operation === "goToDefinition" || input.operation === "findReferences" || input.operation === "hover" || input.operation === "goToImplementation") && input.filePath && input.line !== void 0 && input.character !== void 0) {
       try {
-        const content = readFileSync2(abs, "utf8");
-        const symbol = extractSymbolAtPosition(
+        const content = readFileSync3(abs, "utf8");
+        const symbol = TypeScriptBackend.extractSymbolAtPosition(
           content.split("\n"),
           input.line - 1,
           input.character - 1
@@ -1460,282 +2483,96 @@ var LspTool = {
   },
   async *call(input, _context) {
     const absPath = getAbsolutePath(input.filePath) ?? input.filePath;
-    if (!isFileTypeSupportedByTypescriptBackend(absPath)) {
-      const ext = extname(absPath);
-      const out = {
-        operation: input.operation,
-        result: `No LSP server available for file type: ${ext}`,
-        filePath: input.filePath,
-        resultCount: 0,
-        fileCount: 0
-      };
-      yield { type: "result", data: out, resultForAssistant: out.result };
-      return;
-    }
-    const project = getOrCreateTsProject(getCwd());
-    if (!project) {
-      const out = {
-        operation: input.operation,
-        result: "LSP server manager not initialized. This may indicate a startup issue.",
-        filePath: input.filePath,
-        resultCount: 0,
-        fileCount: 0
-      };
-      yield { type: "result", data: out, resultForAssistant: out.result };
-      return;
-    }
-    project.rootFiles.add(absPath);
-    const ts = project.ts;
-    const service = project.languageService;
-    const program = service.getProgram?.();
-    if (!program) {
-      const out = {
-        operation: input.operation,
-        result: `Error performing ${input.operation}: TypeScript program not available`,
-        filePath: input.filePath,
-        resultCount: 0,
-        fileCount: 0
-      };
-      yield { type: "result", data: out, resultForAssistant: out.result };
-      return;
-    }
-    const sourceFile = program.getSourceFile(absPath);
-    if (!sourceFile) {
-      const out = {
-        operation: input.operation,
-        result: `Error performing ${input.operation}: File is not part of the TypeScript program`,
-        filePath: input.filePath,
-        resultCount: 0,
-        fileCount: 0
-      };
-      yield { type: "result", data: out, resultForAssistant: out.result };
-      return;
-    }
-    const pos = ts.getPositionOfLineAndCharacter(
-      sourceFile,
-      input.line - 1,
-      input.character - 1
-    );
-    try {
-      let formatted;
-      let resultCount = 0;
-      let fileCount = 0;
-      switch (input.operation) {
-        case "goToDefinition": {
-          const defs = service.getDefinitionAtPosition?.(absPath, pos) ?? [];
-          const locations = defs.map((d) => {
-            const defSourceFile = program.getSourceFile(d.fileName);
-            if (!defSourceFile) return null;
-            const lc = ts.getLineAndCharacterOfPosition(
-              defSourceFile,
-              d.textSpan.start
-            );
-            return {
-              fileName: d.fileName,
-              line0: lc.line,
-              character0: lc.character
-            };
-          }).filter(Boolean);
-          const res = formatGoToDefinitionResult(locations);
-          formatted = res.formatted;
-          resultCount = res.resultCount;
-          fileCount = res.fileCount;
-          break;
-        }
-        case "goToImplementation": {
-          const impls = service.getImplementationAtPosition?.(absPath, pos) ?? [];
-          const locations = impls.map((d) => {
-            const defSourceFile = program.getSourceFile(d.fileName);
-            if (!defSourceFile) return null;
-            const lc = ts.getLineAndCharacterOfPosition(
-              defSourceFile,
-              d.textSpan.start
-            );
-            return {
-              fileName: d.fileName,
-              line0: lc.line,
-              character0: lc.character
-            };
-          }).filter(Boolean);
-          const res = formatGoToDefinitionResult(locations);
-          formatted = res.formatted;
-          resultCount = res.resultCount;
-          fileCount = res.fileCount;
-          break;
-        }
-        case "findReferences": {
-          const referencedSymbols = service.findReferences?.(absPath, pos) ?? [];
-          const refs = [];
-          for (const sym of referencedSymbols) {
-            for (const ref of sym.references ?? []) {
-              const refSource = program.getSourceFile(ref.fileName);
-              if (!refSource) continue;
-              const lc = ts.getLineAndCharacterOfPosition(
-                refSource,
-                ref.textSpan.start
-              );
-              refs.push({
-                fileName: ref.fileName,
-                line0: lc.line,
-                character0: lc.character
-              });
-            }
-          }
-          const res = formatFindReferencesResult(refs);
-          formatted = res.formatted;
-          resultCount = res.resultCount;
-          fileCount = res.fileCount;
-          break;
-        }
-        case "hover": {
-          const info = service.getQuickInfoAtPosition?.(absPath, pos);
-          let text = null;
-          let hoverLine0 = input.line - 1;
-          let hoverCharacter0 = input.character - 1;
-          if (info) {
-            const parts = [];
-            const signature = ts.displayPartsToString(info.displayParts ?? []);
-            if (signature) parts.push(signature);
-            const doc = ts.displayPartsToString(info.documentation ?? []);
-            if (doc) parts.push(doc);
-            if (info.tags && info.tags.length > 0) {
-              for (const tag of info.tags) {
-                const tagText = ts.displayPartsToString(tag.text ?? []);
-                parts.push(`@${tag.name}${tagText ? ` ${tagText}` : ""}`);
-              }
-            }
-            text = parts.filter(Boolean).join("\n\n");
-            const lc = ts.getLineAndCharacterOfPosition(
-              sourceFile,
-              info.textSpan.start
-            );
-            hoverLine0 = lc.line;
-            hoverCharacter0 = lc.character;
-          }
-          const res = formatHoverResult(text, hoverLine0, hoverCharacter0);
-          formatted = res.formatted;
-          resultCount = res.resultCount;
-          fileCount = res.fileCount;
-          break;
-        }
-        case "documentSymbol": {
-          const tree = service.getNavigationTree?.(absPath);
-          const lines = [];
-          let count = 0;
-          const kindLabel = (kind) => {
-            const m = {
-              class: "Class",
-              interface: "Interface",
-              enum: "Enum",
-              function: "Function",
-              method: "Method",
-              property: "Property",
-              var: "Variable",
-              let: "Variable",
-              const: "Constant",
-              module: "Module",
-              alias: "Alias",
-              type: "Type"
-            };
-            return m[kind] ?? (kind ? kind[0].toUpperCase() + kind.slice(1) : "Unknown");
-          };
-          const walk = (node, depth) => {
-            const children = node?.childItems ?? [];
-            for (const child of children) {
-              const span = child.spans?.[0];
-              if (!span) continue;
-              const lc = ts.getLineAndCharacterOfPosition(
-                sourceFile,
-                span.start
-              );
-              const indent = "  ".repeat(depth);
-              const label = kindLabel(child.kind);
-              const detail = child.kindModifiers ? ` ${child.kindModifiers}` : "";
-              lines.push(
-                `${indent}${child.text} (${label})${detail} - Line ${lc.line + 1}`
-              );
-              count += 1;
-              if (child.childItems && child.childItems.length > 0) {
-                walk(child, depth + 1);
-              }
-            }
-          };
-          walk(tree, 0);
-          const res = formatDocumentSymbolsResult(lines, count);
-          formatted = res.formatted;
-          resultCount = res.resultCount;
-          fileCount = res.fileCount;
-          break;
-        }
-        case "workspaceSymbol": {
-          const items = service.getNavigateToItems?.("", 100, void 0, true, true) ?? [];
-          if (!items || items.length === 0) {
-            formatted = "No symbols found in workspace. This may occur if the workspace is empty, or if the LSP server has not finished indexing the project.";
-            resultCount = 0;
-            fileCount = 0;
+    const client = await LspClientManager.getInstance().getClient(absPath, getCwd());
+    if (client) {
+      try {
+        let result;
+        let formattedResult;
+        switch (input.operation) {
+          case "goToDefinition":
+            result = await client.goToDefinition(absPath, input.line, input.character);
+            formattedResult = formatGenericDefinitionResult(result);
             break;
-          }
-          const lines = [
-            `Found ${items.length} symbol${items.length === 1 ? "" : "s"} in workspace:`
-          ];
-          const grouped = groupLocationsByFile(
-            items.map((it) => ({
-              fileName: it.fileName,
-              item: it
-            }))
-          );
-          for (const [file, itemsInFile] of grouped) {
-            lines.push(`
-${file}:`);
-            for (const wrapper of itemsInFile) {
-              const it = wrapper.item;
-              const sf = program.getSourceFile(it.fileName);
-              if (!sf) continue;
-              const span = it.textSpan;
-              const lc = span ? ts.getLineAndCharacterOfPosition(sf, span.start) : { line: 0, character: 0 };
-              const label = it.kind ? String(it.kind)[0].toUpperCase() + String(it.kind).slice(1) : "Symbol";
-              let line = `  ${it.name} (${label}) - Line ${lc.line + 1}`;
-              if (it.containerName) line += ` in ${it.containerName}`;
-              lines.push(line);
-            }
-          }
-          formatted = lines.join("\n");
-          resultCount = items.length;
-          fileCount = grouped.size;
-          break;
-        }
-        case "prepareCallHierarchy":
-        case "incomingCalls":
-        case "outgoingCalls": {
-          const opLabel = input.operation;
-          formatted = `Error performing ${opLabel}: Call hierarchy is not supported by the TypeScript backend`;
-          resultCount = 0;
-          fileCount = 0;
-          break;
-        }
-        default: {
-          formatted = `Error performing ${input.operation}: Unsupported operation`;
-          resultCount = 0;
-          fileCount = 0;
+          case "findReferences":
+            result = await client.findReferences(absPath, input.line, input.character);
+            formattedResult = formatGenericReferencesResult(result);
+            break;
+          case "hover":
+            result = await client.hover(absPath, input.line, input.character);
+            formattedResult = formatGenericHoverResult(result, input.line, input.character);
+            break;
+          case "documentSymbol":
+            result = await client.documentSymbol(absPath);
+            formattedResult = formatGenericDocumentSymbolResult(result);
+            break;
+          case "goToImplementation":
+            result = await client.goToImplementation(absPath, input.line, input.character);
+            formattedResult = formatGenericDefinitionResult(result);
+            break;
+          default:
+            formattedResult = { formatted: `Operation ${input.operation} not supported by generic client yet.`, resultCount: 0, fileCount: 0 };
         }
+        const out2 = {
+          operation: input.operation,
+          result: formattedResult.formatted,
+          filePath: input.filePath,
+          resultCount: formattedResult.resultCount,
+          fileCount: formattedResult.fileCount
+        };
+        yield { type: "result", data: out2, resultForAssistant: out2.result };
+        return;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const out2 = {
+          operation: input.operation,
+          result: `Error performing ${input.operation} with generic client: ${message}`,
+          filePath: input.filePath,
+          resultCount: 0,
+          fileCount: 0
+        };
+        yield { type: "result", data: out2, resultForAssistant: out2.result };
+        return;
+      }
+    }
+    if (TypeScriptBackend.isFileTypeSupported(absPath)) {
+      try {
+        const result = TypeScriptBackend.runOperation(
+          input.operation,
+          absPath,
+          input.line,
+          input.character
+        );
+        const out2 = {
+          operation: input.operation,
+          result: result.formatted,
+          filePath: input.filePath,
+          resultCount: result.resultCount,
+          fileCount: result.fileCount
+        };
+        yield { type: "result", data: out2, resultForAssistant: out2.result };
+        return;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const out2 = {
+          operation: input.operation,
+          result: `Error performing ${input.operation}: ${message}`,
+          filePath: input.filePath,
+          resultCount: 0,
+          fileCount: 0
+        };
+        yield { type: "result", data: out2, resultForAssistant: out2.result };
+        return;
       }
-      const out = {
-        operation: input.operation,
-        result: formatted,
-        filePath: input.filePath,
-        resultCount,
-        fileCount
-      };
-      yield { type: "result", data: out, resultForAssistant: out.result };
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      const out = {
-        operation: input.operation,
-        result: `Error performing ${input.operation}: ${message}`,
-        filePath: input.filePath
-      };
-      yield { type: "result", data: out, resultForAssistant: out.result };
     }
+    const ext = extname3(absPath);
+    const out = {
+      operation: input.operation,
+      result: `No LSP server available for file type: ${ext}`,
+      filePath: input.filePath,
+      resultCount: 0,
+      fileCount: 0
+    };
+    yield { type: "result", data: out, resultForAssistant: out.result };
   }
 };
 
@@ -1876,7 +2713,7 @@ import React6 from "react";
 import { Box as Box6, Text as Text6 } from "ink";
 import { z as z6 } from "zod";
 import { randomUUID as randomUUID2 } from "crypto";
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
 
 // src/utils/agent/transcripts.ts
 var transcripts = /* @__PURE__ */ new Map();
@@ -2050,9 +2887,9 @@ function applyAgentPermissionMode(base, options) {
   return { ...base, mode: options.agentPermissionMode };
 }
 function readJsonArrayFile(path) {
-  if (!existsSync3(path)) return null;
+  if (!existsSync5(path)) return null;
   try {
-    const raw = readFileSync3(path, "utf8");
+    const raw = readFileSync4(path, "utf8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed) ? parsed : null;
   } catch {