pi-lens 2.2.9 → 3.0.0

package/clients/lsp/lsp/server.js

@@ -0,0 +1,532 @@
+/**
+ * LSP Server Definitions for pi-lens
+ *
+ * Defines 40+ language servers with:
+ * - Root detection (monorepo support)
+ * - Auto-installation strategies
+ * - Platform-specific handling
+ */
+import path from "path";
+import { launchLSP, launchViaPackageManager } from "./launch.js";
+import { ensureTool, getToolEnvironment } from "../installer/index.js";
+// --- Root Detection Helpers ---
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * 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("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("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",
+    ]),
+    async spawn(root) {
+        const path = await import("path");
+        const fs = await import("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",
+    ]),
+    async spawn(root) {
+        // Ensure pyright is installed
+        const toolPath = await ensureTool("pyright");
+        if (!toolPath) {
+            console.error("[lsp] pyright not found and could not be installed");
+            return undefined;
+        }
+        const env = await getToolEnvironment();
+        const proc = launchLSP("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("fs/promises").then(fs => fs.access(pythonPath));
+                initialization.python = { 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 = launchLSP("gopls", [], { cwd: root });
+        return { process: proc };
+    },
+};
+export const RustServer = {
+    id: "rust",
+    name: "rust-analyzer",
+    extensions: [".rs"],
+    root: createRootDetector(["Cargo.toml", "Cargo.lock"]),
+    async spawn(root) {
+        const proc = launchLSP("rust-analyzer", [], { cwd: root });
+        return { process: proc };
+    },
+};
+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 = 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"]),
+    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"]),
+    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"]),
+    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"]),
+    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"]),
+    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"]),
+    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"]),
+    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"]),
+    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"]),
+    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"]),
+    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"]),
+    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"]),
+    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"]),
+    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"]),
+    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"]),
+    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"]),
+    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 proc = launchViaPackageManager("bash-language-server", ["start"], {});
+        return { process: proc };
+    },
+};
+export const DockerServer = {
+    id: "docker",
+    name: "Dockerfile Language Server",
+    extensions: [".dockerfile", "Dockerfile"],
+    root: async () => process.cwd(),
+    async spawn() {
+        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 proc = launchViaPackageManager("yaml-language-server", ["--stdio"], {});
+        return { process: proc };
+    },
+};
+export const JsonServer = {
+    id: "json",
+    name: "VSCode JSON Language Server",
+    extensions: [".json", ".jsonc"],
+    root: async () => process.cwd(),
+    async spawn() {
+        const proc = launchViaPackageManager("vscode-json-languageserver", ["--stdio"], {});
+        return { process: proc };
+    },
+};
+export const PrismaServer = {
+    id: "prisma",
+    name: "Prisma Language Server",
+    extensions: [".prisma"],
+    root: createRootDetector(["prisma/schema.prisma"]),
+    async spawn(root) {
+        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"]),
+    async spawn(root) {
+        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"]),
+    async spawn(root) {
+        const proc = launchViaPackageManager("svelte-language-server", ["--stdio"], { cwd: root });
+        return { process: proc };
+    },
+};
+export const ESLintServer = {
+    id: "eslint",
+    name: "ESLint Language Server",
+    extensions: [".js", ".jsx", ".ts", ".tsx", ".vue", ".svelte"],
+    root: createRootDetector([
+        ".eslintrc",
+        ".eslintrc.json",
+        ".eslintrc.js",
+        "eslint.config.js",
+        "eslint.config.mjs",
+        "package.json",
+    ]),
+    async spawn(root) {
+        const proc = launchViaPackageManager("vscode-eslint", ["--stdio"], { cwd: root });
+        return { process: proc };
+    },
+};
+export const CssServer = {
+    id: "css",
+    name: "CSS Language Server",
+    extensions: [".css", ".scss", ".sass", ".less"],
+    root: async () => process.cwd(),
+    async spawn() {
+        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));
+}

package/clients/lsp/lsp-index.js

@@ -0,0 +1,10 @@
+/**
+ * LSP Module for pi-lens
+ *
+ * Multi-language LSP client supporting 40+ languages.
+ */
+export * from "./client.js";
+export * from "./server.js";
+export * from "./language.js";
+export * from "./launch.js";
+export * from "./index.js";

package/clients/lsp/lsp-index.ts

@@ -0,0 +1,11 @@
+/**
+ * LSP Module for pi-lens
+ * 
+ * Multi-language LSP client supporting 40+ languages.
+ */
+
+export * from "./client.js";
+export * from "./server.js";
+export * from "./language.js";
+export * from "./launch.js";
+export * from "./index.js";

package/clients/lsp/path-utils.js

@@ -0,0 +1,48 @@
+/**
+ * Path utilities for pi-lens
+ *
+ * Handles cross-platform path normalization, particularly
+ * Windows case-insensitivity issues when using paths as Map keys.
+ */
+import { fileURLToPath, pathToFileURL } from "url";
+/**
+ * Normalize a file path for consistent Map key usage.
+ * On Windows: converts to lowercase (case-insensitive filesystem)
+ * On other platforms: returns path as-is (case-sensitive filesystem)
+ *
+ * This ensures that "C:\foo.ts" and "c:\foo.ts" resolve to the same key.
+ */
+export function normalizeFilePath(filePath) {
+    if (process.platform === "win32") {
+        return filePath.toLowerCase();
+    }
+    return filePath;
+}
+/**
+ * Convert a file:// URI to a normalized path.
+ * Handles URL decoding and Windows drive letter normalization.
+ */
+export function uriToPath(uri) {
+    try {
+        const filePath = fileURLToPath(uri);
+        return normalizeFilePath(filePath);
+    }
+    catch {
+        // Not a valid file:// URI, treat as plain path
+        return normalizeFilePath(uri);
+    }
+}
+/**
+ * Convert a path to a file:// URI.
+ * Does NOT normalize the path - URIs preserve original casing.
+ */
+export function pathToUri(filePath) {
+    return pathToFileURL(filePath).href;
+}
+/**
+ * Normalize a Map key lookup for file paths.
+ * Use this when getting/setting values in Maps that use file paths as keys.
+ */
+export function normalizeMapKey(filePath) {
+    return normalizeFilePath(filePath);
+}

package/clients/lsp/path-utils.ts

@@ -0,0 +1,52 @@
+/**
+ * Path utilities for pi-lens
+ * 
+ * Handles cross-platform path normalization, particularly
+ * Windows case-insensitivity issues when using paths as Map keys.
+ */
+
+import { fileURLToPath, pathToFileURL } from "url";
+
+/**
+ * Normalize a file path for consistent Map key usage.
+ * On Windows: converts to lowercase (case-insensitive filesystem)
+ * On other platforms: returns path as-is (case-sensitive filesystem)
+ * 
+ * This ensures that "C:\foo.ts" and "c:\foo.ts" resolve to the same key.
+ */
+export function normalizeFilePath(filePath: string): string {
+	if (process.platform === "win32") {
+		return filePath.toLowerCase();
+	}
+	return filePath;
+}
+
+/**
+ * Convert a file:// URI to a normalized path.
+ * Handles URL decoding and Windows drive letter normalization.
+ */
+export function uriToPath(uri: string): string {
+	try {
+		const filePath = fileURLToPath(uri);
+		return normalizeFilePath(filePath);
+	} catch {
+		// Not a valid file:// URI, treat as plain path
+		return normalizeFilePath(uri);
+	}
+}
+
+/**
+ * Convert a path to a file:// URI.
+ * Does NOT normalize the path - URIs preserve original casing.
+ */
+export function pathToUri(filePath: string): string {
+	return pathToFileURL(filePath).href;
+}
+
+/**
+ * Normalize a Map key lookup for file paths.
+ * Use this when getting/setting values in Maps that use file paths as keys.
+ */
+export function normalizeMapKey(filePath: string): string {
+	return normalizeFilePath(filePath);
+}