`5b2d0d0`

feat: integrate LSP into editor

Wire LSP functionality into the editor:
- F1: Hover information popup
- F2: Go to definition
- F3: Find references
- F4: Rename symbol
- Tab: Trigger/navigate completions
- Alt+M: Toggle LSP server manager panel

Add diagnostic rendering with underlines and gutter indicators.
Sync document changes to language servers on edit.

Authored by

espadonne 5 months ago

SHA: 5b2d0d05b90b873f247d192625b4bdfe26bfe473
Parents: 05e93ba
Tree: ab962b8

4 changed files

Status	File	+	-
M	`src/editor/state.rs`	913	25
M	`src/main.rs`	2	0
M	`src/render/screen.rs`	1084	22
M	`src/workspace/state.rs`	92	0

src/editor/state.rsmodified

1073 lines changed — click to load

  use crate::buffer::Buffer;
  use crate::input::{Key, Modifiers, Mouse, Button};
 +use crate::lsp::{CompletionItem, Diagnostic, HoverInfo, Location, ServerManagerPanel};
  use crate::render::{PaneBounds as RenderPaneBounds, PaneInfo, Screen, TabInfo};
  use crate::workspace::{PaneDirection, Tab, Workspace};
      GitCommit,
      /// Create a git tag
      GitTag,
 +    /// LSP rename symbol
 +    LspRename { path: String, line: u32, col: u32 },
 +}
++
 +/// LSP UI state
 +#[derive(Debug, Default)]
 +struct LspState {
 +    /// Current hover information to display
 +    hover: Option<HoverInfo>,
 +    /// Whether hover popup is visible
 +    hover_visible: bool,
 +    /// Current completion list
 +    completions: Vec<CompletionItem>,
 +    /// Selected completion index
 +    completion_index: usize,
 +    /// Whether completion popup is visible
 +    completion_visible: bool,
 +    /// Current diagnostics for the active file
 +    diagnostics: Vec<Diagnostic>,
 +    /// Go-to-definition results (for multi-result navigation)
 +    definition_locations: Vec<Location>,
 +    /// Pending request IDs (to match responses)
 +    pending_hover: Option<i64>,
 +    pending_completion: Option<i64>,
 +    pending_definition: Option<i64>,
 +    pending_references: Option<i64>,
 +    /// Last known buffer hash (to detect changes)
 +    last_buffer_hash: Option<u64>,
 +    /// Last file path that was synced to LSP
 +    last_synced_path: Option<PathBuf>,
+ }
  /// Main editor state
      prompt: PromptState,
      /// Last time we wrote backups
      last_backup: Instant,
 +    /// LSP-related UI state
 +    lsp_state: LspState,
 +    /// LSP server manager panel
 +    server_manager: ServerManagerPanel,
+ }
  impl Editor {
              escape_time,
              prompt: PromptState::None,
              last_backup: Instant::now(),
 +            lsp_state: LspState::default(),
 +            server_manager: ServerManagerPanel::new(),
          };
          // If there are backups, show restore prompt
          tab.panes[pane_idx].viewport_line = line;
+     }
 +    /// Get current viewport column (horizontal scroll offset)
 +    #[inline]
 +    fn viewport_col(&self) -> usize {
 +        let tab = self.workspace.active_tab();
 +        tab.panes[tab.active_pane].viewport_col
 +    }
++
 +    /// Set current viewport column (horizontal scroll offset)
 +    #[inline]
 +    fn set_viewport_col(&mut self, col: usize) {
 +        let tab = self.workspace.active_tab_mut();
 +        let pane_idx = tab.active_pane;
 +        tab.panes[pane_idx].viewport_col = col;
 +    }
++
      /// Get current filename
      #[inline]
      fn filename(&self) -> Option<PathBuf> {
          self.render()?;
          while self.running {
 -            // Block until an event is available (no busy polling)
 -            match event::read()? {
 -                Event::Key(key_event) => self.process_key(key_event)?,
 -                Event::Mouse(mouse_event) => self.process_mouse(mouse_event)?,
 -                Event::Resize(cols, rows) => {
 -                    self.screen.cols = cols;
 -                    self.screen.rows = rows;
 -                }
 -                _ => {}
 -            }
 +            // Track whether we need to re-render
 +            let mut needs_render = false;
 -            // Process any additional queued events before rendering
 -            while event::poll(Duration::from_millis(0))? {
 +            // Poll with a short timeout to allow LSP processing
 +            // This balances responsiveness with CPU usage
 +            if event::poll(Duration::from_millis(50))? {
                  match event::read()? {
                      Event::Key(key_event) => self.process_key(key_event)?,
                      Event::Mouse(mouse_event) => self.process_mouse(mouse_event)?,
+                     }
                      _ => {}
+                 }
 +                needs_render = true;
++
 +                // Process any additional queued events before rendering
 +                while event::poll(Duration::from_millis(0))? {
 +                    match event::read()? {
 +                        Event::Key(key_event) => self.process_key(key_event)?,
 +                        Event::Mouse(mouse_event) => self.process_mouse(mouse_event)?,
 +                        Event::Resize(cols, rows) => {
 +                            self.screen.cols = cols;
 +                            self.screen.rows = rows;
 +                        }
 +                        _ => {}
 +                    }
 +                }
 +            }
++
 +            // Process LSP messages from language servers
 +            if self.process_lsp_messages() {
 +                needs_render = true;
 +            }
++
 +            // Poll for completed server installations
 +            if self.server_manager.poll_installs() {
 +                needs_render = true;
+             }
              // Check if it's time to backup modified buffers
              self.maybe_backup();
 -            // Only render after processing events
 -            self.screen.refresh_size()?;
 -            self.render()?;
 +            // Only render if something changed
 +            if needs_render {
 +                self.screen.refresh_size()?;
 +                self.render()?;
 +            }
+         }
          self.screen.leave_raw_mode()?;
+         }
+     }
 +    /// Process LSP messages. Returns true if any messages were processed.
 +    fn process_lsp_messages(&mut self) -> bool {
 +        use crate::lsp::LspResponse;
++
 +        // Process pending messages from language servers
 +        self.workspace.lsp.process_messages();
++
 +        let mut had_response = false;
++
 +        // Handle any responses that came in
 +        while let Some(response) = self.workspace.lsp.poll_response() {
 +            had_response = true;
 +            match response {
 +                LspResponse::Completions(id, items) => {
 +                    if self.lsp_state.pending_completion == Some(id) {
 +                        self.lsp_state.completions = items;
 +                        self.lsp_state.completion_index = 0;
 +                        self.lsp_state.completion_visible = !self.lsp_state.completions.is_empty();
 +                        self.lsp_state.pending_completion = None;
 +                    }
 +                }
 +                LspResponse::Hover(id, info) => {
 +                    if self.lsp_state.pending_hover == Some(id) {
 +                        self.lsp_state.hover = info;
 +                        self.lsp_state.hover_visible = self.lsp_state.hover.is_some();
 +                        self.lsp_state.pending_hover = None;
 +                        if self.lsp_state.hover.is_none() {
 +                            self.message = Some("No hover info available".to_string());
 +                        }
 +                    }
 +                }
 +                LspResponse::Definition(id, locations) => {
 +                    if self.lsp_state.pending_definition == Some(id) {
 +                        self.lsp_state.definition_locations = locations.clone();
 +                        self.lsp_state.pending_definition = None;
 +                        // Jump to first definition
 +                        if let Some(loc) = locations.first() {
 +                            self.goto_location(loc);
 +                        } else {
 +                            self.message = Some("No definition found".to_string());
 +                        }
 +                    }
 +                }
 +                LspResponse::References(id, locations) => {
 +                    if self.lsp_state.pending_references == Some(id) {
 +                        self.lsp_state.pending_references = None;
 +                        if locations.is_empty() {
 +                            self.message = Some("No references found".to_string());
 +                        } else if locations.len() == 1 {
 +                            self.goto_location(&locations[0]);
 +                        } else {
 +                            // Multiple references - show count and go to first
 +                            self.message = Some(format!("Found {} references", locations.len()));
 +                            self.goto_location(&locations[0]);
 +                        }
 +                    }
 +                }
 +                LspResponse::Symbols(id, symbols) => {
 +                    // TODO: Show symbols panel
 +                    let _ = (id, symbols);
 +                }
 +                LspResponse::Formatting(id, edits) => {
 +                    // Apply formatting edits
 +                    let _ = (id, edits);
 +                    // TODO: Apply text edits to buffer
 +                }
 +                LspResponse::Rename(_id, workspace_edit) => {
 +                    // Apply rename edits across all affected files
 +                    let mut total_edits = 0;
 +                    let mut files_changed = 0;
++
 +                    for (uri, edits) in &workspace_edit.changes {
 +                        if let Some(path_str) = crate::lsp::uri_to_path(uri) {
 +                            // Check if we have this file open
 +                            let path = std::path::PathBuf::from(&path_str);
 +                            if let Some(tab_idx) = self.workspace.find_tab_by_path(&path) {
 +                                // Apply edits to the open buffer (in reverse order to preserve positions)
 +                                let mut sorted_edits = edits.clone();
 +                                sorted_edits.sort_by(|a, b| {
 +                                    // Sort by start position, descending
 +                                    b.range.start.line.cmp(&a.range.start.line)
 +                                        .then(b.range.start.character.cmp(&a.range.start.character))
 +                                });
++
 +                                for edit in sorted_edits {
 +                                    self.workspace.apply_text_edit(tab_idx, &edit);
 +                                    total_edits += 1;
 +                                }
 +                                files_changed += 1;
 +                            } else {
 +                                // File not open - would need to open, edit, and save
 +                                self.message = Some(format!("Note: {} not open, skipped", path_str));
 +                            }
 +                        }
 +                    }
++
 +                    if total_edits > 0 {
 +                        self.message = Some(format!("Renamed: {} edits in {} file(s)", total_edits, files_changed));
 +                    } else {
 +                        self.message = Some("No rename edits to apply".to_string());
 +                    }
 +                }
 +                LspResponse::CodeActions(id, actions) => {
 +                    // TODO: Show code actions menu
 +                    let _ = (id, actions);
 +                }
 +                LspResponse::Error(id, message) => {
 +                    // Clear any pending state for this request
 +                    if self.lsp_state.pending_completion == Some(id) {
 +                        self.lsp_state.pending_completion = None;
 +                    }
 +                    if self.lsp_state.pending_hover == Some(id) {
 +                        self.lsp_state.pending_hover = None;
 +                    }
 +                    if self.lsp_state.pending_definition == Some(id) {
 +                        self.lsp_state.pending_definition = None;
 +                    }
 +                    if self.lsp_state.pending_references == Some(id) {
 +                        self.lsp_state.pending_references = None;
 +                    }
 +                    // Optionally show error
 +                    if !message.is_empty() {
 +                        self.message = Some(format!("LSP: {}", message));
 +                    }
 +                }
 +            }
 +        }
++
 +        // Update diagnostics for current file
 +        if let Some(path) = self.filename() {
 +            let path_str = path.to_string_lossy();
 +            self.lsp_state.diagnostics = self.workspace.lsp.get_diagnostics(&path_str);
 +        }
++
 +        // Sync document changes to LSP if buffer has changed
 +        self.sync_document_to_lsp();
++
 +        had_response
 +    }
