pi-lens 2.2.9 → 3.0.0

package/clients/lsp/server.js

@@ -0,0 +1,615 @@
+/**
+ * LSP Server Definitions for pi-lens
+ *
+ * Defines 40+ language servers with:
+ * - Root detection (monorepo support)
+ * - Auto-installation strategies
+ * - Platform-specific handling
+ */
+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 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 spawnFn();
+            }
+            // User declined, return undefined to skip this LSP
+            return undefined;
+        }
+        // For other languages, throw with install instructions
+        throw error;
+    }
+}
+/**
+ * Walk up the tree looking for project root markers
+ */
+export function createRootDetector(includePatterns, excludePatterns) {
+    return async (file) => {
+        let currentDir = path.dirname(file);
+        const root = path.parse(currentDir).root;
+        while (currentDir !== root) {
+            // Check exclude patterns first
+            if (excludePatterns) {
+                for (const pattern of excludePatterns) {
+                    const checkPath = path.join(currentDir, pattern);
+                    try {
+                        const stat = await import("node:fs/promises").then((fs) => fs.stat(checkPath));
+                        if (stat)
+                            return undefined; // Excluded
+                    }
+                    catch {
+                        /* not found */
+                    }
+                }
+            }
+            // Check include patterns
+            for (const pattern of includePatterns) {
+                const checkPath = path.join(currentDir, pattern);
+                try {
+                    const stat = await import("node:fs/promises").then((fs) => fs.stat(checkPath));
+                    if (stat)
+                        return currentDir;
+                }
+                catch {
+                    /* not found */
+                }
+            }
+            currentDir = path.dirname(currentDir);
+        }
+        return undefined;
+    };
+}
+// --- 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",
+    ], [".pi-lens"]),
+    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 = 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",
+    ], [".pi-lens"]),
+    async spawn(root) {
+        const env = await getToolEnvironment();
+        const proc = 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 import("node:fs/promises").then((fs) => 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"], [".pi-lens"]),
+    async spawn(root) {
+        const proc = await spawnWithInteractiveInstall("go", "gopls", [], { cwd: root }, () => launchLSP("gopls", [], { cwd: root }));
+        return proc ? { process: proc } : undefined;
+    },
+};
+export const RustServer = {
+    id: "rust",
+    name: "rust-analyzer",
+    extensions: [".rs"],
+    root: createRootDetector(["Cargo.toml", "Cargo.lock"], [".pi-lens"]),
+    async spawn(root) {
+        const proc = await spawnWithInteractiveInstall("rust", "rust-analyzer", [], { cwd: root }, () => launchLSP("rust-analyzer", [], { cwd: root }));
+        return proc ? { process: proc } : undefined;
+    },
+};
+export const RubyServer = {
+    id: "ruby",
+    name: "Ruby LSP",
+    extensions: [".rb", ".rake", ".gemspec", ".ru"],
+    root: createRootDetector(["Gemfile", ".ruby-version"], [".pi-lens"]),
+    async spawn(root) {
+        // Try ruby-lsp first, fall back to solargraph
+        try {
+            const proc = launchLSP("ruby-lsp", [], { cwd: root });
+            return { process: proc };
+        }
+        catch {
+            const proc = launchViaPackageManager("solargraph", ["stdio"], {
+                cwd: root,
+            });
+            return { process: proc };
+        }
+    },
+};
+export const PHPServer = {
+    id: "php",
+    name: "Intelephense",
+    extensions: [".php"],
+    root: createRootDetector(["composer.json", "composer.lock"], [".pi-lens"]),
+    async spawn(root) {
+        const proc = 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"], [".pi-lens"]),
+    async spawn(root) {
+        const proc = launchLSP("csharp-ls", [], { cwd: root });
+        return { process: proc };
+    },
+};
+export const FSharpServer = {
+    id: "fsharp",
+    name: "FSAutocomplete",
+    extensions: [".fs", ".fsi", ".fsx"],
+    root: createRootDetector([".sln", ".fsproj"], [".pi-lens"]),
+    async spawn(root) {
+        const proc = 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"], [".pi-lens"]),
+    async spawn(root) {
+        // JDTLS requires special handling - paths to launcher jar
+        const jdtlsPath = process.env.JDTLS_PATH || "jdtls";
+        const proc = 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"], [".pi-lens"]),
+    async spawn(root) {
+        const proc = launchLSP("kotlin-language-server", [], { cwd: root });
+        return { process: proc };
+    },
+};
+export const SwiftServer = {
+    id: "swift",
+    name: "SourceKit-LSP",
+    extensions: [".swift"],
+    root: createRootDetector(["Package.swift"], [".pi-lens"]),
+    async spawn(root) {
+        const proc = launchLSP("sourcekit-lsp", [], { cwd: root });
+        return { process: proc };
+    },
+};
+export const DartServer = {
+    id: "dart",
+    name: "Dart Analysis Server",
+    extensions: [".dart"],
+    root: createRootDetector(["pubspec.yaml"], [".pi-lens"]),
+    async spawn(root) {
+        const proc = 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"], [".pi-lens"]),
+    async spawn(root) {
+        const proc = 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 = launchLSP("clangd", ["--background-index"], { cwd: root });
+        return { process: proc };
+    },
+};
+export const ZigServer = {
+    id: "zig",
+    name: "ZLS",
+    extensions: [".zig", ".zon"],
+    root: createRootDetector(["build.zig"], [".pi-lens"]),
+    async spawn(root) {
+        const proc = 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"], [".pi-lens"]),
+    async spawn(root) {
+        const proc = 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"], [".pi-lens"]),
+    async spawn(root) {
+        const proc = launchLSP("elixir-ls", [], { cwd: root });
+        return { process: proc };
+    },
+};
+export const GleamServer = {
+    id: "gleam",
+    name: "Gleam LSP",
+    extensions: [".gleam"],
+    root: createRootDetector(["gleam.toml"], [".pi-lens"]),
+    async spawn(root) {
+        const proc = launchLSP("gleam", ["lsp"], { cwd: root });
+        return { process: proc };
+    },
+};
+export const OCamlServer = {
+    id: "ocaml",
+    name: "ocamllsp",
+    extensions: [".ml", ".mli"],
+    root: createRootDetector(["dune-project", "opam"], [".pi-lens"]),
+    async spawn(root) {
+        const proc = 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"], [".pi-lens"]),
+    async spawn(root) {
+        const proc = launchLSP("clojure-lsp", [], { cwd: root });
+        return { process: proc };
+    },
+};
+export const TerraformServer = {
+    id: "terraform",
+    name: "Terraform LSP",
+    extensions: [".tf", ".tfvars"],
+    root: createRootDetector([".terraform.lock.hcl"], [".pi-lens"]),
+    async spawn(root) {
+        const proc = launchLSP("terraform-ls", ["serve"], { cwd: root });
+        return { process: proc };
+    },
+};
+export const NixServer = {
+    id: "nix",
+    name: "nixd",
+    extensions: [".nix"],
+    root: createRootDetector(["flake.nix"], [".pi-lens"]),
+    async spawn(root) {
+        const proc = 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 }, () => 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 = 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 }, () => 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-languageserver", ["--stdio"], { cwd }, () => launchLSP("vscode-json-languageserver", ["--stdio"], {}));
+        return proc ? { process: proc } : undefined;
+    },
+};
+export const PrismaServer = {
+    id: "prisma",
+    name: "Prisma Language Server",
+    extensions: [".prisma"],
+    root: createRootDetector(["prisma/schema.prisma"], [".pi-lens"]),
+    async spawn(root) {
+        // Use npx since it's not auto-installed
+        const proc = 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",
+    ], [".pi-lens"]),
+    async spawn(root) {
+        // Use npx since it's not auto-installed
+        const proc = 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",
+    ], [".pi-lens"]),
+    async spawn(root) {
+        // Use npx since it's not auto-installed
+        const proc = 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 = 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 = 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));
+}