`e76eeee`

ghost text suggestions

Authored by

espadonne 4 months ago

SHA: e76eeeec5bab2704ef17a867bc63509293ac6ea9
Parents: d40af3b
Tree: a92ada4

6 changed files

Status	File	+	-
M	`src/buffer/rope.rs`	25	0
M	`src/editor/state.rs`	241	12
M	`src/render/screen.rs`	20	0
A	`test_ghost.py`	51	0
A	`test_ghost_text.rs`	61	0
A	`test_simple.txt`	61	0

src/buffer/rope.rsmodified

  use anyhow::Result;
  use ropey::Rope;
  use std::collections::hash_map::DefaultHasher;
++use std::collections::HashSet;
  use std::fs::File;
  use std::hash::{Hash, Hasher};
  use std::io::{BufReader, BufWriter};
          self.text.to_string()
+     }
++    /// Extract all unique words from the buffer for autocomplete.
++    /// Words are alphanumeric sequences with underscores, minimum 3 characters.
++    pub fn extract_words(&self) -> Vec<String> {
++        let mut words = HashSet::new();
++        let mut current_word = String::new();
++
++        for ch in self.text.chars() {
++            if ch.is_alphanumeric() || ch == '_' {
++                current_word.push(ch);
++            } else {
++                if current_word.len() >= 3 {
++                    words.insert(current_word.clone());
++                }
++                current_word.clear();
++            }
++        }
++        // Don't forget the last word
++        if current_word.len() >= 3 {
++            words.insert(current_word);
++        }
++
++        words.into_iter().collect()
++    }
++
      /// Compute a hash of the buffer contents for change detection.
      /// Uses cached value if available, otherwise computes and caches.
      pub fn content_hash(&mut self) -> u64 {

src/editor/state.rsmodified

      valid: bool,
+ }
++/// Source of ghost text suggestion
++#[derive(Debug, Default, Clone, Copy, PartialEq)]
++enum GhostTextSource {
++    #[default]
++    None,
++    Lsp,
++    CurrentBuffer,
++    OtherBuffer,
++}
++
++/// Ghost text inline autocomplete state
++#[derive(Debug, Default)]
++struct GhostTextState {
++    /// The ghost text suggestion (suffix to show/insert after cursor)
++    suggestion: Option<String>,
++    /// Position where suggestion applies (line, col)
++    position: Option<(usize, usize)>,
++    /// The prefix that was used to generate this suggestion
++    prefix: String,
++    /// Source of the current suggestion
++    source: GhostTextSource,
++    /// Cached word list from current buffer (content_hash, words)
++    buffer_words_cache: Option<(u64, Vec<String>)>,
++    /// Cached word list from all open buffers
++    all_buffer_words_cache: Vec<String>,
++}
++
  /// Main editor state
  pub struct Editor {
      /// The workspace (owns tabs, panes, fuss mode, and config)
      search_state: SearchState,
      /// Cached bracket match for rendering
      bracket_cache: BracketMatchCache,
++    /// Ghost text inline autocomplete state
++    ghost_text: GhostTextState,
      /// Yank stack (kill ring) - separate from system clipboard
      yank_stack: Vec<String>,
      /// Current index in yank stack when cycling with Alt+Y
              server_manager: ServerManagerPanel::new(),
              search_state: SearchState::default(),
              bracket_cache: BracketMatchCache::default(),
++            ghost_text: GhostTextState::default(),
              yank_stack: Vec::with_capacity(32),
              yank_index: None,
              last_yank_len: 0,
          self.lsp_state.completion_index = 0;
+     }
++    // === Ghost Text (Inline Autocomplete) ===
++
++    /// Update ghost text suggestion based on current cursor position
++    fn update_ghost_text(&mut self) {
++        // Don't show ghost text if completion popup is visible
++        if self.lsp_state.completion_visible {
++            self.ghost_text.suggestion = None;
++            return;
++        }
++
++        let cursor = self.cursor();
++        let line_idx = cursor.line;
++        let col = cursor.col;
++
++        // Get current line and extract prefix (word before cursor)
++        let prefix = match self.buffer().line_str(line_idx) {
++            Some(line) => {
++                let before_cursor: String = line.chars().take(col).collect();
++                // Walk back to find word start
++                before_cursor
++                    .chars()
++                    .rev()
++                    .take_while(|c| c.is_alphanumeric() || *c == '_')
++                    .collect::<String>()
++                    .chars()
++                    .rev()
++                    .collect::<String>()
++            }
++            None => return,
++        };
++
++        // Don't suggest for very short prefixes
++        if prefix.len() < 2 {
++            self.ghost_text.suggestion = None;
++            return;
++        }
++
++        // Try to find best suggestion from all sources
++        if let Some(full_word) = self.find_best_suggestion(&prefix) {
++            // Ghost text is the suffix (part after prefix)
++            if full_word.len() > prefix.len() {
++                let suffix = full_word[prefix.len()..].to_string();
++                self.ghost_text.suggestion = Some(suffix);
++                self.ghost_text.position = Some((line_idx, col));
++                self.ghost_text.prefix = prefix;
++                return;
++            }
++        }
++
++        self.ghost_text.suggestion = None;
++    }
++
++    /// Find best matching suggestion from all sources (LSP, current buffer, other buffers)
++    fn find_best_suggestion(&mut self, prefix: &str) -> Option<String> {
++        let prefix_lower = prefix.to_lowercase();
++
++        // Priority 1: LSP completions (if we have recent ones)
++        for item in &self.lsp_state.completions_original {
++            let text = item.insert_text.as_ref().unwrap_or(&item.label);
++            if text.to_lowercase().starts_with(&prefix_lower) && text.len() > prefix.len() {
++                self.ghost_text.source = GhostTextSource::Lsp;
++                return Some(text.clone());
++            }
++        }
++
++        // Priority 2: Current buffer words
++        let buffer_hash = self.buffer_mut().content_hash();
++        let needs_refresh = self
++            .ghost_text
++            .buffer_words_cache
++            .as_ref()
++            .map(|(h, _)| *h != buffer_hash)
++            .unwrap_or(true);
++
++        if needs_refresh {
++            let words = self.buffer().extract_words();
++            self.ghost_text.buffer_words_cache = Some((buffer_hash, words));
++        }
++
++        if let Some((_, ref words)) = self.ghost_text.buffer_words_cache {
++            for word in words {
++                if word.to_lowercase().starts_with(&prefix_lower)
++                    && word != prefix
++                    && word.len() > prefix.len()
++                {
++                    self.ghost_text.source = GhostTextSource::CurrentBuffer;
++                    return Some(word.clone());
++                }
++            }
++        }
++
++        // Priority 3: Words from other buffers
++        for word in &self.ghost_text.all_buffer_words_cache {
++            if word.to_lowercase().starts_with(&prefix_lower)
++                && word != prefix
++                && word.len() > prefix.len()
++            {
++                self.ghost_text.source = GhostTextSource::OtherBuffer;
++                return Some(word.clone());
++            }
++        }
++
++        None
++    }
++
++    /// Collect words from all open buffers in workspace
++    fn collect_all_buffer_words(&self) -> Vec<String> {
++        let mut words = std::collections::HashSet::new();
++        for tab in &self.workspace.tabs {
++            for buffer_entry in &tab.buffers {
++                for word in buffer_entry.buffer.extract_words() {
++                    words.insert(word);
++                }
++            }
++        }
++        words.into_iter().collect()
++    }
++
++    /// Accept the current ghost text suggestion
++    fn accept_ghost_text(&mut self) {
++        if let Some(suffix) = self.ghost_text.suggestion.take() {
++            self.insert_text(&suffix);
++            self.ghost_text.position = None;
++            self.ghost_text.prefix.clear();
++        }
++    }
++
++    /// Dismiss ghost text (clear suggestion)
++    fn dismiss_ghost_text(&mut self) {
++        self.ghost_text.suggestion = None;
++        self.ghost_text.position = None;
++        self.ghost_text.prefix.clear();
++    }
++
++    /// Check if ghost text should be dismissed due to cursor movement
++    fn validate_ghost_text_position(&mut self) {
++        if let Some((line, col)) = self.ghost_text.position {
++            let cursor = self.cursor();
++            // Dismiss if cursor moved to different line or before the prefix start
++            let prefix_start = col.saturating_sub(self.ghost_text.prefix.len());
++            if cursor.line != line || cursor.col < prefix_start || cursor.col > col {
++                self.dismiss_ghost_text();
++            }
++        }
++    }
++
      /// Process a key event, handling ESC as potential Alt prefix
      fn process_key(&mut self, key_event: KeyEvent) -> Result<()> {
          use crossterm::event::{KeyCode, KeyModifiers};
                      top_offset,
                      is_modified,
                      &mut buffer_entry.highlighter,
++                    self.ghost_text.suggestion.as_deref(),
                  )?;