++
 +    /// Sync document changes to LSP server
 +    fn sync_document_to_lsp(&mut self) {
 +        let current_path = self.filename();
 +        let current_hash = self.buffer().content_hash();
++
 +        // Check if we switched files
 +        let file_changed = current_path != self.lsp_state.last_synced_path;
++
 +        // Check if buffer content changed
 +        let content_changed = self.lsp_state.last_buffer_hash != Some(current_hash);
++
 +        if file_changed {
 +            // Close the old document if we had one open
 +            if let Some(ref old_path) = self.lsp_state.last_synced_path {
 +                let old_path_str = old_path.to_string_lossy();
 +                let _ = self.workspace.lsp.close_document(&old_path_str);
 +            }
++
 +            // Open the new document
 +            if let Some(ref path) = current_path {
 +                let tab = self.workspace.active_tab();
 +                let pane = &tab.panes[tab.active_pane];
 +                let buffer_entry = &tab.buffers[pane.buffer_idx];
++
 +                let full_path = if buffer_entry.is_orphan {
 +                    path.clone()
 +                } else {
 +                    self.workspace.root.join(path)
 +                };
 +                let path_str = full_path.to_string_lossy();
 +                let content = self.buffer().contents();
 +                let _ = self.workspace.lsp.open_document(&path_str, &content);
 +            }
++
 +            self.lsp_state.last_synced_path = current_path;
 +            self.lsp_state.last_buffer_hash = Some(current_hash);
 +        } else if content_changed {
 +            // Content changed - send didChange notification
 +            if let Some(ref path) = current_path {
 +                let tab = self.workspace.active_tab();
 +                let pane = &tab.panes[tab.active_pane];
 +                let buffer_entry = &tab.buffers[pane.buffer_idx];
++
 +                let full_path = if buffer_entry.is_orphan {
 +                    path.clone()
 +                } else {
 +                    self.workspace.root.join(path)
 +                };
 +                let path_str = full_path.to_string_lossy();
 +                let content = self.buffer().contents();
 +                let _ = self.workspace.lsp.document_changed(&path_str, &content);
 +            }
++
 +            self.lsp_state.last_buffer_hash = Some(current_hash);
 +        }
 +    }
++
 +    /// Navigate to an LSP location
 +    fn goto_location(&mut self, location: &Location) {
 +        use crate::lsp::uri_to_path;
++
 +        if let Some(path) = uri_to_path(&location.uri) {
 +            let path_buf = PathBuf::from(&path);
 +            // Open the file if not already open
 +            if let Err(e) = self.workspace.open_file(&path_buf) {
 +                self.message = Some(format!("Failed to open {}: {}", path, e));
 +                return;
 +            }
++
 +            // Move cursor to the location
 +            let line = location.range.start.line as usize;
 +            let col = location.range.start.character as usize;
++
 +            self.cursors_mut().collapse_to_primary();
 +            self.cursor_mut().line = line.min(self.buffer().line_count().saturating_sub(1));
 +            self.cursor_mut().col = col.min(self.buffer().line_len(self.cursor().line));
 +            self.cursor_mut().desired_col = self.cursor().col;
 +            self.cursor_mut().clear_selection();
 +            self.scroll_to_cursor();
 +        }
 +    }
++
 +    /// Get the full path to the current file
 +    fn current_file_path(&self) -> Option<PathBuf> {
 +        let tab = self.workspace.active_tab();
 +        let pane = &tab.panes[tab.active_pane];
 +        let buffer_entry = &tab.buffers[pane.buffer_idx];
++
 +        buffer_entry.path.as_ref().map(|p| {
 +            if buffer_entry.is_orphan {
 +                p.clone()
 +            } else {
 +                self.workspace.root.join(p)
 +            }
 +        })
 +    }
++
 +    /// LSP: Go to definition
 +    fn lsp_goto_definition(&mut self) {
 +        if let Some(path) = self.current_file_path() {
 +            let path_str = path.to_string_lossy().to_string();
 +            let line = self.cursor().line as u32;
 +            let col = self.cursor().col as u32;
++
 +            match self.workspace.lsp.request_definition(&path_str, line, col) {
 +                Ok(id) => {
 +                    self.lsp_state.pending_definition = Some(id);
 +                    self.message = Some("Finding definition...".to_string());
 +                }
 +                Err(e) => {
 +                    self.message = Some(format!("LSP error: {}", e));
 +                }
 +            }
 +        } else {
 +            self.message = Some("No file open".to_string());
 +        }
 +    }
++
 +    /// LSP: Find references
 +    fn lsp_find_references(&mut self) {
 +        if let Some(path) = self.current_file_path() {
 +            let path_str = path.to_string_lossy().to_string();
 +            let line = self.cursor().line as u32;
 +            let col = self.cursor().col as u32;
++
 +            match self.workspace.lsp.request_references(&path_str, line, col, true) {
 +                Ok(id) => {
 +                    self.lsp_state.pending_references = Some(id);
 +                    self.message = Some("Finding references...".to_string());
 +                }
 +                Err(e) => {
 +                    self.message = Some(format!("LSP error: {}", e));
 +                }
 +            }
 +        } else {
 +            self.message = Some("No file open".to_string());
 +        }
 +    }
++
 +    /// LSP: Show hover information
 +    fn lsp_hover(&mut self) {
 +        if let Some(path) = self.current_file_path() {
 +            let path_str = path.to_string_lossy().to_string();
 +            let line = self.cursor().line as u32;
 +            let col = self.cursor().col as u32;
++
 +            match self.workspace.lsp.request_hover(&path_str, line, col) {
 +                Ok(id) => {
 +                    self.lsp_state.pending_hover = Some(id);
 +                    self.message = Some("Loading hover info...".to_string());
 +                }
 +                Err(e) => {
 +                    self.message = Some(format!("LSP error: {}", e));
 +                }
 +            }
 +        } else {
 +            self.message = Some("No file open".to_string());
 +        }
 +    }
++
 +    /// LSP: Trigger completion
 +    fn lsp_complete(&mut self) {
 +        if let Some(path) = self.current_file_path() {
 +            let path_str = path.to_string_lossy().to_string();
 +            let line = self.cursor().line as u32;
 +            let col = self.cursor().col as u32;
++
 +            match self.workspace.lsp.request_completions(&path_str, line, col) {
 +                Ok(id) => {
 +                    self.lsp_state.pending_completion = Some(id);
 +                    self.message = Some("Loading completions...".to_string());
 +                }
 +                Err(e) => {
 +                    self.message = Some(format!("LSP error: {}", e));
 +                }
 +            }
 +        } else {
 +            self.message = Some("No file open".to_string());
 +        }
 +    }
++
 +    /// Toggle the LSP server manager panel
 +    fn toggle_server_manager(&mut self) {
 +        if self.server_manager.visible {
 +            self.server_manager.hide();
 +        } else {
 +            self.server_manager.show();
 +        }
 +    }
++
 +    /// Handle key input when server manager panel is visible
 +    fn handle_server_manager_key(&mut self, key: Key, mods: Modifiers) -> Result<()> {
 +        let max_visible = 10; // Should match screen.rs
++
 +        // Alt+M toggles the panel closed
 +        if key == Key::Char('m') && mods.alt {
 +            self.server_manager.hide();
 +            return Ok(());
 +        }
++
 +        // Handle confirm mode
 +        if self.server_manager.confirm_mode {
 +            match key {
 +                Key::Char('y') | Key::Char('Y') => {
 +                    // Start install in background thread (non-blocking)
 +                    self.server_manager.start_install();
 +                }
 +                Key::Char('n') | Key::Char('N') | Key::Escape => {
 +                    self.server_manager.cancel_confirm();
 +                }
 +                _ => {}
 +            }
 +            return Ok(());
 +        }
++
 +        // Handle manual info mode
 +        if self.server_manager.manual_info_mode {
 +            match key {
 +                Key::Char('c') | Key::Char('C') => {
 +                    // Copy install instructions to clipboard
 +                    if let Some(text) = self.server_manager.get_manual_install_text() {
 +                        if let Some(ref mut clip) = self.clipboard {
 +                            if clip.set_text(&text).is_ok() {
 +                                self.server_manager.mark_copied();
 +                            } else {
 +                                self.server_manager.status_message = Some("Failed to copy".to_string());
 +                            }
 +                        } else {
 +                            // Fall back to internal clipboard
 +                            self.internal_clipboard = text;
 +                            self.server_manager.mark_copied();
 +                        }
 +                    }
 +                }
 +                Key::Escape | Key::Char('q') => {
 +                    self.server_manager.cancel_confirm();
 +                }
 +                _ => {}
 +            }
 +            return Ok(());
 +        }
++
 +        // Normal panel navigation
 +        match key {
 +            Key::Up | Key::Char('k') => {
 +                self.server_manager.move_up();
 +            }
 +            Key::Down | Key::Char('j') => {
 +                self.server_manager.move_down(max_visible);
 +            }
 +            Key::Enter => {
 +                self.server_manager.enter_confirm_mode();
 +            }
 +            Key::Char('r') | Key::Char('R') => {
 +                self.server_manager.refresh();
 +            }
 +            Key::Escape | Key::Char('q') => {
 +                self.server_manager.hide();
 +            }
 +            _ => {}
 +        }
++
 +        Ok(())
 +    }
++
 +    /// LSP: Rename symbol - opens prompt for new name
 +    fn lsp_rename(&mut self) {
 +        if let Some(path) = self.current_file_path() {
 +            let path_str = path.to_string_lossy().to_string();
 +            let line = self.cursor().line as u32;
 +            let col = self.cursor().col as u32;
++
 +            // Get the word under cursor to show in prompt
 +            let buffer = self.buffer();
 +            let cursor = self.cursor();
 +            let current_word = if let Some(line_slice) = buffer.line(cursor.line) {
 +                let line_text: String = line_slice.chars().collect();
 +                let mut start = cursor.col;
 +                let mut end = cursor.col;
++
 +                // Find word boundaries
 +                while start > 0 {
 +                    let ch = line_text.chars().nth(start - 1).unwrap_or(' ');
 +                    if ch.is_alphanumeric() || ch == '_' {
 +                        start -= 1;
 +                    } else {
 +                        break;
 +                    }
 +                }
 +                while end < line_text.len() {
 +                    let ch = line_text.chars().nth(end).unwrap_or(' ');
 +                    if ch.is_alphanumeric() || ch == '_' {
 +                        end += 1;
 +                    } else {
 +                        break;
 +                    }
 +                }
 +                line_text[start..end].to_string()
 +            } else {
 +                String::new()
 +            };
++
 +            self.prompt = PromptState::TextInput {
 +                label: "Rename to: ".to_string(),
 +                buffer: current_word.clone(),
 +                action: TextInputAction::LspRename { path: path_str, line, col },
 +            };
 +            self.message = Some(format!("Rename '{}' to: {}", current_word, current_word));
 +        } else {
 +            self.message = Some("No file open".to_string());
 +        }
 +    }
