`05e93ba`

feat: add LSP server auto-install panel

Add UI panel for discovering and installing language servers.
Detects missing servers based on file types and offers one-click
installation via npm, pip, cargo, or system package managers.

Authored by

espadonne 5 months ago

SHA: 05e93ba1df8d74e32de9d39621cec9e97a05663f
Parents: 69345bd
Tree: 779426c

1 changed file

Status	File	+	-
A	`src/lsp/server_manager.rs`	760	0

src/lsp/server_manager.rsadded

++//! LSP Server Manager
++//!
++//! Detects available language servers and helps users install them.
++//!
++//! Note: Some fields are for planned UI features.
++#![allow(dead_code)]
++
++use std::collections::HashSet;
++use std::process::Command;
++use std::sync::mpsc::{self, Receiver, Sender};
++use std::thread;
++
++/// Result of an install operation
++pub struct InstallResult {
++    pub server_index: usize,
++    pub server_name: String,
++    pub check_cmd: String,
++    pub success: bool,
++    pub message: String,
++}
++
++/// A known language server with installation instructions
++#[derive(Debug, Clone)]
++pub struct KnownServer {
++    pub name: &'static str,
++    pub language: &'static str,
++    pub check_cmd: &'static str,
++    pub install_cmd: &'static str,
++    pub description: &'static str,
++    pub is_installed: bool,
++}
++
++impl KnownServer {
++    const fn new(
++        name: &'static str,
++        language: &'static str,
++        check_cmd: &'static str,
++        install_cmd: &'static str,
++        description: &'static str,
++    ) -> Self {
++        Self {
++            name,
++            language,
++            check_cmd,
++            install_cmd,
++            description,
++            is_installed: false,
++        }
++    }
++}
++
++/// All known language servers
++pub fn get_known_servers() -> Vec<KnownServer> {
++    vec![
++        // Python
++        KnownServer::new(
++            "pyright",
++            "Python",
++            "pyright-langserver",
++            "pip install pyright",
++            "Python type checker and language server",
++        ),
++        KnownServer::new(
++            "ruff",
++            "Python",
++            "ruff",
++            "pip install ruff",
++            "Fast Python linter with LSP support",
++        ),
++        KnownServer::new(
++            "pylsp",
++            "Python",
++            "pylsp",
++            "pip install python-lsp-server",
++            "Python LSP server with plugin support",
++        ),
++        // Rust
++        KnownServer::new(
++            "rust-analyzer",
++            "Rust",
++            "rust-analyzer",
++            "rustup component add rust-analyzer",
++            "Rust language server",
++        ),
++        // C/C++
++        KnownServer::new(
++            "clangd",
++            "C/C++",
++            "clangd",
++            "# Install via package manager (apt/brew/etc)",
++            "C/C++ language server from LLVM",
++        ),
++        // Go
++        KnownServer::new(
++            "gopls",
++            "Go",
++            "gopls",
++            "go install golang.org/x/tools/gopls@latest",
++            "Go language server",
++        ),
++        // TypeScript/JavaScript
++        KnownServer::new(
++            "typescript-language-server",
++            "JS/TS",
++            "typescript-language-server",
++            "npm i -g typescript-language-server typescript",
++            "TypeScript and JavaScript language server",
++        ),
++        KnownServer::new(
++            "vtsls",
++            "JS/TS",
++            "vtsls",
++            "npm i -g @vtsls/language-server",
++            "Fast TypeScript language server",
++        ),
++        // Lua
++        KnownServer::new(
++            "lua-language-server",
++            "Lua",
++            "lua-language-server",
++            "# Install via package manager",
++            "Lua language server",
++        ),
++        // Ruby
++        KnownServer::new(
++            "solargraph",
++            "Ruby",
++            "solargraph",
++            "gem install solargraph",
++            "Ruby language server",
++        ),
++        // Java
++        KnownServer::new(
++            "jdtls",
++            "Java",
++            "jdtls",
++            "# Install via package manager",
++            "Eclipse JDT Language Server",
++        ),
++        // HTML/CSS/JSON
++        KnownServer::new(
++            "vscode-langservers",
++            "HTML/CSS/JSON",
++            "vscode-html-language-server",
++            "npm i -g vscode-langservers-extracted",
++            "HTML, CSS, JSON language servers",
++        ),
++        // Bash
++        KnownServer::new(
++            "bash-language-server",
++            "Bash",
++            "bash-language-server",
++            "npm i -g bash-language-server",
++            "Bash/Shell language server",
++        ),
++        // YAML
++        KnownServer::new(
++            "yaml-language-server",
++            "YAML",
++            "yaml-language-server",
++            "npm i -g yaml-language-server",
++            "YAML language server",
++        ),
++        // Docker
++        KnownServer::new(
++            "dockerfile-langserver",
++            "Docker",
++            "docker-langserver",
++            "npm i -g dockerfile-language-server-nodejs",
++            "Dockerfile language server",
++        ),
++        // Zig
++        KnownServer::new(
++            "zls",
++            "Zig",
++            "zls",
++            "# Install via package manager or zigtools",
++            "Zig language server",
++        ),
++        // Haskell
++        KnownServer::new(
++            "haskell-language-server",
++            "Haskell",
++            "haskell-language-server-wrapper",
++            "ghcup install hls",
++            "Haskell language server",
++        ),
++        // Terraform
++        KnownServer::new(
++            "terraform-ls",
++            "Terraform",
++            "terraform-ls",
++            "# Install from HashiCorp",
++            "Terraform language server",
++        ),
++        // Fortran
++        KnownServer::new(
++            "fortls",
++            "Fortran",
++            "fortls",
++            "pip install fortls",
++            "Fortran language server",
++        ),
++        // Elixir
++        KnownServer::new(
++            "elixir-ls",
++            "Elixir",
++            "elixir-ls",
++            "# Download from GitHub releases",
++            "Elixir language server",
++        ),
++        // Markdown
++        KnownServer::new(
++            "marksman",
++            "Markdown",
++            "marksman",
++            "# Install from GitHub releases or brew install marksman",
++            "Markdown language server with wiki-links support",
++        ),
++        // Kotlin
++        KnownServer::new(
++            "kotlin-language-server",
++            "Kotlin",
++            "kotlin-language-server",
++            "# Install from GitHub releases",
++            "Kotlin language server",
++        ),
++        // Swift
++        KnownServer::new(
++            "sourcekit-lsp",
++            "Swift",
++            "sourcekit-lsp",
++            "# Included with Xcode or Swift toolchain",
++            "Swift/Objective-C language server",
++        ),
++        // PHP
++        KnownServer::new(
++            "intelephense",
++            "PHP",
++            "intelephense",
++            "npm i -g intelephense",
++            "PHP language server",
++        ),
++        // C#
++        KnownServer::new(
++            "omnisharp",
++            "C#",
++            "OmniSharp",
++            "# Install from GitHub releases",
++            "C# language server",
++        ),
++        // Scala
++        KnownServer::new(
++            "metals",
++            "Scala",
++            "metals",
++            "# Install via coursier: cs install metals",
++            "Scala language server",
++        ),
++        // OCaml
++        KnownServer::new(
++            "ocamllsp",
++            "OCaml",
++            "ocamllsp",
++            "opam install ocaml-lsp-server",
++            "OCaml language server",
++        ),
++        // Nim
++        KnownServer::new(
++            "nimlangserver",
++            "Nim",
++            "nimlangserver",
++            "nimble install nimlangserver",
++            "Nim language server",
++        ),
++        // Julia
++        KnownServer::new(
++            "julia-lsp",
++            "Julia",
++            "julia",
++            "# Install LanguageServer.jl package in Julia",
++            "Julia language server",
++        ),
++        // Erlang
++        KnownServer::new(
++            "erlang_ls",
++            "Erlang",
++            "erlang_ls",
++            "# Install from GitHub releases",
++            "Erlang language server",
++        ),
++        // Clojure
++        KnownServer::new(
++            "clojure-lsp",
++            "Clojure",
++            "clojure-lsp",
++            "# Install from GitHub releases or brew",
++            "Clojure language server",
++        ),
++        // Perl
++        KnownServer::new(
++            "perlnavigator",
++            "Perl",
++            "perlnavigator",
++            "npm i -g perlnavigator-server",
++            "Perl language server",
++        ),
++        // R
++        KnownServer::new(
++            "r-languageserver",
++            "R",
++            "R",
++            "# Install languageserver package in R",
++            "R language server",
++        ),
++        // Dart/Flutter
++        KnownServer::new(
++            "dart-language-server",
++            "Dart",
++            "dart",
++            "# Included with Dart SDK",
++            "Dart language server",
++        ),
++        // Vue
++        KnownServer::new(
++            "vue-language-server",
++            "Vue",
++            "vue-language-server",
++            "npm i -g @vue/language-server",
++            "Vue.js language server",
++        ),
++        // Svelte
++        KnownServer::new(
++            "svelte-language-server",
++            "Svelte",
++            "svelteserver",
++            "npm i -g svelte-language-server",
++            "Svelte language server",
++        ),
++        // TOML
++        KnownServer::new(
++            "taplo",
++            "TOML",
++            "taplo",
++            "cargo install taplo-cli --features lsp",
++            "TOML language server",
++        ),
++        // Nix
++        KnownServer::new(
++            "nil",
++            "Nix",
++            "nil",
++            "nix profile install nixpkgs#nil",
++            "Nix language server",
++        ),
++        // GraphQL
++        KnownServer::new(
++            "graphql-lsp",
++            "GraphQL",
++            "graphql-lsp",
++            "npm i -g graphql-language-service-cli",
++            "GraphQL language server",
++        ),
++        // SQL
++        KnownServer::new(
++            "sqls",
++            "SQL",
++            "sqls",
++            "go install github.com/sqls-server/sqls@latest",
++            "SQL language server",
++        ),
++        // LaTeX
++        KnownServer::new(
++            "texlab",
++            "LaTeX",
++            "texlab",
++            "# Install from GitHub releases or cargo install texlab",
++            "LaTeX language server",
++        ),
++        // CMake
++        KnownServer::new(
++            "cmake-language-server",
++            "CMake",
++            "cmake-language-server",
++            "pip install cmake-language-server",
++            "CMake language server",
++        ),
++        // D
++        KnownServer::new(
++            "serve-d",
++            "D",
++            "serve-d",
++            "# Install from GitHub releases",
++            "D language server",
++        ),
++        // V
++        KnownServer::new(
++            "v-analyzer",
++            "V",
++            "v-analyzer",
++            "# Install from GitHub releases",
++            "V language server",
++        ),
++        // Odin
++        KnownServer::new(
++            "ols",
++            "Odin",
++            "ols",
++            "# Install from GitHub releases",
++            "Odin language server",
++        ),
++        // F#
++        KnownServer::new(
++            "fsautocomplete",
++            "F#",
++            "fsautocomplete",
++            "dotnet tool install -g fsautocomplete",
++            "F# language server",
++        ),
++        // Groovy
++        KnownServer::new(
++            "groovy-language-server",
++            "Groovy",
++            "groovy-language-server",
++            "# Install from GitHub releases",
++            "Groovy language server",
++        ),
++    ]
++}
++
++/// Check if a command exists in PATH
++pub fn check_command_exists(cmd: &str) -> bool {
++    if cmd.is_empty() {
++        return false;
++    }
++
++    Command::new("which")
++        .arg(cmd)
++        .stdout(std::process::Stdio::null())
++        .stderr(std::process::Stdio::null())
++        .status()
++        .map(|s| s.success())
++        .unwrap_or(false)
++}
++
++/// Detect which servers are installed
++pub fn detect_installed_servers() -> Vec<KnownServer> {
++    let mut servers = get_known_servers();
++    for server in &mut servers {
++        server.is_installed = check_command_exists(server.check_cmd);
++    }
++    servers
++}
++
++/// Sanitize a string for display - remove ANSI escape codes and control characters
++fn sanitize_for_display(s: &str) -> String {
++    let mut result = String::new();
++    let mut chars = s.chars().peekable();
++
++    while let Some(c) = chars.next() {
++        // Skip ANSI escape sequences (ESC [ ... m and similar)
++        if c == '\x1b' {
++            // Skip until we hit a letter (end of escape sequence)
++            while let Some(&next) = chars.peek() {
++                chars.next();
++                if next.is_ascii_alphabetic() {
++                    break;
++                }
++            }
++            continue;
++        }
++
++        // Skip other control characters except space
++        if c.is_control() {
++            if c == '\n' || c == '\t' {
++                result.push(' '); // Replace newlines/tabs with space
++            }
++            continue;
++        }
++
++        result.push(c);
++    }
++
++    // Collapse multiple spaces
++    let mut prev_space = false;
++    let collapsed: String = result.chars().filter(|&c| {
++        if c == ' ' {
++            if prev_space {
++                return false;
++            }
++            prev_space = true;
++        } else {
++            prev_space = false;
++        }
++        true
++    }).collect();
++
++    collapsed.trim().to_string()
++}
++
++/// Run an install command
++pub fn run_install_command(cmd: &str) -> Result<String, String> {
++    // Skip comments
++    if cmd.starts_with('#') {
++        return Err("Manual installation required. See instructions.".to_string());
++    }
++
++    let output = Command::new("sh")
++        .arg("-c")
++        .arg(cmd)
++        .output()
++        .map_err(|e| format!("Failed to run command: {}", e))?;
++
++    if output.status.success() {
++        Ok(String::from_utf8_lossy(&output.stdout).to_string())
++    } else {
++        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
++        Err(sanitize_for_display(&stderr))
++    }
++}
++
++/// LSP Server Manager Panel state
++pub struct ServerManagerPanel {
++    pub visible: bool,
++    pub servers: Vec<KnownServer>,
++    pub selected_index: usize,
++    pub scroll_offset: usize,
++    pub confirm_mode: bool,
++    pub confirm_index: usize,
++    /// Set of server indices currently being installed
++    pub installing_indices: HashSet<usize>,
++    pub status_message: Option<String>,
++    /// Show manual install info dialog
++    pub manual_info_mode: bool,
++    pub manual_info_index: usize,
++    /// Text that was copied to clipboard (for status message)
++    pub copied_to_clipboard: bool,
++    /// Channel to receive install completion results
++    install_rx: Option<Receiver<InstallResult>>,
++    install_tx: Option<Sender<InstallResult>>,
++}
++
++impl Default for ServerManagerPanel {
++    fn default() -> Self {
++        Self::new()
++    }
++}
++
++impl ServerManagerPanel {
++    pub fn new() -> Self {
++        let (tx, rx) = mpsc::channel();
++        Self {
++            visible: false,
++            servers: Vec::new(),
++            selected_index: 0,
++            scroll_offset: 0,
++            confirm_mode: false,
++            confirm_index: 0,
++            installing_indices: HashSet::new(),
++            status_message: None,
++            manual_info_mode: false,
++            manual_info_index: 0,
++            copied_to_clipboard: false,
++            install_rx: Some(rx),
++            install_tx: Some(tx),
++        }
++    }
++
++    /// Check if a specific server is currently being installed
++    pub fn is_installing(&self, index: usize) -> bool {
++        self.installing_indices.contains(&index)
++    }
++
++    /// Check if any installs are in progress
++    pub fn has_active_installs(&self) -> bool {
++        !self.installing_indices.is_empty()
++    }
++
++    /// Poll for completed installs (non-blocking)
++    /// Returns true if there was an update (caller should re-render)
++    pub fn poll_installs(&mut self) -> bool {
++        let rx = match &self.install_rx {
++            Some(rx) => rx,
++            None => return false,
++        };
++
++        let mut had_update = false;
++
++        // Drain all available results
++        while let Ok(result) = rx.try_recv() {
++            had_update = true;
++            self.installing_indices.remove(&result.server_index);
++
++            if result.success {
++                // Update the server's installed status
++                if let Some(server) = self.servers.get_mut(result.server_index) {
++                    // Re-check if it's actually installed now
++                    server.is_installed = check_command_exists(&result.check_cmd);
++                    if server.is_installed {
++                        self.status_message = Some(format!("✓ {} installed successfully", result.server_name));
++                    } else {
++                        self.status_message = Some(format!("Installed {} (may need shell restart)", result.server_name));
++                    }
++                }
++            } else {
++                self.status_message = Some(result.message);
++            }
++        }
++
++        had_update
++    }
++
++    pub fn show(&mut self) {
++        self.visible = true;
++        self.selected_index = 0;
++        self.scroll_offset = 0;
++        self.confirm_mode = false;
++        self.manual_info_mode = false;
++        self.status_message = None;
++        self.copied_to_clipboard = false;
++
++        // Detect servers if not already done
++        if self.servers.is_empty() {
++            self.refresh();
++        }
++    }
++
++    pub fn hide(&mut self) {
++        self.visible = false;
++        self.confirm_mode = false;
++        self.manual_info_mode = false;
++    }
++
++    pub fn refresh(&mut self) {
++        self.servers = detect_installed_servers();
++        self.status_message = Some("Server status refreshed".to_string());
++    }
++
++    pub fn move_up(&mut self) {
++        if self.selected_index > 0 {
++            self.selected_index -= 1;
++            if self.selected_index < self.scroll_offset {
++                self.scroll_offset = self.selected_index;
++            }
++        }
++    }
++
++    pub fn move_down(&mut self, max_visible: usize) {
++        if self.selected_index < self.servers.len().saturating_sub(1) {
++            self.selected_index += 1;
++            if self.selected_index >= self.scroll_offset + max_visible {
++                self.scroll_offset = self.selected_index - max_visible + 1;
++            }
++        }
++    }
++
++    pub fn enter_confirm_mode(&mut self) {
++        if self.selected_index < self.servers.len() {
++            let server = &self.servers[self.selected_index];
++            if server.is_installed {
++                self.status_message = Some(format!("{} is already installed", server.name));
++            } else if server.install_cmd.starts_with('#') {
++                // Show manual install info dialog
++                self.manual_info_mode = true;
++                self.manual_info_index = self.selected_index;
++                self.copied_to_clipboard = false;
++            } else {
++                self.confirm_mode = true;
++                self.confirm_index = self.selected_index;
++            }
++        }
++    }
++
++    pub fn cancel_confirm(&mut self) {
++        self.confirm_mode = false;
++        self.manual_info_mode = false;
++        self.status_message = None;
++        self.copied_to_clipboard = false;
++    }
++
++    /// Get the manual install info for clipboard
++    pub fn get_manual_install_text(&self) -> Option<String> {
++        self.servers.get(self.manual_info_index).map(|s| {
++            // Remove the leading "# " from the install command
++            let cmd = s.install_cmd.trim_start_matches('#').trim();
++            format!("{} - {}\n{}", s.name, s.language, cmd)
++        })
++    }
++
++    /// Mark that text was copied to clipboard
++    pub fn mark_copied(&mut self) {
++        self.copied_to_clipboard = true;
++        self.status_message = Some("Copied to clipboard".to_string());
++    }
++
++    /// Get the server for manual info dialog
++    pub fn manual_info_server(&self) -> Option<&KnownServer> {
++        self.servers.get(self.manual_info_index)
++    }
++
++    /// Start the install process - spawns a background thread
++    pub fn start_install(&mut self) {
++        if self.confirm_index >= self.servers.len() {
++            self.confirm_mode = false;
++            return;
++        }
++
++        // Don't allow installing the same server twice
++        if self.installing_indices.contains(&self.confirm_index) {
++            self.status_message = Some("Already installing...".to_string());
++            self.confirm_mode = false;
++            return;
++        }
++
++        let server = &self.servers[self.confirm_index];
++        let name = server.name.to_string();
++        let cmd = server.install_cmd.to_string();
++        let check_cmd = server.check_cmd.to_string();
++        let server_index = self.confirm_index;
++
++        // Mark as installing
++        self.installing_indices.insert(server_index);
++        self.confirm_mode = false;
++        self.status_message = Some(format!("Installing {}...", name));
++
++        // Clone the sender for the thread
++        let tx = match &self.install_tx {
++            Some(tx) => tx.clone(),
++            None => return,
++        };
++
++        // Spawn install thread
++        thread::spawn(move || {
++            let result = run_install_command(&cmd);
++            let (success, message) = match &result {
++                Ok(_) => (true, String::new()),
++                Err(e) => {
++                    let err_msg = if e.len() > 50 { format!("{}...", &e[..50]) } else { e.clone() };
++                    (false, format!("Install failed: {}", err_msg))
++                }
++            };
++
++            let _ = tx.send(InstallResult {
++                server_index,
++                server_name: name,
++                check_cmd,
++                success,
++                message,
++            });
++        });
++    }
++
++    pub fn selected_server(&self) -> Option<&KnownServer> {
++        self.servers.get(self.selected_index)
++    }
++
++    pub fn confirm_server(&self) -> Option<&KnownServer> {
++        self.servers.get(self.confirm_index)
++    }
++}