+             }
                  } else {
                      self.cursors_mut().primary_mut().clear_selection();
+                 }
++                self.dismiss_ghost_text();
+             }
              // === Undo/Redo ===
              (Key::Char('f'), Modifiers { alt: true, .. }) => self.move_word_right(false),
              // === Movement with selection ===
--            (Key::Up, Modifiers { shift, .. }) => self.move_up(*shift),
++            (Key::Up, Modifiers { shift, .. }) => {
--            (Key::Down, Modifiers { shift, .. }) => self.move_down(*shift),
++                self.move_up(*shift);
--            (Key::Left, Modifiers { shift, .. }) => self.move_left(*shift),
++                self.validate_ghost_text_position();
--            (Key::Right, Modifiers { shift, .. }) => self.move_right(*shift),
++            }
++            (Key::Down, Modifiers { shift, .. }) => {
++                self.move_down(*shift);
++                self.validate_ghost_text_position();
++            }
++            (Key::Left, Modifiers { shift, .. }) => {
++                self.move_left(*shift);
++                self.validate_ghost_text_position();
++            }
++            (Key::Right, Modifiers { shift, .. }) => {
++                self.move_right(*shift);
++                self.validate_ghost_text_position();
++            }
              // Home/End
--            (Key::Home, Modifiers { shift, .. }) => self.move_home(*shift),
++            (Key::Home, Modifiers { shift, .. }) => {
--            (Key::End, Modifiers { shift, .. }) => self.move_end(*shift),
++                self.move_home(*shift);
++                self.validate_ghost_text_position();
++            }
++            (Key::End, Modifiers { shift, .. }) => {
++                self.move_end(*shift);
++                self.validate_ghost_text_position();
++            }
              (Key::Char('a'), Modifiers { ctrl: true, shift, .. }) => self.smart_home(*shift),
              (Key::Char('e'), Modifiers { ctrl: true, shift, .. }) => self.move_end(*shift),
              // Page movement