++
 +    /// Accept the currently selected completion and insert it
 +    fn accept_completion(&mut self) {
 +        if self.lsp_state.completions.is_empty() {
 +            return;
 +        }
++
 +        let completion = self.lsp_state.completions[self.lsp_state.completion_index].clone();
++
 +        // Determine the text to insert
 +        let insert_text = if let Some(ref text_edit) = completion.text_edit {
 +            // Use text edit if provided (includes range to replace)
 +            // For now, just use the new text - proper range replacement would be more complex
 +            text_edit.new_text.clone()
 +        } else if let Some(ref insert) = completion.insert_text {
 +            insert.clone()
 +        } else {
 +            completion.label.clone()
 +        };
++
 +        // Find the start of the word being completed (walk back from cursor)
 +        let buffer = self.buffer();
 +        let cursor = self.cursor();
 +        let line_idx = cursor.line;
 +        let cursor_col = cursor.col;
 +        let mut word_start = cursor_col;
++
 +        // Walk back to find word start (alphanumeric or underscore)
 +        if let Some(line_slice) = buffer.line(line_idx) {
 +            let line_text: String = line_slice.chars().collect();
 +            while word_start > 0 {
 +                let prev_char = line_text.chars().nth(word_start - 1).unwrap_or(' ');
 +                if prev_char.is_alphanumeric() || prev_char == '_' {
 +                    word_start -= 1;
 +                } else {
 +                    break;
 +                }
 +            }
 +        }
++
 +        // Delete the partial word and insert completion
 +        if word_start < cursor_col {
 +            // Select from word start to cursor
 +            let cursor = self.cursor_mut();
 +            cursor.anchor_line = cursor.line;
 +            cursor.anchor_col = word_start;
 +            cursor.selecting = true;
 +        }
++
 +        // Insert the completion text (this will replace selection if any)
 +        for ch in insert_text.chars() {
 +            self.insert_char(ch);
 +        }
++
 +        // Clear completion state
 +        self.lsp_state.completion_visible = false;
 +        self.lsp_state.completions.clear();
 +        self.lsp_state.completion_index = 0;
 +    }
++
      /// Process a key event, handling ESC as potential Alt prefix
      fn process_key(&mut self, key_event: KeyEvent) -> Result<()> {
          use crossterm::event::KeyCode;
+             }
              Mouse::ScrollDown { .. } => {
                  // Scroll down 3 lines
 -                let max_viewport = self.buffer().line_count().saturating_sub(1);
 +                // Calculate visible rows (accounting for tab bar, gap, and status bar)
 +                let top_offset = if self.workspace.tabs.len() > 1 { 1 } else { 0 };
 +                let visible_rows = (self.screen.rows as usize).saturating_sub(2 + top_offset);
 +                // Max viewport is when the last line is at the bottom of visible area
 +                let max_viewport = self.buffer().line_count().saturating_sub(visible_rows).max(0);
                  let new_line = (self.viewport_line() + 3).min(max_viewport);
                  self.set_viewport_line(new_line);
+             }
                  top_offset,
+             )
          } else {
 -            // Single pane - use simpler render path
 +            // Single pane - use simpler render path with syntax highlighting
              let pane = &tab.panes[tab.active_pane];
              let buffer_entry = &tab.buffers[pane.buffer_idx];
              let buffer = &buffer_entry.buffer;
              let cursors = &pane.cursors;
              let viewport_line = pane.viewport_line;
 +            let viewport_col = pane.viewport_col;
              let is_modified = buffer_entry.is_modified();
 +            let highlighter = &buffer_entry.highlighter;
              // Find matching bracket for primary cursor
              let cursor = cursors.primary();
              let bracket_match = buffer.find_matching_bracket(cursor.line, cursor.col);
 -            self.screen.render_with_offset(
 +            self.screen.render_with_syntax(
                  buffer,
                  cursors,
                  viewport_line,
 +                viewport_col,
                  filename,
                  self.message.as_deref(),
                  bracket_match,
                  fuss_width,
                  top_offset,
                  is_modified,
 -            )
 +                highlighter,
 +            )?;
++
 +            // Render diagnostics markers in gutter
 +            if !self.lsp_state.diagnostics.is_empty() {
 +                self.screen.render_diagnostics_gutter(
 +                    &self.lsp_state.diagnostics,
 +                    viewport_line,
 +                    fuss_width,
 +                    top_offset,
 +                )?;
 +            }
++
 +            // Render completion popup if visible
 +            if self.lsp_state.completion_visible && !self.lsp_state.completions.is_empty() {
 +                let cursor = cursors.primary();
 +                // Calculate cursor screen position
 +                let cursor_row = (cursor.line.saturating_sub(viewport_line)) as u16 + top_offset;
 +                let line_num_width = self.screen.line_number_width(buffer.line_count()) as u16;
 +                let cursor_col = cursor.col as u16 + line_num_width + 1;
++
 +                self.screen.render_completion_popup(
 +                    &self.lsp_state.completions,
 +                    self.lsp_state.completion_index,
 +                    cursor_row,
 +                    cursor_col,
 +                    fuss_width,
 +                )?;
 +            }
++
 +            // Render hover popup if visible
 +            if self.lsp_state.hover_visible {
 +                if let Some(ref hover) = self.lsp_state.hover {
 +                    let cursor = cursors.primary();
 +                    let cursor_row = (cursor.line.saturating_sub(viewport_line)) as u16 + top_offset;
 +                    let line_num_width = self.screen.line_number_width(buffer.line_count()) as u16;
 +                    let cursor_col = cursor.col as u16 + line_num_width + 1;
++
 +                    self.screen.render_hover_popup(
 +                        hover,
 +                        cursor_row,
 +                        cursor_col,
 +                        fuss_width,
 +                    )?;
 +                }
 +            }
++
 +            // Render server manager panel if visible (on top of everything)
 +            if self.server_manager.visible {
 +                self.screen.render_server_manager_panel(&self.server_manager)?;
 +            }
++
 +            // After all overlays are rendered, reposition cursor to the correct location
 +            // (overlays may have moved the terminal cursor position)
 +            let cursor = cursors.primary();
 +            let cursor_row = (cursor.line.saturating_sub(viewport_line)) as u16 + top_offset;
 +            let line_num_width = self.screen.line_number_width(buffer.line_count()) as u16;
 +            // Account for horizontal scroll offset
 +            let cursor_screen_col = fuss_width + line_num_width + 1 + (cursor.col.saturating_sub(viewport_col)) as u16;
 +            self.screen.show_cursor_at(cursor_screen_col, cursor_row)?;
++
 +            Ok(())
+         }
+     }
              return self.handle_prompt_key(key);
+         }
 +        // Handle server manager panel when visible
 +        if self.server_manager.visible {
 +            return self.handle_server_manager_key(key, mods);
 +        }
++
          // Clear message on any key
          self.message = None;
              return self.handle_fuss_key(key, mods);
+         }
 +        // Handle completion popup navigation when visible
 +        if self.lsp_state.completion_visible {
 +            match (&key, &mods) {
 +                // Navigate up in completion list
 +                (Key::Up, _) => {
 +                    if self.lsp_state.completion_index > 0 {
 +                        self.lsp_state.completion_index -= 1;
 +                    } else {
 +                        // Wrap to bottom
 +                        self.lsp_state.completion_index = self.lsp_state.completions.len().saturating_sub(1);
 +                    }
 +                    return Ok(());
 +                }
 +                // Navigate down in completion list
 +                (Key::Down, _) => {
 +                    if self.lsp_state.completion_index < self.lsp_state.completions.len().saturating_sub(1) {
 +                        self.lsp_state.completion_index += 1;
 +                    } else {
 +                        // Wrap to top
 +                        self.lsp_state.completion_index = 0;
 +                    }
 +                    return Ok(());
 +                }
 +                // Select completion with Enter or Tab
 +                (Key::Enter, _) | (Key::Tab, _) => {
 +                    self.accept_completion();
 +                    return Ok(());
 +                }
 +                // Dismiss completion popup with Escape
 +                (Key::Escape, _) => {
 +                    self.lsp_state.completion_visible = false;
 +                    self.lsp_state.completions.clear();
 +                    return Ok(());
 +                }
 +                // Any other key dismisses popup and continues normally
 +                _ => {
 +                    self.lsp_state.completion_visible = false;
 +                    self.lsp_state.completions.clear();
 +                }
 +            }
 +        }
++
 +        // Dismiss hover popup on any key press
 +        if self.lsp_state.hover_visible {
 +            self.lsp_state.hover_visible = false;
 +            self.lsp_state.hover = None;
 +            // Let Escape just dismiss the popup without doing anything else
 +            if matches!(key, Key::Escape) {
 +                return Ok(());
 +            }
 +        }
