tenseleyflow/fackr / e76eeee

+use std::collections::HashSet;

+    /// 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()

+    }

+

+/// 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>,

+}

+

+    /// Ghost text inline autocomplete state

+    ghost_text: GhostTextState,

+            ghost_text: GhostTextState::default(),

+    // === 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();

+            }

+        }

+    }

+

+                    self.ghost_text.suggestion.as_deref(),

+                self.dismiss_ghost_text();

+            (Key::Up, Modifiers { shift, .. }) => {

+                self.move_up(*shift);

+                self.validate_ghost_text_position();

+            }

+            (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();

+            }

+            (Key::Home, Modifiers { shift, .. }) => {

+                self.move_home(*shift);

+                self.validate_ghost_text_position();

+            }

+            (Key::End, Modifiers { shift, .. }) => {

+                self.move_end(*shift);

+                self.validate_ghost_text_position();

+            }

+            (Key::PageUp, Modifiers { shift, .. }) => {

+                self.page_up(*shift);

+                self.validate_ghost_text_position();

+            }

+            (Key::PageDown, Modifiers { shift, .. }) => {

+                self.page_down(*shift);

+                self.validate_ghost_text_position();

+            }

+            (Key::Enter, _) => {

+                self.insert_newline();

+                self.dismiss_ghost_text();

+            }

+            (Key::Backspace, Modifiers { alt: true, .. }) => {

+                self.delete_word_backward();

+                self.update_ghost_text();

+            }

+                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();

+                }

+            self.dismiss_ghost_text();

+                self.dismiss_ghost_text();

+                self.dismiss_ghost_text();

+

+        // Update ghost text after alphanumeric input

+        if c.is_alphanumeric() || c == '_' {

+            self.update_ghost_text();

+        } else {

+            self.dismiss_ghost_text();

+        }

+        ghost_text: Option<&str>,

+

+                    // 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),

+                                )?;

+                            }

+                        }

+                    }

+# 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 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:

+    //

+

+}

+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)