pybao-cli 1.3.62 → 1.3.64

package/dist/chunk-K4F43CEG.js

@@ -0,0 +1,727 @@
+import { createRequire as __pybCreateRequire } from "node:module";
+const require = __pybCreateRequire(import.meta.url);
+import {
+  debug
+} from "./chunk-BEYXNT3B.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 } 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 = 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);
+  }
+  getDiagnostics(filePath) {
+    return this.diagnostics.get(this.normalizeUri(filePath)) || [];
+  }
+};
+
+// src/tools/search/LspTool/client/manager.ts
+import { extname } from "path";
+
+// src/tools/search/LspTool/registry.ts
+import { join, dirname } from "path";
+import { existsSync } 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, npmPackageName) {
+    const ext = process.platform === "win32" ? ".cmd" : "";
+    const localNodeModulesBin = join(process.cwd(), "node_modules", ".bin");
+    let 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, "..");
+        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(
+      "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
+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 = 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) {
+    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) {
+      }
+    }
+    return results;
+  }
+};
+
+export {
+  LspClientManager
+};