++
          // Break undo group on any non-character key (movement, commands, etc.)
          // This ensures each "typing session" is its own undo unit
          let is_typing = matches!(
              // New tab: Alt+T
              (Key::Char('t'), Modifiers { alt: true, .. }) => self.workspace.new_tab(),
 +            // === LSP operations ===
 +            // Go to definition: F12
 +            (Key::F(12), Modifiers { shift: false, .. }) => self.lsp_goto_definition(),
 +            // Find references: Shift+F12
 +            (Key::F(12), Modifiers { shift: true, .. }) => self.lsp_find_references(),
 +            // Hover info: F1
 +            (Key::F(1), _) => self.lsp_hover(),
 +            // Code completion: Ctrl+Space
 +            (Key::Char(' '), Modifiers { ctrl: true, .. }) => self.lsp_complete(),
 +            // Rename: F2
 +            (Key::F(2), _) => self.lsp_rename(),
 +            // Server manager: Alt+M
 +            (Key::Char('m'), Modifiers { alt: true, .. }) => self.toggle_server_manager(),
++
              _ => {}
+         }
+     }
      fn select_word(&mut self) {
 -        // If no selection, select word at cursor
 -        // If already have selection, this could expand to next occurrence (future enhancement)
 +        // If primary cursor has a selection, find next occurrence and add cursor there
 +        if self.cursor().has_selection() {
 +            self.select_next_occurrence();
 +            return;
 +        }
++
 +        // No selection - select word at cursor
          if let Some(line_str) = self.buffer().line_str(self.cursor().line) {
              let chars: Vec<char> = line_str.chars().collect();
              let col = self.cursor().col.min(chars.len());
+         }
+     }
 +    /// Find the next occurrence of the selected text and add a cursor there
 +    fn select_next_occurrence(&mut self) {
 +        // Get the selected text from primary cursor
 +        let selected_text = {
 +            let cursor = self.cursor();
 +            if !cursor.has_selection() {
 +                return;
 +            }
 +            let (start, end) = cursor.selection().ordered();
 +            let buffer = self.buffer();
++
 +            // Extract selected text
 +            let mut text = String::new();
 +            for line_idx in start.line..=end.line {
 +                if let Some(line) = buffer.line_str(line_idx) {
 +                    let line_start = if line_idx == start.line { start.col } else { 0 };
 +                    let line_end = if line_idx == end.line { end.col } else { line.len() };
 +                    if line_start < line_end && line_end <= line.len() {
 +                        text.push_str(&line[line_start..line_end]);
 +                    }
 +                    if line_idx < end.line {
 +                        text.push('\n');
 +                    }
 +                }
 +            }
 +            text
 +        };
++
 +        if selected_text.is_empty() {
 +            return;
 +        }
++
 +        // Find the position to start searching from (after the last cursor with this selection)
 +        let search_start = {
 +            let cursors = self.cursors();
 +            let mut max_pos = (0usize, 0usize);
 +            for cursor in cursors.all() {
 +                if cursor.has_selection() {
 +                    let (_, end) = cursor.selection().ordered();
 +                    if (end.line, end.col) > max_pos {
 +                        max_pos = (end.line, end.col);
 +                    }
 +                }
 +            }
 +            max_pos
 +        };
++
 +        // Search for next occurrence
 +        let buffer = self.buffer();
 +        let line_count = buffer.line_count();
 +        let search_text = &selected_text;
++
 +        // Start searching from the line after the last selection end
 +        for line_idx in search_start.0..line_count {
 +            if let Some(line) = buffer.line_str(line_idx) {
 +                let start_col = if line_idx == search_start.0 { search_start.1 } else { 0 };
++
 +                // Search for the text in this line (only works for single-line selections for now)
 +                if !search_text.contains('\n') {
 +                    if let Some(found_col) = line[start_col..].find(search_text) {
 +                        let match_start = start_col + found_col;
 +                        let match_end = match_start + search_text.len();
++
 +                        // Add a new cursor with selection at this location
 +                        self.cursors_mut().add_with_selection(
 +                            line_idx,
 +                            match_end,
 +                            line_idx,
 +                            match_start,
 +                        );
 +                        return;
 +                    }
 +                }
 +            }
 +        }
++
 +        // Wrap around to beginning if not found
 +        for line_idx in 0..=search_start.0 {
 +            if let Some(line) = buffer.line_str(line_idx) {
 +                let end_col = if line_idx == search_start.0 {
 +                    // Don't search past where we started
 +                    search_start.1.saturating_sub(search_text.len())
 +                } else {
 +                    line.len()
 +                };
++
 +                if !search_text.contains('\n') {
 +                    if let Some(found_col) = line[..end_col].find(search_text) {
 +                        let match_start = found_col;
 +                        let match_end = match_start + search_text.len();
++
 +                        // Check if this position already has a cursor
 +                        let already_has_cursor = self.cursors().all().iter().any(|c| {
 +                            c.line == line_idx && c.col == match_end
 +                        });
++
 +                        if !already_has_cursor {
 +                            self.cursors_mut().add_with_selection(
 +                                line_idx,
 +                                match_end,
 +                                line_idx,
 +                                match_start,
 +                            );
 +                            return;
 +                        }
 +                    }
 +                }
 +            }
 +        }
++
 +        // No more occurrences found
 +        self.message = Some("No more occurrences".to_string());
 +    }
++
      // === Bracket/Quote Operations ===
      fn jump_to_matching_bracket(&mut self) {
      // === Viewport ===
      fn scroll_to_cursor(&mut self) {
 -        let visible_rows = self.screen.rows.saturating_sub(1) as usize;
 +        // Calculate top offset (tab bar takes 1 row if multiple tabs)
 +        let top_offset = if self.workspace.tabs.len() > 1 { 1 } else { 0 };
 +        // Vertical scrolling (2 rows reserved: gap + status bar, plus top_offset for tab bar)
 +        let visible_rows = (self.screen.rows as usize).saturating_sub(2 + top_offset);
          let cursor_line = self.cursor().line;
 -        let viewport = self.viewport_line();
 +        let viewport_line = self.viewport_line();
 -        if cursor_line < viewport {
 +        if cursor_line < viewport_line {
              self.set_viewport_line(cursor_line);
+         }
 -        if cursor_line >= viewport + visible_rows {
 +        if cursor_line >= viewport_line + visible_rows {
              self.set_viewport_line(cursor_line - visible_rows + 1);
+         }
++
 +        // Horizontal scrolling
 +        let line_num_width = self.screen.line_number_width(self.buffer().line_count());
 +        let fuss_width = if self.workspace.fuss.active {
 +            self.workspace.fuss.width(self.screen.cols)
 +        } else {
 +            0
 +        };
 +        // Available text columns = screen width - fuss sidebar - line numbers - 1 (separator)
 +        let visible_cols = (self.screen.cols as usize)
 +            .saturating_sub(fuss_width as usize)
 +            .saturating_sub(line_num_width + 1);
++
 +        let cursor_col = self.cursor().col;
 +        let viewport_col = self.viewport_col();
++
 +        // Keep some margin (3 chars) so cursor isn't right at the edge
 +        let margin = 3;
++
 +        if cursor_col < viewport_col {
 +            // Cursor is left of viewport - scroll left
 +            self.set_viewport_col(cursor_col.saturating_sub(margin));
 +        }
++
 +        if cursor_col >= viewport_col + visible_cols.saturating_sub(margin) {
 +            // Cursor is right of viewport - scroll right
 +            self.set_viewport_col(cursor_col.saturating_sub(visible_cols.saturating_sub(margin + 1)));
 +        }
+     }
      // === File operations ===
                  let (_, msg) = self.workspace.fuss.git_tag(buffer);
                  self.message = Some(msg);
+             }
 +            TextInputAction::LspRename { path, line, col } => {
 +                if buffer.is_empty() {
 +                    self.message = Some("Rename cancelled: empty name".to_string());
 +                    return;
 +                }
 +                match self.workspace.lsp.request_rename(&path, line, col, buffer) {
 +                    Ok(_id) => {
 +                        self.message = Some(format!("Renaming to '{}'...", buffer));
 +                        // Note: The actual rename edits will be applied when we receive
 +                        // the response and implement WorkspaceEdit handling
 +                    }
 +                    Err(e) => {
 +                        self.message = Some(format!("Rename failed: {}", e));
 +                    }
 +                }
 +            }
+         }
+     }

src/main.rsmodified

  mod editor;
  mod fuss;
  mod input;
 +mod lsp;
  mod render;
 +mod syntax;
  mod util;
  mod workspace;

src/render/screen.rsmodified

1220 lines changed — click to load

          KeyboardEnhancementFlags, PopKeyboardEnhancementFlags, PushKeyboardEnhancementFlags,
      },
      execute,
 -    style::{Color, Print, ResetColor, SetBackgroundColor, SetForegroundColor},
 +    style::{Attribute, Color, Print, ResetColor, SetAttribute, SetBackgroundColor, SetForegroundColor},
      terminal::{self, Clear, ClearType, EnterAlternateScreen, LeaveAlternateScreen},
  };
  use std::io::{stdout, Stdout, Write};
 +use unicode_width::UnicodeWidthStr;
  use crate::buffer::Buffer;
  use crate::editor::{Cursors, Position};
  use crate::fuss::VisibleItem;
 +use crate::lsp::{CompletionItem, Diagnostic, DiagnosticSeverity, HoverInfo, ServerManagerPanel};
 +use crate::syntax::{Highlighter, HighlightState, Token};
  // Editor color scheme (256-color palette)
  const BG_COLOR: Color = Color::AnsiValue(234);           // Off-black editor background
          Ok(())
+     }
 +    /// Position and show the hardware cursor at the given screen coordinates
 +    pub fn show_cursor_at(&mut self, col: u16, row: u16) -> Result<()> {
 +        execute!(self.stdout, MoveTo(col, row), Show)?;
 +        self.stdout.flush()?;
 +        Ok(())
 +    }
++
      #[allow(dead_code)]
      pub fn clear(&mut self) -> Result<()> {
          execute!(self.stdout, Clear(ClearType::All))?;
              .map(|(i, c)| (c.line, c.col, i == primary_idx)) // (line, col, is_primary)
              .collect();
 -        // Reserve 1 row for status bar
 -        let text_rows = self.rows.saturating_sub(1) as usize;
 +        // Reserve 2 rows: 1 for gap above status bar, 1 for status bar itself
 +        let text_rows = self.rows.saturating_sub(2) as usize;
          // Draw text area
          for row in 0..text_rows {
+             }
+         }
 +        // Render the gap row (empty line between text and status bar)
 +        let gap_row = text_rows as u16;
 +        execute!(
 +            self.stdout,
 +            MoveTo(0, gap_row),
 +            SetBackgroundColor(BG_COLOR),
 +            Clear(ClearType::UntilNewLine),
 +            ResetColor
 +        )?;
++
          // Status bar
          self.render_status_bar(buffer, cursors, filename, message)?;
          is_current_line: bool,
          bracket_col: Option<usize>,
          secondary_cursors: &[usize],
 +    ) -> Result<()> {
 +        // Call the syntax-aware version with no tokens
 +        self.render_line_with_syntax(
 +            line,
 +            line_idx,
 +            max_cols,
 +            selections,
 +            is_current_line,
 +            bracket_col,
 +            secondary_cursors,
 +            &[],
 +        )
 +    }
++
 +    fn render_line_with_syntax(
 +        &mut self,
 +        line: &str,
 +        line_idx: usize,
 +        max_cols: usize,
 +        selections: &[(Position, Position)],
 +        is_current_line: bool,
 +        bracket_col: Option<usize>,
 +        secondary_cursors: &[usize],
 +        tokens: &[Token],
      ) -> Result<()> {
          let chars: Vec<char> = line.chars().take(max_cols).collect();
          let line_bg = if is_current_line { CURRENT_LINE_BG } else { BG_COLOR };
+             }
+         }
 +        // Helper to find token at character position
 +        let get_token_at = |col: usize| -> Option<&Token> {
 +            tokens.iter().find(|t| col >= t.start && col < t.end)
 +        };
