pybao-cli 1.3.82 → 1.3.84

package/dist/chunk-4PBAKIJH.js

@@ -1,929 +0,0 @@
-import { createRequire as __pybCreateRequire } from "node:module";
-const require = __pybCreateRequire(import.meta.url);
-import {
-  levenshtein
-} from "./chunk-UZ34JEUK.js";
-import {
-  debug
-} from "./chunk-M4X6YU4Q.js";
-import {
-  getCwd
-} from "./chunk-SWH7ADMS.js";
-import {
-  __require
-} from "./chunk-I3J4JYES.js";
-
-// src/tools/search/LspTool/client/generic.ts
-import { createMessageConnection, StreamMessageReader, StreamMessageWriter } from "vscode-jsonrpc/node.js";
-import { spawn } from "child_process";
-import { pathToFileURL, fileURLToPath } from "url";
-import { EventEmitter } from "events";
-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));
-      }
-      if (method === "textDocument/publishDiagnostics") {
-        try {
-          const uri = params.uri;
-          let filePath = uri;
-          if (uri.startsWith("file://")) {
-            filePath = fileURLToPath(uri);
-          }
-          const normalizedUri = this.normalizeUri(filePath);
-          this.diagnosticsMap.set(normalizedUri, params.diagnostics);
-          this.diagnosticEvents.emit("diagnostics", { uri, filePath, diagnostics: params.diagnostics });
-        } catch (e) {
-          console.error("[LSP] Error processing diagnostics:", e);
-        }
-      }
-    });
-    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;
-  diagnosticEvents = new EventEmitter();
-  diagnosticsMap = /* @__PURE__ */ new Map();
-  normalizeUri(filePath) {
-    let uri = pathToFileURL(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(query) {
-    const params = {
-      query
-    };
-    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);
-  }
-  async didClose(filePath) {
-    const params = {
-      textDocument: {
-        uri: this.normalizeUri(filePath)
-      }
-    };
-    await this.connection.sendNotification("textDocument/didClose", params);
-  }
-  async waitForReadiness(filePath, timeoutMs = 3e3) {
-    const normalizedUri = this.normalizeUri(filePath);
-    return new Promise((resolve) => {
-      let debounceTimer;
-      let timeoutTimer;
-      const cleanup = () => {
-        if (debounceTimer) clearTimeout(debounceTimer);
-        clearTimeout(timeoutTimer);
-        this.diagnosticEvents.off("diagnostics", handler);
-      };
-      const handler = (event) => {
-        if (event.uri === normalizedUri || event.uri.toLowerCase() === normalizedUri.toLowerCase() || decodeURIComponent(event.uri) === decodeURIComponent(normalizedUri)) {
-          if (debounceTimer) clearTimeout(debounceTimer);
-          debounceTimer = setTimeout(() => {
-            cleanup();
-            resolve();
-          }, 150);
-        }
-      };
-      this.diagnosticEvents.on("diagnostics", handler);
-      timeoutTimer = setTimeout(() => {
-        cleanup();
-        resolve();
-      }, timeoutMs);
-    });
-  }
-  getDiagnostics(filePath) {
-    return this.diagnosticsMap.get(this.normalizeUri(filePath)) || [];
-  }
-};
-
-// src/tools/search/LspTool/client/manager.ts
-import { extname, join as join2, dirname as dirname2 } from "path";
-
-// src/tools/search/LspTool/registry.ts
-import { join, dirname } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { existsSync } from "fs";
-import { spawnSync } from "child_process";
-var __filename = fileURLToPath2(import.meta.url);
-var __dirname = dirname(__filename);
-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, npmPackageName) {
-    const exts = process.platform === "win32" ? [".cmd", ".exe", ".ps1", ""] : [""];
-    const localNodeModulesBin = join(process.cwd(), "node_modules", ".bin");
-    for (const ext of exts) {
-      const localBinPath = join(localNodeModulesBin, `${binName}${ext}`);
-      if (existsSync(localBinPath)) {
-        return localBinPath;
-      }
-    }
-    try {
-      const pkgName = npmPackageName || binName;
-      const pkgEntry = __require.resolve(pkgName, { paths: [process.cwd(), __dirname] });
-      let current = pkgEntry;
-      let pkgRoot = "";
-      for (let i = 0; i < 5; i++) {
-        current = join(current, "..");
-        if (existsSync(join(current, "package.json"))) {
-          pkgRoot = current;
-          break;
-        }
-      }
-      if (pkgRoot) {
-        const nodeModulesRoot = join(pkgRoot, "..");
-        for (const ext of exts) {
-          const potentialBin = join(nodeModulesRoot, ".bin", `${binName}${ext}`);
-          if (existsSync(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, this.npmPackage);
-    if (existsSync(localBin)) {
-      return true;
-    }
-    return false;
-  }
-  async getCommand(rootPath) {
-    if (process.platform === "win32") {
-      try {
-        const pkgJsonPath = __require.resolve(`${this.npmPackage}/package.json`, { paths: [process.cwd(), __dirname] });
-        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 = join(dirname(pkgJsonPath), "dist", "pyright-langserver.js");
-            if (existsSync(distScript)) {
-              return { command: process.execPath, args: [distScript, ...this.args] };
-            }
-          }
-          const scriptPath = join(dirname(pkgJsonPath), binScript);
-          if (existsSync(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, this.npmPackage);
-    if (existsSync(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(
-      "typescript-language-server",
-      [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"],
-      ["tsconfig.json", "package.json", "jsconfig.json"],
-      "typescript-language-server",
-      "typescript-language-server",
-      ["--stdio"]
-    ));
-    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(
-      "metals",
-      [".scala", ".sbt", ".sc"],
-      ["build.sbt"],
-      "metals",
-      []
-    ));
-    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
-import { readdir, readFile } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
-var LspClientManager = class _LspClientManager {
-  static instance;
-  clients = /* @__PURE__ */ new Map();
-  constructor() {
-  }
-  static getInstance() {
-    if (!_LspClientManager.instance) {
-      _LspClientManager.instance = new _LspClientManager();
-    }
-    return _LspClientManager.instance;
-  }
-  getLanguageId(ext) {
-    const map = {
-      ".ts": "typescript",
-      ".tsx": "typescriptreact",
-      ".js": "javascript",
-      ".jsx": "javascriptreact",
-      ".py": "python",
-      ".java": "java",
-      ".cs": "csharp",
-      ".cpp": "cpp",
-      ".c": "c",
-      ".rs": "rust",
-      ".go": "go"
-    };
-    return map[ext] || "plaintext";
-  }
-  async ensureWorkspaceClients(rootPath) {
-    try {
-      const files = await readdir(rootPath, { withFileTypes: true });
-      const extensionMap = /* @__PURE__ */ new Map();
-      const fileNames = new Set(files.map((f) => f.name));
-      if (fileNames.has("tsconfig.json") || fileNames.has("package.json")) {
-        if (!files.some((f) => f.isFile() && /\.(ts|tsx|js|jsx)$/.test(f.name))) {
-          try {
-            const srcFiles = await readdir(join2(rootPath, "src"), { withFileTypes: true });
-            const triggerFile = srcFiles.find((f) => f.isFile() && /\.(ts|tsx|js|jsx)$/.test(f.name));
-            if (triggerFile) {
-              extensionMap.set(extname(triggerFile.name), join2(rootPath, "src", triggerFile.name));
-            }
-          } catch (e) {
-          }
-        }
-      }
-      if (fileNames.has("go.mod")) {
-        extensionMap.set(".go", join2(rootPath, "go.mod"));
-        if (fileNames.has("main.go")) extensionMap.set(".go", join2(rootPath, "main.go"));
-      }
-      if (fileNames.has("Cargo.toml")) {
-        try {
-          if (existsSync2(join2(rootPath, "src", "main.rs"))) extensionMap.set(".rs", join2(rootPath, "src", "main.rs"));
-          else if (existsSync2(join2(rootPath, "src", "lib.rs"))) extensionMap.set(".rs", join2(rootPath, "src", "lib.rs"));
-        } catch (e) {
-        }
-      }
-      for (const file of files) {
-        if (file.isFile()) {
-          const ext = extname(file.name);
-          if (ext && !extensionMap.has(ext)) {
-            extensionMap.set(ext, join2(rootPath, file.name));
-          }
-        }
-      }
-      for (const [ext, realPath] of extensionMap) {
-        const client = await this.getClient(realPath, rootPath);
-        if (client) {
-          try {
-            const content = await readFile(realPath, "utf-8");
-            await client.didOpen(realPath, content, this.getLanguageId(ext));
-            await client.waitForReadiness(realPath, 2e3);
-          } catch (e) {
-          }
-        } else {
-        }
-      }
-    } catch (e) {
-    }
-  }
-  async getClientForFile(filePath) {
-    const rootPath = this.findProjectRoot(filePath);
-    return this.getClient(filePath, rootPath);
-  }
-  findProjectRoot(filePath) {
-    const cwd = getCwd();
-    if (filePath.startsWith(cwd)) {
-      return cwd;
-    }
-    return dirname2(filePath);
-  }
-  async getClient(filePath, rootPath = getCwd()) {
-    const ext = extname(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();
-  }
-  async workspaceSymbol(query, rootPath = getCwd()) {
-    if (this.clients.size === 0) {
-      await this.ensureWorkspaceClients(rootPath);
-    }
-    const results = [];
-    for (const client of this.clients.values()) {
-      try {
-        const symbols = await client.workspaceSymbol(query);
-        if (symbols && Array.isArray(symbols)) {
-          results.push(...symbols);
-        }
-      } catch (e) {
-      }
-    }
-    if (results.length === 0 && query.length > 0) {
-      for (const client of this.clients.values()) {
-        try {
-          const broadSymbols = await client.workspaceSymbol("");
-          if (broadSymbols && Array.isArray(broadSymbols)) {
-            for (const sym of broadSymbols) {
-              const dist = levenshtein(query, sym.name);
-              if (dist <= 2 || dist <= query.length * 0.3) {
-                results.push(sym);
-              }
-            }
-          }
-        } catch (e) {
-        }
-      }
-    }
-    return results;
-  }
-  async documentSymbol(filePath, rootPath = getCwd()) {
-    const client = await this.getClient(filePath, rootPath);
-    if (!client) {
-      return null;
-    }
-    try {
-      const content = await readFile(filePath, "utf-8");
-      const languageId = this.getLanguageId(extname(filePath));
-      await client.didOpen(filePath, content, languageId);
-      await client.waitForReadiness(filePath, 2e3);
-      const symbols = await client.documentSymbol(filePath);
-      return symbols || [];
-    } catch (e) {
-      console.error(`Failed to get document symbols for ${filePath}:`, e);
-      return null;
-    }
-  }
-  async getDiagnostics(filePath, rootPath = getCwd()) {
-    const client = await this.getClient(filePath, rootPath);
-    if (!client) {
-      return [];
-    }
-    return client.getDiagnostics(filePath);
-  }
-  // New helper to expose waitForReadiness to clients who only have a manager
-  async waitForReadiness(filePath, rootPath = getCwd(), timeoutMs = 2e3) {
-    const client = await this.getClientForFile(filePath);
-    if (client) {
-      await client.waitForReadiness(filePath, timeoutMs);
-    }
-  }
-};
-
-export {
-  LspClientManager
-};