--            (Key::PageUp, Modifiers { shift, .. }) => self.page_up(*shift),
++            (Key::PageUp, Modifiers { shift, .. }) => {
--            (Key::PageDown, Modifiers { shift, .. }) => self.page_down(*shift),
++                self.page_up(*shift);
++                self.validate_ghost_text_position();
++            }
++            (Key::PageDown, Modifiers { shift, .. }) => {
++                self.page_down(*shift);
++                self.validate_ghost_text_position();
++            }
              // Join lines: Ctrl+J
              (Key::Char('j'), Modifiers { ctrl: true, .. }) => self.join_lines(),
              (Key::Char(c), Modifiers { ctrl: false, alt: false, .. }) => {
                  self.insert_char(*c);
+             }
--            (Key::Enter, _) => self.insert_newline(),
++            (Key::Enter, _) => {
--            (Key::Backspace, Modifiers { alt: true, .. }) => self.delete_word_backward(),
++                self.insert_newline();
++                self.dismiss_ghost_text();
++            }
++            (Key::Backspace, Modifiers { alt: true, .. }) => {
++                self.delete_word_backward();
++                self.update_ghost_text();
++            }
              (Key::Backspace, _) | (Key::Char('h'), Modifiers { ctrl: true, .. }) => {
                  self.delete_backward();
++                self.update_ghost_text();
++            }
++            (Key::Delete, _) => {
++                self.delete_forward();
++                self.dismiss_ghost_text();
++            }
++            (Key::Tab, _) => {
++                // Accept ghost text if visible and no selection
++                if self.ghost_text.suggestion.is_some() && !self.cursor().has_selection() {
++                    self.accept_ghost_text();
++                } else {
++                    self.insert_tab();
++                }
+             }
--            (Key::Delete, _) => self.delete_forward(),
--            (Key::Tab, _) => self.insert_tab(),
              (Key::BackTab, _) => self.dedent(),
              // Delete word backward: Ctrl+W
          // For multi-cursor, use simple insert (skip auto-pair complexity for now)
          if self.cursors().len() > 1 {
              self.insert_text_multi(&c.to_string());
++            self.dismiss_ghost_text();
              return;
+         }
              if c == next_char && (c == ')' || c == ']' || c == '}' || c == '"' || c == '\'' || c == '`') {
                  self.cursor_mut().col += 1;
                  self.cursor_mut().desired_col = self.cursor().col;
++                self.dismiss_ghost_text();
                  return;
+             }
+         }
                  let cursor_after = self.cursor_pos();
                  self.history_mut().record_insert(idx, pair_str, cursor_before, cursor_after);
++                self.dismiss_ghost_text();
                  return;
+             }
+         }
          self.insert_text(&c.to_string());
++
++        // Update ghost text after alphanumeric input
++        if c.is_alphanumeric() || c == '_' {
++            self.update_ghost_text();
++        } else {
++            self.dismiss_ghost_text();
++        }
+     }
      /// Get character at cursor position (if any)

src/render/screen.rsmodified

          top_offset: u16,
          is_modified: bool,
          highlighter: &mut Highlighter,
++        ghost_text: Option<&str>,
      ) -> Result<()> {
          execute!(self.stdout, Hide)?;
                          &secondary_cursors,
                          &adjusted_tokens,
                      )?;