++
          // Render character by character for precise highlighting
          for (col, ch) in chars.iter().enumerate() {
              let in_selection = sel_ranges.iter().any(|(s, e)| col >= *s && col < *e);
              let is_bracket_match = bracket_col == Some(col);
              let is_secondary_cursor = secondary_cursors.contains(&col);
 -            // Determine background color
 +            // Determine background color (priority: selection > cursor > bracket > syntax/line)
              let bg = if in_selection {
                  Color::Blue
              } else if is_secondary_cursor {
 -                Color::Magenta  // Use magenta for better visibility
 +                Color::Magenta
              } else if is_bracket_match {
                  BRACKET_MATCH_BG
              } else {
                  line_bg
              };
 -            // Determine foreground color
 -            let fg = if in_selection {
 -                Color::White
 +            // Determine foreground color and boldness
 +            let (fg, bold) = if in_selection {
 +                (Color::White, false)
              } else if is_secondary_cursor {
 -                Color::White  // White text on magenta bg
 +                (Color::White, false)
 +            } else if let Some(token) = get_token_at(col) {
 +                (token.token_type.color(), token.token_type.bold())
              } else {
 -                default_fg
 +                (default_fg, false)
              };
 -            execute!(
 -                self.stdout,
 -                SetBackgroundColor(bg),
 -                SetForegroundColor(fg),
 -                Print(ch)
 -            )?;
 +            // Apply styling
 +            if bold {
 +                execute!(
 +                    self.stdout,
 +                    SetBackgroundColor(bg),
 +                    SetForegroundColor(fg),
 +                    SetAttribute(Attribute::Bold),
 +                    Print(ch),
 +                    SetAttribute(Attribute::NoBold),
 +                )?;
 +            } else {
 +                execute!(
 +                    self.stdout,
 +                    SetBackgroundColor(bg),
 +                    SetForegroundColor(fg),
 +                    Print(ch)
 +                )?;
 +            }
+         }
          // Reset to line background for rest of line
          execute!(self.stdout, SetBackgroundColor(line_bg), SetForegroundColor(default_fg))?;
          // Handle secondary cursors at end of line (past text content)
 -        // Find the rightmost secondary cursor past text
          let max_cursor_past_text = secondary_cursors.iter()
              .filter(|&&c| c >= chars.len())
              .max()
          if let Some(max_cursor) = max_cursor_past_text {
              if max_cursor < max_cols {
 -                // Fill spaces up to and including the cursor positions
                  for col in chars.len()..=max_cursor {
                      if secondary_cursors.contains(&col) {
                          execute!(
                          )?;
+                     }
+                 }
 -                // Reset for the rest of the line
                  execute!(self.stdout, SetBackgroundColor(line_bg), SetForegroundColor(default_fg))?;
+             }
+         }
          Ok(())
+     }
 -    fn line_number_width(&self, line_count: usize) -> usize {
 +    pub fn line_number_width(&self, line_count: usize) -> usize {
          let digits = if line_count == 0 {
          } else {
+     }
      /// Render the editor view with horizontal and vertical offsets (for fuss mode and tab bar)
 +    #[allow(dead_code)]
      pub fn render_with_offset(
          &mut self,
          buffer: &Buffer,
              .map(|(i, c)| (c.line, c.col, i == primary_idx))
              .collect();
 -        // Reserve 1 row for status bar, accounting for top offset
 -        let text_rows = self.rows.saturating_sub(1 + top_offset) as usize;
 +        // Reserve 2 rows: 1 for gap above status bar, 1 for status bar itself
 +        let text_rows = self.rows.saturating_sub(2 + top_offset) as usize;
          // Draw text area
          for row in 0..text_rows {
+             }
+         }
 +        // Render the gap row (empty line between text and status bar)
 +        let gap_row = text_rows as u16 + top_offset;
 +        execute!(
 +            self.stdout,
 +            MoveTo(left_offset, gap_row),
 +            SetBackgroundColor(BG_COLOR),
 +            Clear(ClearType::UntilNewLine),
 +            ResetColor
 +        )?;
++
          // Status bar
          self.render_status_bar_with_offset(cursors, filename, message, left_offset, is_modified)?;
          Ok(())
+     }
 +    /// Render the editor view with syntax highlighting
 +    pub fn render_with_syntax(
 +        &mut self,
 +        buffer: &Buffer,
 +        cursors: &Cursors,
 +        viewport_line: usize,
 +        viewport_col: usize,
 +        filename: Option<&str>,
 +        message: Option<&str>,
 +        bracket_match: Option<(usize, usize)>,
 +        left_offset: u16,
 +        top_offset: u16,
 +        is_modified: bool,
 +        highlighter: &Highlighter,
 +    ) -> Result<()> {
 +        execute!(self.stdout, Hide)?;
++
 +        let available_cols = self.cols.saturating_sub(left_offset) as usize;
 +        let line_num_width = self.line_number_width(buffer.line_count());
 +        let text_cols = available_cols.saturating_sub(line_num_width + 1);
++
 +        let primary = cursors.primary();
++
 +        // Adjust selections for horizontal scroll
 +        let selections: Vec<(Position, Position)> = cursors.all()
 +            .iter()
 +            .filter_map(|c| c.selection_bounds())
 +            .map(|(start, end)| {
 +                (
 +                    Position { line: start.line, col: start.col.saturating_sub(viewport_col) },
 +                    Position { line: end.line, col: end.col.saturating_sub(viewport_col) },
 +                )
 +            })
 +            .collect();
++
 +        let primary_idx = cursors.primary_index();
 +        // Adjust cursor positions for horizontal scroll
 +        let cursor_positions: Vec<(usize, usize, bool)> = cursors.all()
 +            .iter()
 +            .enumerate()
 +            .map(|(i, c)| (c.line, c.col.saturating_sub(viewport_col), i == primary_idx))
 +            .collect();
++
 +        // Reserve 2 rows: 1 for gap above status bar, 1 for status bar itself
 +        let text_rows = self.rows.saturating_sub(2 + top_offset) as usize;
++
 +        // Track multiline state across lines
 +        let mut highlight_state = HighlightState::default();
++
 +        // Pre-tokenize lines from start of buffer to viewport for correct multiline state
 +        // (In a production system, we'd cache this state per line)
 +        for line_idx in 0..viewport_line {
 +            if let Some(line) = buffer.line_str(line_idx) {
 +                let _ = highlighter.tokenize_line(&line, &mut highlight_state);
 +            }
 +        }
++
 +        // Draw text area with syntax highlighting
 +        for row in 0..text_rows {
 +            let line_idx = viewport_line + row;
 +            let is_current_line = line_idx == primary.line;
 +            execute!(self.stdout, MoveTo(left_offset, (row as u16) + top_offset))?;
++
 +            if line_idx < buffer.line_count() {
 +                let line_num_fg = if is_current_line {
 +                    CURRENT_LINE_NUM_COLOR
 +                } else {
 +                    LINE_NUM_COLOR
 +                };
 +                let line_bg = if is_current_line { CURRENT_LINE_BG } else { BG_COLOR };
++
 +                execute!(
 +                    self.stdout,
 +                    SetBackgroundColor(line_bg),
 +                    SetForegroundColor(line_num_fg),
 +                    Print(format!("{:>width$} ", line_idx + 1, width = line_num_width)),
 +                )?;
++
 +                if let Some(line) = buffer.line_str(line_idx) {
 +                    // Tokenize this line
 +                    let tokens = highlighter.tokenize_line(&line, &mut highlight_state);
++
 +                    // Apply horizontal scroll to bracket match column
 +                    // Only show if the bracket is in the visible area
 +                    let bracket_col = bracket_match
 +                        .filter(|(bl, bc)| *bl == line_idx && *bc >= viewport_col)
 +                        .map(|(_, bc)| bc - viewport_col);
++
 +                    let secondary_cursors: Vec<usize> = cursor_positions.iter()
 +                        .filter(|(l, _, is_primary)| *l == line_idx && !*is_primary)
 +                        .map(|(_, c, _)| *c)
 +                        .collect();
++
 +                    // Skip characters before viewport_col
 +                    let display_line: String = line.chars().skip(viewport_col).collect();
++
 +                    // Adjust tokens for horizontal scroll
 +                    let adjusted_tokens: Vec<Token> = tokens.iter()
 +                        .filter_map(|t| {
 +                            let new_start = t.start.saturating_sub(viewport_col);
 +                            let new_end = t.end.saturating_sub(viewport_col);
 +                            if t.end <= viewport_col {
 +                                None // Token is entirely before viewport
 +                            } else {
 +                                Some(Token {
 +                                    start: new_start,
 +                                    end: new_end,
 +                                    token_type: t.token_type,
 +                                })
 +                            }
 +                        })
 +                        .collect();
++
 +                    self.render_line_with_syntax(
 +                        &display_line,
 +                        line_idx,
 +                        text_cols,
 +                        &selections,
 +                        is_current_line,
 +                        bracket_col,
 +                        &secondary_cursors,
 +                        &adjusted_tokens,
 +                    )?;
 +                }
++
 +                execute!(
 +                    self.stdout,
 +                    SetBackgroundColor(line_bg),
 +                    Clear(ClearType::UntilNewLine),
 +                    ResetColor
 +                )?;
 +            } else {
 +                execute!(
 +                    self.stdout,
 +                    SetBackgroundColor(BG_COLOR),
 +                    SetForegroundColor(Color::DarkBlue),
 +                    Print(format!("{:>width$} ", "~", width = line_num_width)),
 +                    Clear(ClearType::UntilNewLine),
 +                    ResetColor
 +                )?;
 +            }
 +        }
++
 +        // Render the gap row (empty line between text and status bar)
 +        let gap_row = text_rows as u16 + top_offset;
 +        execute!(
 +            self.stdout,
 +            MoveTo(left_offset, gap_row),
 +            SetBackgroundColor(BG_COLOR),
 +            Clear(ClearType::UntilNewLine),
 +            ResetColor
 +        )?;
++
 +        // Status bar
 +        self.render_status_bar_with_offset(cursors, filename, message, left_offset, is_modified)?;
++
 +        // Position hardware cursor (adjusted for horizontal scroll)
 +        let cursor_row = (primary.line.saturating_sub(viewport_line) as u16) + top_offset;
 +        let cursor_col = left_offset as usize + line_num_width + 1 + primary.col.saturating_sub(viewport_col);
 +        execute!(
 +            self.stdout,
 +            MoveTo(cursor_col as u16, cursor_row),
 +            Show
 +        )?;
++
 +        self.stdout.flush()?;
 +        Ok(())
 +    }
++
      fn render_status_bar_with_offset(
          &mut self,
          cursors: &Cursors,
          self.stdout.flush()?;
          Ok(())
+     }
++
 +    /// Render a completion popup at the given screen position
 +    pub fn render_completion_popup(
 +        &mut self,
 +        completions: &[CompletionItem],
 +        selected_index: usize,
 +        cursor_row: u16,
 +        cursor_col: u16,
 +        left_offset: u16,
 +    ) -> Result<()> {
 +        if completions.is_empty() {
 +            return Ok(());
 +        }
++
 +        // Popup settings
 +        let max_items = 10.min(completions.len());
 +        let popup_width = 40;
 +        let popup_bg = Color::AnsiValue(237);
 +        let selected_bg = Color::AnsiValue(24);
 +        let item_fg = Color::AnsiValue(252);
 +        let detail_fg = Color::AnsiValue(244);
++
 +        // Position popup below cursor, or above if not enough space
 +        let popup_row = if cursor_row + (max_items as u16) + 2 < self.rows {
 +            cursor_row + 1
 +        } else {
 +            cursor_row.saturating_sub(max_items as u16 + 1)
 +        };
++
 +        let popup_col = (cursor_col + left_offset).min(self.cols.saturating_sub(popup_width as u16));
++
 +        // Calculate scroll offset to keep selection visible
 +        let scroll_offset = if selected_index >= max_items {
 +            selected_index - max_items + 1
 +        } else {
 +            0
 +        };
++
 +        // Draw border and items
 +        for (i, item) in completions.iter().skip(scroll_offset).take(max_items).enumerate() {
 +            let row = popup_row + i as u16;
 +            let is_selected = i + scroll_offset == selected_index;
 +            let bg = if is_selected { selected_bg } else { popup_bg };
++
 +            execute!(
 +                self.stdout,
 +                MoveTo(popup_col, row),
 +                SetBackgroundColor(bg),
 +                SetForegroundColor(item_fg),
 +            )?;
++
 +            // Format: [icon] label   detail
 +            let icon = item.kind.map(|k| k.icon()).unwrap_or(" ");
 +            let label = &item.label;
 +            let detail = item.detail.as_deref().unwrap_or("");
++
 +            let label_width = popup_width - 4;
 +            let truncated_label: String = if label.len() > label_width - 2 {
 +                format!("{}...", &label[..label_width - 5])
 +            } else {
 +                label.clone()
 +            };
++
 +            write!(self.stdout, " {} ", icon)?;
 +            write!(self.stdout, "{:<width$}", truncated_label, width = label_width - detail.len().min(15))?;
++
 +            if !detail.is_empty() {
 +                execute!(self.stdout, SetForegroundColor(detail_fg))?;
 +                let truncated_detail: String = if detail.len() > 12 {
 +                    format!("{}...", &detail[..9])
 +                } else {
 +                    detail.to_string()
 +                };
 +                write!(self.stdout, "{}", truncated_detail)?;
 +            }
++
 +            // Clear to popup width
 +            execute!(self.stdout, ResetColor)?;
 +        }
++
 +        // Show scroll indicator if needed
 +        if completions.len() > max_items {
 +            let indicator_row = popup_row + max_items as u16;
 +            execute!(
 +                self.stdout,
 +                MoveTo(popup_col, indicator_row),
 +                SetBackgroundColor(popup_bg),
 +                SetForegroundColor(detail_fg),
 +                Print(format!(" {}/{} items ", selected_index + 1, completions.len())),
 +                ResetColor,
 +            )?;
 +        }
++
 +        Ok(())
 +    }
++
 +    /// Render diagnostics in the gutter or inline
 +    pub fn render_diagnostics_gutter(
 +        &mut self,
 +        diagnostics: &[Diagnostic],
 +        viewport_line: usize,
 +        left_offset: u16,
 +        top_offset: u16,
 +    ) -> Result<()> {
 +        // Match text_rows calculation from render functions
 +        let text_rows = self.rows.saturating_sub(2 + top_offset) as usize;
++
 +        for diagnostic in diagnostics {
 +            let line = diagnostic.range.start.line as usize;
++
 +            // Only render if in visible viewport
 +            if line >= viewport_line && line < viewport_line + text_rows {
 +                let row = (line - viewport_line) as u16 + top_offset;
++
 +                // Determine color based on severity
 +                let color = match diagnostic.severity {
 +                    Some(DiagnosticSeverity::Error) => Color::Red,
 +                    Some(DiagnosticSeverity::Warning) => Color::Yellow,
 +                    Some(DiagnosticSeverity::Information) => Color::Blue,
 +                    Some(DiagnosticSeverity::Hint) => Color::Cyan,
 +                    None => Color::Yellow,
 +                };
++
 +                // Draw indicator at the start of the line (before line number)
 +                execute!(
 +                    self.stdout,
 +                    MoveTo(left_offset, row),
 +                    SetForegroundColor(color),
 +                    Print("●"),
 +                    ResetColor,
 +                )?;
 +            }
 +        }
++
 +        Ok(())
 +    }
++
 +    /// Render a hover info popup at the given screen position
 +    pub fn render_hover_popup(
 +        &mut self,
 +        hover: &HoverInfo,
 +        cursor_row: u16,
 +        cursor_col: u16,
 +        left_offset: u16,
 +    ) -> Result<()> {
 +        let (width, height) = (self.cols, self.rows);
++
 +        // Split content into lines
 +        let lines: Vec<&str> = hover.contents.lines().collect();
 +        if lines.is_empty() {
 +            return Ok(());
 +        }
++
 +        // Calculate popup dimensions
 +        let max_popup_width = (width as usize).saturating_sub(left_offset as usize + 4).min(80);
 +        let popup_width = lines
 +            .iter()
 +            .map(|l| l.len().min(max_popup_width))
 +            .max()
 +            .unwrap_or(20)
 +            .max(20);
 +        let max_popup_height = (height as usize).saturating_sub(4).min(15);
 +        let popup_height = lines.len().min(max_popup_height);
++
 +        // Determine position - prefer above cursor, but go below if needed
 +        let (popup_row, show_above) = if cursor_row as usize >= popup_height + 2 {
 +            (cursor_row.saturating_sub(popup_height as u16 + 1), true)
 +        } else {
 +            (cursor_row + 1, false)
 +        };
++
 +        let popup_col = cursor_col.max(left_offset);
++
 +        // Ensure popup fits on screen
 +        let popup_col = if popup_col as usize + popup_width + 2 > width as usize {
 +            (width as usize).saturating_sub(popup_width + 3) as u16
 +        } else {
 +            popup_col
 +        };
++
 +        // Draw popup border and content
 +        for (i, line) in lines.iter().take(popup_height).enumerate() {
 +            let row = popup_row + i as u16;
++
 +            // Background and border
 +            execute!(
 +                self.stdout,
 +                MoveTo(popup_col, row),
 +                SetBackgroundColor(Color::AnsiValue(238)),
 +                SetForegroundColor(Color::White),
 +            )?;
++
 +            // Truncate line if needed
 +            let display_line: String = if line.len() > popup_width {
 +                format!(" {}... ", &line[..popup_width.saturating_sub(4)])
 +            } else {
 +                format!(" {:width$} ", line, width = popup_width)
 +            };
++
 +            execute!(self.stdout, Print(&display_line), ResetColor)?;
 +        }
++
 +        // Show indicator if content is truncated
 +        if lines.len() > popup_height {
 +            let row = popup_row + popup_height as u16;
 +            execute!(
 +                self.stdout,
 +                MoveTo(popup_col, row),
 +                SetBackgroundColor(Color::AnsiValue(238)),
 +                SetForegroundColor(Color::DarkGrey),
 +                Print(format!(" [{} more lines] ", lines.len() - popup_height)),
 +                ResetColor
 +            )?;
 +        }
++
 +        // Hide cursor position indicator
 +        let _ = show_above; // suppress unused warning
++
 +        Ok(())
 +    }
++
 +    /// Render the LSP server manager panel
 +    pub fn render_server_manager_panel(&mut self, panel: &ServerManagerPanel) -> Result<()> {
 +        if !panel.visible {
 +            return Ok(());
 +        }
++
 +        let (width, height) = (self.cols, self.rows);
 +        let panel_width = 64.min(width as usize - 4);
 +        let max_visible = 10.min(height as usize - 8);
++
 +        // Center the panel
 +        let start_col = ((width as usize).saturating_sub(panel_width)) / 2;
 +        let start_row = 2u16;
++
 +        // Draw confirm dialog if in confirm mode
 +        if panel.confirm_mode {
 +            self.render_server_install_confirm(panel, start_col, start_row + 4)?;
 +            return Ok(());
 +        }
++
 +        // Draw manual install info dialog
 +        if panel.manual_info_mode {
 +            self.render_manual_install_info(panel, start_col, start_row + 4)?;
 +            return Ok(());
 +        }
++
 +        // Top border
 +        execute!(
 +            self.stdout,
 +            MoveTo(start_col as u16, start_row),
 +            SetForegroundColor(Color::Cyan),
 +            Print("┌"),
 +            Print("─".repeat(panel_width - 2)),
 +            Print("┐"),
 +            ResetColor
 +        )?;
++
 +        // Header
 +        execute!(
 +            self.stdout,
 +            MoveTo(start_col as u16, start_row + 1),
 +            SetForegroundColor(Color::Cyan),
 +            Print("│"),
 +            SetForegroundColor(Color::Cyan),
 +            SetAttribute(Attribute::Bold),
 +            Print(" Language Server Manager"),
 +            SetAttribute(Attribute::Reset),
 +            SetForegroundColor(Color::DarkGrey),
 +        )?;
 +        let header_len = 25;
 +        let padding = panel_width - header_len - 7;
 +        execute!(
 +            self.stdout,
 +            Print(" ".repeat(padding)),
 +            Print("Alt+M"),
 +            SetForegroundColor(Color::Cyan),
 +            Print(" │"),
 +            ResetColor
 +        )?;
++
 +        // Header separator
 +        execute!(
 +            self.stdout,
 +            MoveTo(start_col as u16, start_row + 2),
 +            SetForegroundColor(Color::Cyan),
 +            Print("├"),
 +            Print("─".repeat(panel_width - 2)),
 +            Print("┤"),
 +            ResetColor
 +        )?;
++
 +        // Server list
 +        let visible_end = (panel.scroll_offset + max_visible).min(panel.servers.len());
 +        for (i, idx) in (panel.scroll_offset..visible_end).enumerate() {
 +            let server = &panel.servers[idx];
 +            let row = start_row + 3 + i as u16;
 +            let is_selected = idx == panel.selected_index;
++
 +            execute!(
 +                self.stdout,
 +                MoveTo(start_col as u16, row),
 +                SetForegroundColor(Color::Cyan),
 +                Print("│"),
 +            )?;
++
 +            // Highlight selected row
 +            if is_selected {
 +                execute!(self.stdout, SetAttribute(Attribute::Reverse))?;
 +            }
++
 +            // Status icon
 +            execute!(self.stdout, Print(" "))?;
 +            if server.is_installed {
 +                execute!(
 +                    self.stdout,
 +                    SetForegroundColor(Color::Green),
 +                    Print("✓"),
 +                )?;
 +            } else {
 +                execute!(
 +                    self.stdout,
 +                    SetForegroundColor(Color::Red),
 +                    Print("✗"),
 +                )?;
 +            }
++
 +            // Server name and language (or "Installing..." if being installed)
 +            let is_installing = panel.is_installing(idx);
 +            let name_lang = if is_installing {
 +                " Installing...".to_string()
 +            } else {
 +                format!(" {} ({})", server.name, server.language)
 +            };
 +            let name_len = name_lang.len().min(panel_width - 20);
 +            execute!(
 +                self.stdout,
 +                SetForegroundColor(if is_installing { Color::Yellow } else { Color::White }),
 +                Print(&name_lang[..name_len]),
 +            )?;
++
 +            // Status text
 +            let status = if is_installing {
 +                ""
 +            } else if server.is_installed {
 +                "installed"
 +            } else if server.install_cmd.starts_with('#') {
 +                "manual"
 +            } else {
 +                "Enter to install"
 +            };
 +            // Content width is panel_width - 2 (for the two │ borders)
 +            // We've printed: 1 space + 1 icon + name_len chars
 +            // We need to print: status + 1 trailing space before │
 +            let used = 1 + 1 + name_len + status.len() + 1;
 +            let content_width = panel_width - 2;
 +            let status_padding = content_width.saturating_sub(used);
 +            execute!(self.stdout, Print(" ".repeat(status_padding)))?;
++
 +            if server.is_installed {
 +                execute!(
 +                    self.stdout,
 +                    SetForegroundColor(Color::DarkGrey),
 +                    Print(status),
 +                )?;
 +            } else {
 +                execute!(
 +                    self.stdout,
 +                    SetForegroundColor(Color::Yellow),
 +                    Print(status),
 +                )?;
 +            }
++
 +            if is_selected {
 +                execute!(self.stdout, SetAttribute(Attribute::Reset))?;
 +            }
++
 +            execute!(
 +                self.stdout,
 +                Print(" "),
 +                SetForegroundColor(Color::Cyan),
 +                Print("│"),
 +                ResetColor
 +            )?;
 +        }
++
 +        // Fill remaining rows
 +        for i in (visible_end - panel.scroll_offset)..max_visible {
 +            let row = start_row + 3 + i as u16;
 +            execute!(
 +                self.stdout,
 +                MoveTo(start_col as u16, row),
 +                SetForegroundColor(Color::Cyan),
 +                Print("│"),
 +                Print(" ".repeat(panel_width - 2)),
 +                Print("│"),
 +                ResetColor
 +            )?;
 +        }
++
 +        // Footer separator
 +        let footer_row = start_row + 3 + max_visible as u16;
 +        execute!(
 +            self.stdout,
 +            MoveTo(start_col as u16, footer_row),
 +            SetForegroundColor(Color::Cyan),
 +            Print("├"),
 +            Print("─".repeat(panel_width - 2)),
 +            Print("┤"),
 +            ResetColor
 +        )?;
++
 +        // Status or help
 +        execute!(
 +            self.stdout,
 +            MoveTo(start_col as u16, footer_row + 1),
 +            SetForegroundColor(Color::Cyan),
 +            Print("│"),
 +        )?;
++
 +        if let Some(ref msg) = panel.status_message {
 +            let content_width = panel_width - 2;
 +            let msg_width = msg.width();
 +            // Truncate if needed (simple truncation, could be smarter)
 +            let msg_display = if msg_width > content_width - 2 {
 +                // Find a safe truncation point
 +                let mut truncated = String::new();
 +                let mut w = 0;
 +                for c in msg.chars() {
 +                    let cw = unicode_width::UnicodeWidthChar::width(c).unwrap_or(0);
 +                    if w + cw > content_width - 5 {
 +                        break;
 +                    }
 +                    truncated.push(c);
 +                    w += cw;
 +                }
 +                truncated.push_str("...");
 +                truncated
 +            } else {
 +                msg.clone()
 +            };
 +            let display_width = msg_display.width();
 +            execute!(
 +                self.stdout,
 +                SetForegroundColor(Color::Yellow),
 +                Print(format!(" {}", msg_display)),
 +            )?;
 +            // We printed 1 space + msg_display, need to fill to content_width
 +            let pad = content_width.saturating_sub(1 + display_width);
 +            execute!(self.stdout, Print(" ".repeat(pad)))?;
 +        } else {
 +            let help_text = " ↑↓ Navigate  Enter Install  r Refresh  Esc Close ";
 +            let help_width = help_text.width();
 +            execute!(
 +                self.stdout,
 +                SetForegroundColor(Color::DarkGrey),
 +                Print(help_text),
 +            )?;
 +            // Content width is panel_width - 2 (for borders)
 +            let content_width = panel_width - 2;
 +            let pad = content_width.saturating_sub(help_width);
 +            execute!(self.stdout, Print(" ".repeat(pad)))?;
 +        }
++
 +        execute!(
 +            self.stdout,
 +            SetForegroundColor(Color::Cyan),
 +            Print("│"),
 +            ResetColor
 +        )?;
++
 +        // Bottom border
 +        execute!(
 +            self.stdout,
 +            MoveTo(start_col as u16, footer_row + 2),
 +            SetForegroundColor(Color::Cyan),
 +            Print("└"),
 +            Print("─".repeat(panel_width - 2)),
 +            Print("┘"),
 +            ResetColor
 +        )?;
++
 +        Ok(())
 +    }
++
 +    /// Render the install confirmation dialog
 +    fn render_server_install_confirm(
 +        &mut self,
 +        panel: &ServerManagerPanel,
 +        start_col: usize,
 +        start_row: u16,
 +    ) -> Result<()> {
 +        let panel_width = 60;
++
 +        let server = match panel.confirm_server() {
 +            Some(s) => s,
 +            None => return Ok(()),
 +        };
++
 +        // Top border
 +        execute!(
 +            self.stdout,
 +            MoveTo(start_col as u16, start_row),
 +            SetForegroundColor(Color::Cyan),
 +            Print("┌"),
 +            Print("─".repeat(panel_width - 2)),
 +            Print("┐"),
 +            ResetColor
 +        )?;
++
 +        // Title
 +        let title = format!(" Install {}? ", server.name);
 +        execute!(
 +            self.stdout,
 +            MoveTo(start_col as u16, start_row + 1),
 +            SetForegroundColor(Color::Cyan),
 +            Print("│"),
 +            SetAttribute(Attribute::Bold),
 +            Print(&title),
 +            SetAttribute(Attribute::Reset),
 +        )?;
 +        let pad = panel_width - 2 - title.len();
 +        execute!(
 +            self.stdout,
 +            Print(" ".repeat(pad)),
 +            SetForegroundColor(Color::Cyan),
 +            Print("│"),
 +            ResetColor
 +        )?;
++
 +        // Blank line
 +        execute!(
 +            self.stdout,
 +            MoveTo(start_col as u16, start_row + 2),
 +            SetForegroundColor(Color::Cyan),
 +            Print("│"),
 +            Print(" ".repeat(panel_width - 2)),
 +            Print("│"),
 +            ResetColor
 +        )?;
++
 +        // Command
 +        let cmd_display = if server.install_cmd.len() > panel_width - 14 {
 +            format!("{}...", &server.install_cmd[..panel_width - 17])
 +        } else {
 +            server.install_cmd.to_string()
 +        };
 +        execute!(
 +            self.stdout,
 +            MoveTo(start_col as u16, start_row + 3),
 +            SetForegroundColor(Color::Cyan),
 +            Print("│"),
 +            SetForegroundColor(Color::White),
 +            Print(" Command: "),
 +            SetForegroundColor(Color::Yellow),
 +            Print(&cmd_display),
 +        )?;
 +        let pad = panel_width - 12 - cmd_display.len();
 +        execute!(
 +            self.stdout,
 +            Print(" ".repeat(pad)),
 +            SetForegroundColor(Color::Cyan),
 +            Print("│"),
 +            ResetColor
 +        )?;
++
 +        // Blank line
 +        execute!(
 +            self.stdout,
 +            MoveTo(start_col as u16, start_row + 4),
 +            SetForegroundColor(Color::Cyan),
 +            Print("│"),
 +            Print(" ".repeat(panel_width - 2)),
 +            Print("│"),
 +            ResetColor
 +        )?;
++
 +        // Buttons
 +        execute!(
 +            self.stdout,
 +            MoveTo(start_col as u16, start_row + 5),
 +            SetForegroundColor(Color::Cyan),
 +            Print("│"),
 +        )?;
 +        let button_text = "[Y]es    [N]o";
 +        let button_pad = (panel_width - 2 - button_text.len()) / 2;
 +        execute!(
 +            self.stdout,
 +            Print(" ".repeat(button_pad)),
 +            Print("["),
 +            SetForegroundColor(Color::Green),
 +            Print("Y"),
 +            SetForegroundColor(Color::White),
 +            Print("]es    ["),
 +            SetForegroundColor(Color::Red),
 +            Print("N"),
 +            SetForegroundColor(Color::White),
 +            Print("]o"),
 +            Print(" ".repeat(panel_width - 2 - button_pad - button_text.len())),
 +            SetForegroundColor(Color::Cyan),
 +            Print("│"),
 +            ResetColor
 +        )?;
++
 +        // Bottom border
 +        execute!(
 +            self.stdout,
 +            MoveTo(start_col as u16, start_row + 6),
 +            SetForegroundColor(Color::Cyan),
 +            Print("└"),
 +            Print("─".repeat(panel_width - 2)),
 +            Print("┘"),
 +            ResetColor
 +        )?;
++
 +        Ok(())
 +    }
++
 +    /// Render the manual install info dialog
 +    fn render_manual_install_info(
 +        &mut self,
 +        panel: &ServerManagerPanel,
 +        start_col: usize,
 +        start_row: u16,
 +    ) -> Result<()> {
 +        let panel_width = 60;
++
 +        let server = match panel.manual_info_server() {
 +            Some(s) => s,
 +            None => return Ok(()),
 +        };
++
 +        // Parse the install instructions (remove leading #)
 +        let instructions = server.install_cmd.trim_start_matches('#').trim();
++
 +        // Top border
 +        execute!(
 +            self.stdout,
 +            MoveTo(start_col as u16, start_row),
 +            SetForegroundColor(Color::Cyan),
 +            Print("┌"),
 +            Print("─".repeat(panel_width - 2)),
 +            Print("┐"),
 +            ResetColor
 +        )?;
++
 +        // Title
 +        let title = format!(" {} - Manual Installation ", server.name);
 +        execute!(
 +            self.stdout,
 +            MoveTo(start_col as u16, start_row + 1),
 +            SetForegroundColor(Color::Cyan),
 +            Print("│"),
 +            SetAttribute(Attribute::Bold),
 +            SetForegroundColor(Color::Yellow),
 +            Print(&title),
 +            SetAttribute(Attribute::Reset),
 +        )?;
 +        let pad = panel_width - 2 - title.len();
 +        execute!(
 +            self.stdout,
 +            Print(" ".repeat(pad)),
 +            SetForegroundColor(Color::Cyan),
 +            Print("│"),
 +            ResetColor
 +        )?;
++
 +        // Separator
 +        execute!(
 +            self.stdout,
 +            MoveTo(start_col as u16, start_row + 2),
 +            SetForegroundColor(Color::Cyan),
 +            Print("├"),
 +            Print("─".repeat(panel_width - 2)),
 +            Print("┤"),
 +            ResetColor
 +        )?;
++
 +        // Language
 +        execute!(
 +            self.stdout,
 +            MoveTo(start_col as u16, start_row + 3),
 +            SetForegroundColor(Color::Cyan),
 +            Print("│"),
 +            SetForegroundColor(Color::White),
 +            Print(" Language: "),
 +            SetForegroundColor(Color::Green),
 +            Print(server.language),
 +        )?;
 +        let lang_pad = panel_width - 13 - server.language.len();
 +        execute!(
 +            self.stdout,
 +            Print(" ".repeat(lang_pad)),
 +            SetForegroundColor(Color::Cyan),
 +            Print("│"),
 +            ResetColor
 +        )?;
++
 +        // Blank line
 +        execute!(
 +            self.stdout,
 +            MoveTo(start_col as u16, start_row + 4),
 +            SetForegroundColor(Color::Cyan),
 +            Print("│"),
 +            Print(" ".repeat(panel_width - 2)),
 +            Print("│"),
 +            ResetColor
 +        )?;
++
 +        // Instructions label
 +        execute!(
 +            self.stdout,
 +            MoveTo(start_col as u16, start_row + 5),
 +            SetForegroundColor(Color::Cyan),
 +            Print("│"),
 +            SetForegroundColor(Color::White),
 +            Print(" Installation:"),
 +        )?;
 +        execute!(
 +            self.stdout,
 +            Print(" ".repeat(panel_width - 16)),
 +            SetForegroundColor(Color::Cyan),
 +            Print("│"),
 +            ResetColor
 +        )?;
++
 +        // Instructions text (may be multi-line, show up to 3 lines)
 +        let instr_lines: Vec<&str> = instructions.lines().collect();
 +        for (i, line) in instr_lines.iter().take(3).enumerate() {
 +            let row = start_row + 6 + i as u16;
 +            let display_line = if line.len() > panel_width - 6 {
 +                format!("{}...", &line[..panel_width - 9])
 +            } else {
 +                line.to_string()
 +            };
 +            execute!(
 +                self.stdout,
 +                MoveTo(start_col as u16, row),
 +                SetForegroundColor(Color::Cyan),
 +                Print("│"),
 +                SetForegroundColor(Color::Yellow),
 +                Print(format!("   {}", display_line)),
 +            )?;
 +            let line_pad = panel_width - 5 - display_line.len();
 +            execute!(
 +                self.stdout,
 +                Print(" ".repeat(line_pad)),
 +                SetForegroundColor(Color::Cyan),
 +                Print("│"),
 +                ResetColor
 +            )?;
 +        }
++
 +        // Fill remaining instruction lines if less than 3
 +        for i in instr_lines.len()..3 {
 +            let row = start_row + 6 + i as u16;
 +            execute!(
 +                self.stdout,
 +                MoveTo(start_col as u16, row),
 +                SetForegroundColor(Color::Cyan),
 +                Print("│"),
 +                Print(" ".repeat(panel_width - 2)),
 +                Print("│"),
 +                ResetColor
 +            )?;
 +        }
++
 +        // Blank line
 +        execute!(
 +            self.stdout,
 +            MoveTo(start_col as u16, start_row + 9),
 +            SetForegroundColor(Color::Cyan),
 +            Print("│"),
 +            Print(" ".repeat(panel_width - 2)),
 +            Print("│"),
 +            ResetColor
 +        )?;
++
 +        // Status or help line
 +        execute!(
 +            self.stdout,
 +            MoveTo(start_col as u16, start_row + 10),
 +            SetForegroundColor(Color::Cyan),
 +            Print("│"),
 +        )?;
++
 +        if panel.copied_to_clipboard {
 +            execute!(
 +                self.stdout,
 +                SetForegroundColor(Color::Green),
 +                Print(" ✓ Copied to clipboard!"),
 +            )?;
 +            execute!(self.stdout, Print(" ".repeat(panel_width - 26)))?;
 +        } else {
 +            execute!(
 +                self.stdout,
 +                SetForegroundColor(Color::DarkGrey),
 +                Print(" [C] Copy to clipboard  [Esc] Close"),
 +            )?;
 +            execute!(self.stdout, Print(" ".repeat(panel_width - 38)))?;
 +        }
++
 +        execute!(
 +            self.stdout,
 +            SetForegroundColor(Color::Cyan),
 +            Print("│"),
 +            ResetColor
 +        )?;
++
 +        // Bottom border
 +        execute!(
 +            self.stdout,
 +            MoveTo(start_col as u16, start_row + 11),
 +            SetForegroundColor(Color::Cyan),
 +            Print("└"),
 +            Print("─".repeat(panel_width - 2)),
 +            Print("┘"),
 +            ResetColor
 +        )?;
++
 +        Ok(())
 +    }
+ }

