pi-lens 3.6.2 → 3.6.4

package/clients/lsp/server.js

@@ -1,725 +0,0 @@
-/**
- * LSP Server Definitions for pi-lens
- *
- * Defines 40+ language servers with:
- * - Root detection (monorepo support)
- * - Auto-installation strategies
- * - Platform-specific handling
- */
-import { stat } from "node:fs/promises";
-import path from "node:path";
-import { ensureTool, getToolEnvironment } from "../installer/index.js";
-import { promptForInstall, supportsInteractiveInstall, } from "./interactive-install.js";
-import { launchLSP, launchViaPackageManager, } from "./launch.js";
-// --- Root Detection Helpers ---
-import { dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-// --- Interactive Install Helper ---
-/**
- * Spawn LSP with interactive install support for common languages
- *
- * For Go, Rust, YAML, JSON, Bash: prompts user to install if tool not found
- * Other languages: throws error with install instructions
- */
-async function spawnWithInteractiveInstall(language, _command, _args, options, spawnFn) {
-    try {
-        return await spawnFn();
-    }
-    catch (error) {
-        // Check if this is a "command not found" error
-        const errorMsg = String(error);
-        if (!errorMsg.includes("not found") && !errorMsg.includes("ENOENT")) {
-            throw error; // Re-throw if it's a different error
-        }
-        // Check if language supports interactive install
-        if (supportsInteractiveInstall(language)) {
-            const shouldInstall = await promptForInstall(language, options.cwd);
-            if (shouldInstall) {
-                // Try again after install
-                return await spawnFn();
-            }
-            // User declined, return undefined to skip this LSP
-            return undefined;
-        }
-        // For other languages, throw with install instructions
-        throw error;
-    }
-}
-/**
- * Walk up the directory tree looking for project root markers.
- *
- * NearestRoot(includePatterns, excludePatterns?) → RootFunction
- *
- * - includePatterns: file/dir names that signal the project root (e.g. ["package.json"])
- * - excludePatterns: if any of these exist in a directory, skip it (e.g. ["node_modules"])
- * - stopDir: walk stops here (defaults to filesystem root; set to project cwd for safety)
- *
- * Equivalent to createRootDetector; exported under both names for clarity.
- */
-export function NearestRoot(includePatterns, excludePatterns, stopDir) {
-    return async (file) => {
-        let currentDir = path.dirname(file);
-        const fsRoot = path.parse(currentDir).root;
-        const stop = stopDir ?? fsRoot;
-        while (currentDir !== fsRoot) {
-            // Bail out if we've reached the stop boundary
-            if (currentDir === stop ||
-                (currentDir.startsWith(stop + path.sep) === false &&
-                    currentDir === stop)) {
-                break;
-            }
-            // Check exclude patterns — skip this dir (but keep walking up)
-            if (excludePatterns) {
-                let excluded = false;
-                for (const pattern of excludePatterns) {
-                    try {
-                        await stat(path.join(currentDir, pattern));
-                        excluded = true;
-                        break;
-                    }
-                    catch {
-                        /* not found */
-                    }
-                }
-                if (excluded) {
-                    currentDir = path.dirname(currentDir);
-                    continue;
-                }
-            }
-            // Check include patterns
-            for (const pattern of includePatterns) {
-                try {
-                    await stat(path.join(currentDir, pattern));
-                    return currentDir;
-                }
-                catch {
-                    /* not found */
-                }
-            }
-            currentDir = path.dirname(currentDir);
-        }
-        return undefined;
-    };
-}
-/** Alias kept for backward compatibility */
-export const createRootDetector = NearestRoot;
-// --- Server Definitions ---
-export const TypeScriptServer = {
-    id: "typescript",
-    name: "TypeScript Language Server",
-    extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"],
-    root: createRootDetector([
-        "package-lock.json",
-        "bun.lockb",
-        "bun.lock",
-        "pnpm-lock.yaml",
-        "yarn.lock",
-        "package.json",
-    ]),
-    async spawn(root) {
-        const path = await import("node:path");
-        const fs = await import("node:fs/promises");
-        // Find typescript-language-server - prefer local project version
-        let lspPath;
-        const localLsp = path.join(root, "node_modules", ".bin", "typescript-language-server");
-        const localLspCmd = path.join(root, "node_modules", ".bin", "typescript-language-server.cmd");
-        // Check for local version first (Windows .cmd first, then Unix)
-        for (const checkPath of [localLspCmd, localLsp]) {
-            try {
-                await fs.access(checkPath);
-                lspPath = checkPath;
-                break;
-            }
-            catch {
-                /* not found */
-            }
-        }
-        // Fall back to auto-installed version
-        if (!lspPath) {
-            lspPath = await ensureTool("typescript-language-server");
-            if (!lspPath) {
-                console.error("[lsp] typescript-language-server not found");
-                return undefined;
-            }
-        }
-        // Find tsserver.js path (needed for TypeScript LSP initialization)
-        // Check relative to the LSP path first, then project root
-        let tsserverPath;
-        const tsserverCandidates = [
-            // Relative to LSP binary (for locally installed)
-            path.join(path.dirname(lspPath), "..", "typescript", "lib", "tsserver.js"),
-            // Project root
-            path.join(root, "node_modules", "typescript", "lib", "tsserver.js"),
-            // Current working directory
-            path.join(process.cwd(), "node_modules", "typescript", "lib", "tsserver.js"),
-        ];
-        for (const checkPath of tsserverCandidates) {
-            try {
-                await fs.access(checkPath);
-                tsserverPath = checkPath;
-                break;
-            }
-            catch {
-                /* not found */
-            }
-        }
-        // Use absolute path and proper environment
-        const env = await getToolEnvironment();
-        const proc = await launchLSP(lspPath, ["--stdio"], {
-            cwd: root,
-            env: {
-                ...env,
-                TSSERVER_PATH: tsserverPath,
-            },
-        });
-        return {
-            process: proc,
-            initialization: tsserverPath
-                ? { tsserver: { path: tsserverPath } }
-                : undefined,
-        };
-    },
-};
-export const PythonServer = {
-    id: "python",
-    name: "Pyright Language Server",
-    extensions: [".py", ".pyi"],
-    root: createRootDetector([
-        "pyproject.toml",
-        "setup.py",
-        "setup.cfg",
-        "requirements.txt",
-        "Pipfile",
-        "poetry.lock",
-    ]),
-    async spawn(root) {
-        const path = await import("node:path");
-        const fs = await import("node:fs/promises");
-        const env = await getToolEnvironment();
-        // Strategy 1: Find pyright - prefer local project version
-        let pyrightPath;
-        const localPyright = path.join(root, "node_modules", ".bin", "pyright");
-        const localPyrightCmd = path.join(root, "node_modules", ".bin", "pyright.cmd");
-        // Check for local version first (Windows .cmd first, then Unix)
-        for (const checkPath of [localPyrightCmd, localPyright]) {
-            try {
-                await fs.access(checkPath);
-                pyrightPath = checkPath;
-                break;
-            }
-            catch {
-                /* not found */
-            }
-        }
-        // Strategy 2: Fall back to auto-installed version
-        if (!pyrightPath) {
-            pyrightPath = await ensureTool("pyright");
-            if (!pyrightPath) {
-                console.error("[lsp] pyright not found, falling back to npx");
-            }
-        }
-        // Strategy 3: Use found pyright to derive pyright-langserver path
-        let langserverPath;
-        if (pyrightPath) {
-            // Derive langserver from pyright binary location
-            // Both are in the same .bin directory
-            const binDir = path.dirname(pyrightPath);
-            const isWindows = process.platform === "win32";
-            const candidates = isWindows
-                ? [
-                    path.join(binDir, "pyright-langserver.cmd"),
-                    path.join(binDir, "pyright-langserver.ps1"),
-                    path.join(binDir, "pyright-langserver"),
-                ]
-                : [path.join(binDir, "pyright-langserver")];
-            for (const candidate of candidates) {
-                try {
-                    await fs.access(candidate);
-                    langserverPath = candidate;
-                    console.error(`[lsp] Found pyright-langserver: ${candidate}`);
-                    break;
-                }
-                catch {
-                    /* not found */
-                }
-            }
-        }
-        // Spawn the LSP server
-        let proc;
-        if (langserverPath) {
-            // Use resolved langserver path
-            proc = await launchLSP(langserverPath, ["--stdio"], {
-                cwd: root,
-                env,
-            });
-        }
-        else {
-            // Fallback to npx for auto-download
-            console.error("[lsp] Falling back to npx for pyright-langserver");
-            proc = await launchViaPackageManager("pyright-langserver", ["--stdio"], {
-                cwd: root,
-                env,
-            });
-        }
-        // Detect virtual environment
-        const initialization = {};
-        const venvPaths = [
-            path.join(root, ".venv"),
-            path.join(root, "venv"),
-            process.env.VIRTUAL_ENV,
-        ].filter(Boolean);
-        for (const venv of venvPaths) {
-            if (!venv)
-                continue;
-            try {
-                const pythonPath = process.platform === "win32"
-                    ? path.join(venv, "Scripts", "python.exe")
-                    : path.join(venv, "bin", "python");
-                await fs.access(pythonPath);
-                // Pyright expects pythonPath at top level, not nested
-                initialization.pythonPath = pythonPath;
-                break;
-            }
-            catch {
-                /* not found */
-            }
-        }
-        return { process: proc, initialization };
-    },
-};
-export const GoServer = {
-    id: "go",
-    name: "gopls",
-    extensions: [".go"],
-    root: createRootDetector(["go.mod", "go.sum"]),
-    async spawn(root) {
-        const proc = await spawnWithInteractiveInstall("go", "gopls", [], { cwd: root }, async () => await launchLSP("gopls", [], { cwd: root }));
-        // gopls works best with minimal initialization options
-        // The client capabilities fix (workspaceFolders: true) is the key fix
-        return proc
-            ? {
-                process: proc,
-                initialization: {
-                    // Disable experimental features that may cause issues
-                    ui: {
-                        semanticTokens: true,
-                    },
-                },
-            }
-            : undefined;
-    },
-};
-export const RustServer = {
-    id: "rust",
-    name: "rust-analyzer",
-    extensions: [".rs"],
-    root: createRootDetector(["Cargo.toml", "Cargo.lock"]),
-    async spawn(root) {
-        const proc = await spawnWithInteractiveInstall("rust", "rust-analyzer", [], { cwd: root }, async () => await launchLSP("rust-analyzer", [], { cwd: root }));
-        // rust-analyzer needs minimal initialization to avoid capability mismatches
-        return proc
-            ? {
-                process: proc,
-                initialization: {
-                    // Disable features that may conflict with our client capabilities
-                    cargo: {
-                        buildScripts: { enable: true },
-                    },
-                    procMacro: { enable: true },
-                    diagnostics: { enable: true },
-                },
-            }
-            : undefined;
-    },
-};
-export const RubyServer = {
-    id: "ruby",
-    name: "Ruby LSP",
-    extensions: [".rb", ".rake", ".gemspec", ".ru"],
-    root: createRootDetector(["Gemfile", ".ruby-version"]),
-    async spawn(root) {
-        // Try ruby-lsp first, fall back to solargraph
-        try {
-            const proc = await launchLSP("ruby-lsp", [], { cwd: root });
-            return { process: proc };
-        }
-        catch {
-            const proc = await launchViaPackageManager("solargraph", ["stdio"], {
-                cwd: root,
-            });
-            return { process: proc };
-        }
-    },
-};
-export const PHPServer = {
-    id: "php",
-    name: "Intelephense",
-    extensions: [".php"],
-    root: createRootDetector(["composer.json", "composer.lock"]),
-    async spawn(root) {
-        const proc = await launchViaPackageManager("intelephense", ["--stdio"], {
-            cwd: root,
-        });
-        return {
-            process: proc,
-            initialization: { storagePath: path.join(__dirname, ".intelephense") },
-        };
-    },
-};
-export const CSharpServer = {
-    id: "csharp",
-    name: "csharp-ls",
-    extensions: [".cs"],
-    root: createRootDetector([".sln", ".csproj", ".slnx"]),
-    async spawn(root) {
-        const proc = await launchLSP("csharp-ls", [], { cwd: root });
-        return { process: proc };
-    },
-};
-export const FSharpServer = {
-    id: "fsharp",
-    name: "FSAutocomplete",
-    extensions: [".fs", ".fsi", ".fsx"],
-    root: createRootDetector([".sln", ".fsproj"]),
-    async spawn(root) {
-        const proc = await launchLSP("fsautocomplete", [], { cwd: root });
-        return { process: proc };
-    },
-};
-export const JavaServer = {
-    id: "java",
-    name: "JDT Language Server",
-    extensions: [".java"],
-    root: createRootDetector(["pom.xml", "build.gradle", ".classpath"]),
-    async spawn(root) {
-        // JDTLS requires special handling - paths to launcher jar
-        const jdtlsPath = process.env.JDTLS_PATH || "jdtls";
-        const proc = await launchLSP(jdtlsPath, [], { cwd: root });
-        return { process: proc };
-    },
-};
-export const KotlinServer = {
-    id: "kotlin",
-    name: "Kotlin Language Server",
-    extensions: [".kt", ".kts"],
-    root: createRootDetector(["build.gradle.kts", "build.gradle", "pom.xml"]),
-    async spawn(root) {
-        const proc = await launchLSP("kotlin-language-server", [], { cwd: root });
-        return { process: proc };
-    },
-};
-export const SwiftServer = {
-    id: "swift",
-    name: "SourceKit-LSP",
-    extensions: [".swift"],
-    root: createRootDetector(["Package.swift"]),
-    async spawn(root) {
-        const proc = await launchLSP("sourcekit-lsp", [], { cwd: root });
-        return { process: proc };
-    },
-};
-export const DartServer = {
-    id: "dart",
-    name: "Dart Analysis Server",
-    extensions: [".dart"],
-    root: createRootDetector(["pubspec.yaml"]),
-    async spawn(root) {
-        const proc = await launchLSP("dart", ["language-server", "--protocol=lsp"], {
-            cwd: root,
-        });
-        return { process: proc };
-    },
-};
-export const LuaServer = {
-    id: "lua",
-    name: "Lua Language Server",
-    extensions: [".lua"],
-    root: createRootDetector([".luarc.json", ".luacheckrc"]),
-    async spawn(root) {
-        const proc = await launchLSP("lua-language-server", [], { cwd: root });
-        return { process: proc };
-    },
-};
-export const CppServer = {
-    id: "cpp",
-    name: "clangd",
-    extensions: [".c", ".cpp", ".cc", ".cxx", ".h", ".hpp"],
-    root: createRootDetector([
-        "compile_commands.json",
-        ".clangd",
-        "CMakeLists.txt",
-        "Makefile",
-    ]),
-    async spawn(root) {
-        const proc = await launchLSP("clangd", ["--background-index"], {
-            cwd: root,
-        });
-        return { process: proc };
-    },
-};
-export const ZigServer = {
-    id: "zig",
-    name: "ZLS",
-    extensions: [".zig", ".zon"],
-    root: createRootDetector(["build.zig"]),
-    async spawn(root) {
-        const proc = await launchLSP("zls", [], { cwd: root });
-        return { process: proc };
-    },
-};
-export const HaskellServer = {
-    id: "haskell",
-    name: "Haskell Language Server",
-    extensions: [".hs", ".lhs"],
-    root: createRootDetector(["stack.yaml", "cabal.project", "*.cabal"]),
-    async spawn(root) {
-        const proc = await launchLSP("haskell-language-server-wrapper", ["--lsp"], {
-            cwd: root,
-        });
-        return { process: proc };
-    },
-};
-export const ElixirServer = {
-    id: "elixir",
-    name: "ElixirLS",
-    extensions: [".ex", ".exs"],
-    root: createRootDetector(["mix.exs"]),
-    async spawn(root) {
-        const proc = await launchLSP("elixir-ls", [], { cwd: root });
-        return { process: proc };
-    },
-};
-export const GleamServer = {
-    id: "gleam",
-    name: "Gleam LSP",
-    extensions: [".gleam"],
-    root: createRootDetector(["gleam.toml"]),
-    async spawn(root) {
-        const proc = await launchLSP("gleam", ["lsp"], { cwd: root });
-        return { process: proc };
-    },
-};
-export const OCamlServer = {
-    id: "ocaml",
-    name: "ocamllsp",
-    extensions: [".ml", ".mli"],
-    root: createRootDetector(["dune-project", "opam"]),
-    async spawn(root) {
-        const proc = await launchLSP("ocamllsp", [], { cwd: root });
-        return { process: proc };
-    },
-};
-export const ClojureServer = {
-    id: "clojure",
-    name: "Clojure LSP",
-    extensions: [".clj", ".cljs", ".cljc", ".edn"],
-    root: createRootDetector(["deps.edn", "project.clj"]),
-    async spawn(root) {
-        const proc = await launchLSP("clojure-lsp", [], { cwd: root });
-        return { process: proc };
-    },
-};
-export const TerraformServer = {
-    id: "terraform",
-    name: "Terraform LSP",
-    extensions: [".tf", ".tfvars"],
-    root: createRootDetector([".terraform.lock.hcl"]),
-    async spawn(root) {
-        const proc = await launchLSP("terraform-ls", ["serve"], { cwd: root });
-        return { process: proc };
-    },
-};
-export const NixServer = {
-    id: "nix",
-    name: "nixd",
-    extensions: [".nix"],
-    root: createRootDetector(["flake.nix"]),
-    async spawn(root) {
-        const proc = await launchLSP("nixd", [], { cwd: root });
-        return { process: proc };
-    },
-};
-export const BashServer = {
-    id: "bash",
-    name: "Bash Language Server",
-    extensions: [".sh", ".bash", ".zsh"],
-    root: async () => process.cwd(),
-    async spawn() {
-        const cwd = process.cwd();
-        const proc = await spawnWithInteractiveInstall("bash", "bash-language-server", ["start"], { cwd }, async () => await launchLSP("bash-language-server", ["start"], {}));
-        return proc ? { process: proc } : undefined;
-    },
-};
-export const DockerServer = {
-    id: "docker",
-    name: "Dockerfile Language Server",
-    extensions: [".dockerfile", "Dockerfile"],
-    root: async () => process.cwd(),
-    async spawn() {
-        // Use npx since it's not auto-installed
-        const proc = await launchViaPackageManager("dockerfile-language-server-nodejs", ["--stdio"], {});
-        return { process: proc };
-    },
-};
-export const YamlServer = {
-    id: "yaml",
-    name: "YAML Language Server",
-    extensions: [".yaml", ".yml"],
-    root: async () => process.cwd(),
-    async spawn() {
-        const cwd = process.cwd();
-        const proc = await spawnWithInteractiveInstall("yaml", "yaml-language-server", ["--stdio"], { cwd }, async () => await launchLSP("yaml-language-server", ["--stdio"], {}));
-        return proc ? { process: proc } : undefined;
-    },
-};
-export const JsonServer = {
-    id: "json",
-    name: "VSCode JSON Language Server",
-    extensions: [".json", ".jsonc"],
-    root: async () => process.cwd(),
-    async spawn() {
-        const cwd = process.cwd();
-        const proc = await spawnWithInteractiveInstall("json", "vscode-json-language-server", ["--stdio"], { cwd }, async () => await launchLSP("vscode-json-language-server", ["--stdio"], {}));
-        return proc ? { process: proc } : undefined;
-    },
-};
-export const PrismaServer = {
-    id: "prisma",
-    name: "Prisma Language Server",
-    extensions: [".prisma"],
-    root: createRootDetector(["prisma/schema.prisma"]),
-    async spawn(root) {
-        // Use npx since it's not auto-installed
-        const proc = await launchViaPackageManager("@prisma/language-server", ["--stdio"], { cwd: root });
-        return { process: proc };
-    },
-};
-// --- Web Framework & Styling Servers ---
-export const VueServer = {
-    id: "vue",
-    name: "Vue Language Server",
-    extensions: [".vue"],
-    root: createRootDetector([
-        "package-lock.json",
-        "bun.lockb",
-        "bun.lock",
-        "pnpm-lock.yaml",
-        "yarn.lock",
-    ]),
-    async spawn(root) {
-        // Use npx since it's not auto-installed
-        const proc = await launchViaPackageManager("@vue/language-server", ["--stdio"], {
-            cwd: root,
-        });
-        return { process: proc };
-    },
-};
-export const SvelteServer = {
-    id: "svelte",
-    name: "Svelte Language Server",
-    extensions: [".svelte"],
-    root: createRootDetector([
-        "package-lock.json",
-        "bun.lockb",
-        "bun.lock",
-        "pnpm-lock.yaml",
-        "yarn.lock",
-    ]),
-    async spawn(root) {
-        // Use npx since it's not auto-installed
-        const proc = await launchViaPackageManager("svelte-language-server", ["--stdio"], { cwd: root });
-        return { process: proc };
-    },
-};
-export const ESLintServer = {
-    id: "eslint",
-    name: "ESLint Language Server",
-    extensions: [".js", ".jsx", ".vue", ".svelte"], // Note: .ts/.tsx handled by TypeScript LSP + Biome
-    root: createRootDetector([
-        ".eslintrc",
-        ".eslintrc.json",
-        ".eslintrc.js",
-        "eslint.config.js",
-        "eslint.config.mjs",
-        "package.json",
-    ]),
-    async spawn(root) {
-        // Try via package manager (npx) since it's not auto-installed
-        try {
-            const proc = await launchViaPackageManager("vscode-eslint-language-server", ["--stdio"], { cwd: root });
-            return { process: proc };
-        }
-        catch {
-            // Fall back to global install message
-            console.error("[lsp] ESLint Language Server not found. Install: npm install -g vscode-langservers-extracted");
-            return undefined;
-        }
-    },
-};
-export const CssServer = {
-    id: "css",
-    name: "CSS Language Server",
-    extensions: [".css", ".scss", ".sass", ".less"],
-    root: async () => process.cwd(),
-    async spawn() {
-        // Use npx since it's not auto-installed
-        const proc = await launchViaPackageManager("vscode-css-languageserver", ["--stdio"], {});
-        return { process: proc };
-    },
-};
-// --- Registry ---
-export const LSP_SERVERS = [
-    TypeScriptServer,
-    PythonServer,
-    GoServer,
-    RustServer,
-    RubyServer,
-    PHPServer,
-    CSharpServer,
-    FSharpServer,
-    JavaServer,
-    KotlinServer,
-    SwiftServer,
-    DartServer,
-    LuaServer,
-    CppServer,
-    ZigServer,
-    HaskellServer,
-    ElixirServer,
-    GleamServer,
-    OCamlServer,
-    ClojureServer,
-    TerraformServer,
-    NixServer,
-    BashServer,
-    DockerServer,
-    YamlServer,
-    JsonServer,
-    PrismaServer,
-    // Web frameworks & styling
-    VueServer,
-    SvelteServer,
-    ESLintServer,
-    CssServer,
-];
-/**
- * Get server for a file extension
- */
-export function getServerForExtension(ext) {
-    return LSP_SERVERS.find((server) => server.extensions.includes(ext));
-}
-/**
- * Get server by ID
- */
-export function getServerById(id) {
-    return LSP_SERVERS.find((server) => server.id === id);
-}
-/**
- * Get all servers for a file (may have multiple matches)
- */
-export function getServersForFile(filePath) {
-    const ext = path.extname(filePath).toLowerCase();
-    return LSP_SERVERS.filter((server) => server.extensions.includes(ext));
-}