++
++                    // Render ghost text on the current line after the cursor
++                    if is_current_line {
++                        if let Some(ghost) = ghost_text {
++                            // Calculate remaining space for ghost text
++                            let line_len = display_line.chars().count();
++                            let remaining_cols = text_cols.saturating_sub(line_len);
++                            if remaining_cols > 0 {
++                                // Truncate ghost text if it doesn't fit
++                                let ghost_display: String = ghost.chars().take(remaining_cols).collect();
++                                execute!(
++                                    self.stdout,
++                                    SetBackgroundColor(line_bg),
++                                    SetForegroundColor(Color::AnsiValue(240)), // Dim gray
++                                    Print(&ghost_display),
++                                )?;
++                            }
++                        }
++                    }
+                 }
                  execute!(

test_ghost.pyadded

++# Python test file for ghost text autocomplete
++
++def initialize_database():
++    print("initializing database")
++
++def initialize_server():
++    print("initializing server")
++
++def validate_input(data):
++    return data is not None
++
++def validate_output(result):
++    return result is not None
++
++def transform_data(input_data):
++    return input_data.upper()
++
++def transform_result(output_result):
++    return output_result.lower()
++
++class UserAuthentication:
++    def __init__(self):
++        self.authenticated = False
++
++    def authenticate_user(self, username, password):
++        self.authenticated = True
++        return self.authenticated
++
++class DataProcessor:
++    def __init__(self):
++        self.processing = False
++
++    def process_batch(self, items):
++        self.processing = True
++        return [item * 2 for item in items]
++
++# Test typing here:
++# Try: "init" -> should suggest "ialize_database" or "ialize_server"
++# Try: "vali" -> should suggest "date_input" or "date_output"
++# Try: "trans" -> should suggest "form_data" or "form_result"
++# Try: "User" -> should suggest "Authentication"
++# Try: "Data" -> should suggest "Processor"
++# Try: "auth" -> should suggest "enticated" or "enticate_user"
++# Try: "proc" -> should suggest "essing" or "ess_batch"
++
++def main():
++    # Type new code here to test autocomplete:
++    pass
++
++if __name__ == "__main__":
++    main()

test_ghost_text.rsadded

++// Test file for ghost text autocomplete
++// Try typing the first 2-3 characters of these words and see ghost suggestions
++
++fn authentication_handler() {
++    println!("authentication started");
++}
++
++fn authorization_check() {
++    println!("authorization verified");
++}
++
++fn calculate_total(items: Vec<i32>) -> i32 {
++    items.iter().sum()
++}
++
++fn calculate_average(items: Vec<i32>) -> f64 {
++    let total = calculate_total(items.clone());
++    total as f64 / items.len() as f64
++}
++
++fn process_request(request: String) {
++    println!("processing: {}", request);
++}
++
++fn process_response(response: String) {
++    println!("response: {}", response);
++}
++
++struct Configuration {
++    database_url: String,
++    database_port: u16,
++    server_host: String,
++    server_port: u16,
++}
++
++impl Configuration {
++    fn new() -> Self {
++        Configuration {
++            database_url: String::from("localhost"),
++            database_port: 5432,
++            server_host: String::from("0.0.0.0"),
++            server_port: 8080,
++        }
++    }
++}
++
++// Test suggestions:
++// Type "auth" -> should suggest "entication" or "orization"
++// Type "calc" -> should suggest "ulate_total" or "ulate_average"
++// Type "proc" -> should suggest "ess_request" or "ess_response"
++// Type "data" -> should suggest "base_url" or "base_port"
++// Type "serv" -> should suggest "er_host" or "er_port"
++// Type "Conf" -> should suggest "iguration"
++
++fn main() {
++    let config = Configuration::new();
++
++    // Try typing here:
++    //
++
++}

test_simple.txtadded

++Ghost Text Autocomplete Test File
++==================================
++
++Words to test (type first 2-3 letters, then Tab to accept):
++
++hello
++hello
++hello
++
++world
++world
++world
++
++function
++function
++function
++
++variable
++variable
++variable
++
++testing
++testing
++testing
++
++autocomplete
++autocomplete
++autocomplete
++
++suggestion
++suggestion
++suggestion
++
++keyboard
++keyboard
++keyboard
++
++terminal
++terminal
++terminal
++
++implementation
++implementation
++implementation
++
++---
++
++Try typing below this line:
++
++
++
++---
++
++Expected behaviors:
++1. Type "hel" -> ghost text shows "lo" in dim gray
++2. Press Tab -> "lo" is inserted, cursor at end of "hello"
++3. Type "fun" -> ghost text shows "ction"
++4. Press Escape -> ghost text disappears
++5. Type "var" -> ghost text shows "iable"
++6. Press arrow key -> ghost text disappears
++7. Tab with no ghost text -> inserts 4 spaces (normal indent)