src/workspace/state.rsmodified

  use crate::buffer::Buffer;
  use crate::editor::{Cursors, History};
  use crate::fuss::FussMode;
 +use crate::lsp::LspClient;
 +use crate::syntax::Highlighter;
  /// Normalized pane bounds (0.0 to 1.0)
  /// Converted to screen coordinates at render time
      pub buffer: Buffer,
      /// Undo/redo history for this buffer
      pub history: History,
 +    /// Syntax highlighter for this buffer
 +    pub highlighter: Highlighter,
      /// File is outside workspace directory
      pub is_orphan: bool,
      /// Hash of buffer content at last save (None for new unsaved buffers)
              path: None,
              buffer,
              history: History::new(),
 +            highlighter: Highlighter::new(),
              is_orphan: false,
              saved_hash,
              saved_len,
          let buffer = Buffer::from_str(content);
          let saved_hash = Some(buffer.content_hash());
          let saved_len = Some(buffer.len_chars());
++
 +        // Detect language from display name for syntax highlighting
 +        let mut highlighter = Highlighter::new();
 +        if let Some(name) = display_name {
 +            highlighter.detect_language(name);
 +        }
++
          Self {
              path: display_name.map(PathBuf::from),
              buffer,
              history: History::new(),
 +            highlighter,
              is_orphan: true, // Mark as orphan so path isn't prefixed with workspace root
              saved_hash,
              saved_len,
                  .to_path_buf()
          };
 +        // Detect language for syntax highlighting
 +        let mut highlighter = Highlighter::new();
 +        if let Some(filename) = path.file_name().and_then(|n| n.to_str()) {
 +            highlighter.detect_language(filename);
 +        }
++
          Ok(Self {
              path: Some(stored_path),
              buffer,
              history: History::new(),
 +            highlighter,
              is_orphan,
              saved_hash,
              saved_len,
      pub fuss: FussMode,
      /// Workspace configuration
      pub config: WorkspaceConfig,
 +    /// LSP client for language server support
 +    pub lsp: LspClient,
+ }
  impl Workspace {
      pub fn new(root: PathBuf) -> Self {
          let mut fuss = FussMode::new();
          fuss.init(&root);
 +        let root_str = root.to_string_lossy().to_string();
 +        let lsp = LspClient::new(&root_str);
          Self {
              root,
              tabs: vec![Tab::new()],
              active_tab: 0,
              fuss,
              config: WorkspaceConfig::default(),
 +            lsp,
+         }
+     }
          // Open new tab
          let tab = Tab::from_file(path, &self.root)?;
++
 +        // Notify LSP server of newly opened file
 +        if let Some(file_path) = tab.path() {
 +            let full_path = if tab.is_orphan() {
 +                file_path.clone()
 +            } else {
 +                self.root.join(file_path)
 +            };
 +            let path_str = full_path.to_string_lossy();
 +            let content = tab.buffers[0].buffer.contents();
 +            let _ = self.lsp.open_document(&path_str, &content);
 +        }
++
          self.tabs.push(tab);
          self.active_tab = self.tabs.len() - 1;
          Ok(())
      pub fn is_git_repo(&self) -> bool {
          self.root.join(".git").exists()
+     }
++
 +    /// Find a tab by file path, returns tab index if found
 +    pub fn find_tab_by_path(&self, path: &std::path::Path) -> Option<usize> {
 +        for (tab_idx, tab) in self.tabs.iter().enumerate() {
 +            for buffer_entry in &tab.buffers {
 +                if let Some(buf_path) = &buffer_entry.path {
 +                    // Get full path for comparison
 +                    let full_path = if buffer_entry.is_orphan {
 +                        buf_path.clone()
 +                    } else {
 +                        self.root.join(buf_path)
 +                    };
 +                    if full_path == path {
 +                        return Some(tab_idx);
 +                    }
 +                }
 +            }
 +        }
 +        None
 +    }
++
 +    /// Apply a text edit to a buffer in a specific tab
 +    pub fn apply_text_edit(&mut self, tab_idx: usize, edit: &crate::lsp::TextEdit) {
 +        if tab_idx >= self.tabs.len() {
 +            return;
 +        }
++
 +        let tab = &mut self.tabs[tab_idx];
 +        if tab.buffers.is_empty() {
 +            return;
 +        }
++
 +        let buffer = &mut tab.buffers[0].buffer;
++
 +        // Convert LSP range to buffer char indices
 +        let start_line = edit.range.start.line as usize;
 +        let start_col = edit.range.start.character as usize;
 +        let end_line = edit.range.end.line as usize;
 +        let end_col = edit.range.end.character as usize;
++
 +        let start_char = buffer.line_col_to_char(start_line, start_col);
 +        let end_char = buffer.line_col_to_char(end_line, end_col);
++
 +        // Delete the old text first (if range is non-empty)
 +        if start_char < end_char {
 +            buffer.delete(start_char, end_char);
 +        }
++
 +        // Insert the new text at start position
 +        if !edit.new_text.is_empty() {
 +            buffer.insert(start_char, &edit.new_text);
 +        }
 +        // Buffer automatically tracks modifications via content hash
 +    }
+ }