tenseleyflow/fackr / ddc3697

+crossterm = { version = "0.28", features = ["libc"] }

+[[bin]]

+name = "keytest"

+path = "src/bin/keytest.rs"

+

+Version:        0.9.6

+* Wed Dec 11 2024 mfw <espadon@outlook.com> - 0.9.6-1

+- Fix command palette char input

+- Create new file from CLI

+

+* Wed Dec 11 2024 mfw <espadon@outlook.com> - 0.9.5-1

+- Command palette (Ctrl+P) with fuzzy search

+

+* Wed Dec 11 2024 mfw <espadon@outlook.com> - 0.9.4-1

+- Ctrl+D scrolls viewport to show newly added cursor

+

+* Tue Dec 10 2024 mfw <espadon@outlook.com> - 0.9.0-1

+- Add Ctrl+/ toggle line comment

+- Performance optimizations

+

+* Mon Dec 09 2024 mfw <espadon@outlook.com> - 0.8.0-1

+- Add Ctrl+G/F5 goto line with line:col syntax

+- Add Ctrl+O fortress file browser

+- Fix multi-cursor same-line edits

+

+* Mon Dec 09 2024 mfw <espadon@outlook.com> - 0.7.0-1

+- Add Ctrl+F/Ctrl+R find and replace with regex support

+- Fuzzy filter improvements and references panel visual fix

+

+* Sun Dec 08 2024 mfw <espadon@outlook.com> - 0.6.0-1

+- Add Shift+F12 references panel with filtering

+- Syntax highlighting for 30+ languages

+- LSP support with auto-completion and diagnostics

+

+// Simple key event debugger

+// Run with: cargo run --bin keytest

+

+use crossterm::{

+    event::{self, Event, KeyCode, KeyEvent, KeyModifiers, PushKeyboardEnhancementFlags, PopKeyboardEnhancementFlags, KeyboardEnhancementFlags},

+    terminal::{self, EnterAlternateScreen, LeaveAlternateScreen},

+    execute,

+};

+use std::io::{self, Write};

+

+fn main() -> io::Result<()> {

+    terminal::enable_raw_mode()?;

+    execute!(io::stdout(), EnterAlternateScreen)?;

+

+    // Try to enable keyboard enhancement

+    let enhanced = execute!(

+        io::stdout(),

+        PushKeyboardEnhancementFlags(

+            KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES

+                | KeyboardEnhancementFlags::REPORT_ALL_KEYS_AS_ESCAPE_CODES

+        )

+    ).is_ok();

+

+    println!("Keyboard enhancement: {}\r", if enhanced { "enabled" } else { "disabled" });

+    println!("Press keys to see events (Ctrl+C to quit)\r\n");

+

+    loop {

+        if event::poll(std::time::Duration::from_millis(100))? {

+            match event::read()? {

+                Event::Key(KeyEvent { code, modifiers, kind, state }) => {

+                    let ctrl = modifiers.contains(KeyModifiers::CONTROL);

+                    let alt = modifiers.contains(KeyModifiers::ALT);

+                    let shift = modifiers.contains(KeyModifiers::SHIFT);

+

+                    println!(

+                        "Key: {:?} | Modifiers: ctrl={} alt={} shift={} | Kind: {:?} | State: {:?}\r",

+                        code, ctrl, alt, shift, kind, state

+                    );

+

+                    // Quit on Ctrl+C

+                    if let KeyCode::Char('c') = code {

+                        if ctrl {

+                            break;

+                        }

+                    }

+                }

+                Event::Resize(w, h) => {

+                    println!("Resize: {}x{}\r", w, h);

+                }

+                _ => {}

+            }

+        }

+    }

+

+    if enhanced {

+        let _ = execute!(io::stdout(), PopKeyboardEnhancementFlags);

+    }

+    execute!(io::stdout(), LeaveAlternateScreen)?;

+    terminal::disable_raw_mode()?;

+

+    Ok(())

+}

+    PaletteCommand::new("Help / Keybindings", "Shift+F1", "Help", "help"),

+];

+

+/// A keybinding entry for the help menu

+#[derive(Debug, Clone, PartialEq)]

+struct HelpKeybind {

+    /// Keyboard shortcut (e.g., "Ctrl+S")

+    shortcut: &'static str,

+    /// Description of what the keybind does

+    description: &'static str,

+    /// Category for grouping

+    category: &'static str,

+}

+

+impl HelpKeybind {

+    const fn new(shortcut: &'static str, description: &'static str, category: &'static str) -> Self {

+        Self { shortcut, description, category }

+    }

+}

+

+/// All keybindings for the help menu - comprehensive list

+const ALL_KEYBINDS: &[HelpKeybind] = &[

+    // File Operations

+    HelpKeybind::new("Ctrl+S", "Save file", "File"),

+    HelpKeybind::new("Ctrl+O", "Open file browser (Fortress)", "File"),

+    HelpKeybind::new("Ctrl+Q", "Quit editor", "File"),

+    HelpKeybind::new("Ctrl+B / F3", "Toggle file explorer", "File"),

+

+    // Tabs

+    HelpKeybind::new("Alt+T", "New tab", "Tabs"),

+    HelpKeybind::new("Alt+Q", "Close tab/pane", "Tabs"),

+    HelpKeybind::new("Alt+.", "Next tab", "Tabs"),

+    HelpKeybind::new("Alt+,", "Previous tab", "Tabs"),

+    HelpKeybind::new("Alt+1-9", "Switch to tab 1-9", "Tabs"),

+

+    // Panes

+    HelpKeybind::new("Alt+V", "Split vertical", "Panes"),

+    HelpKeybind::new("Alt+S", "Split horizontal", "Panes"),

+    HelpKeybind::new("Alt+H/J/K/L", "Navigate panes (vim-style)", "Panes"),

+    HelpKeybind::new("Alt+N", "Next pane", "Panes"),

+    HelpKeybind::new("Alt+P", "Previous pane", "Panes"),

+

+    // Editing

+    HelpKeybind::new("Ctrl+Z", "Undo", "Edit"),

+    HelpKeybind::new("Ctrl+Shift+Z", "Redo", "Edit"),

+    HelpKeybind::new("Ctrl+C", "Copy", "Edit"),

+    HelpKeybind::new("Ctrl+X", "Cut", "Edit"),

+    HelpKeybind::new("Ctrl+V", "Paste", "Edit"),

+    HelpKeybind::new("Ctrl+J", "Join lines", "Edit"),

+    HelpKeybind::new("Ctrl+/", "Toggle line comment", "Edit"),

+    HelpKeybind::new("Ctrl+T", "Transpose characters", "Edit"),

+    HelpKeybind::new("Tab", "Indent", "Edit"),

+    HelpKeybind::new("Shift+Tab", "Outdent", "Edit"),

+    HelpKeybind::new("Backspace", "Delete backward", "Edit"),

+    HelpKeybind::new("Delete", "Delete forward", "Edit"),

+    HelpKeybind::new("Ctrl+W", "Delete word backward", "Edit"),

+    HelpKeybind::new("Alt+D", "Delete word forward", "Edit"),

+    HelpKeybind::new("Alt+Backspace", "Delete word backward", "Edit"),

+

+    // Line Operations

+    HelpKeybind::new("Alt+Up", "Move line up", "Lines"),

+    HelpKeybind::new("Alt+Down", "Move line down", "Lines"),

+    HelpKeybind::new("Alt+Shift+Up", "Duplicate line up", "Lines"),

+    HelpKeybind::new("Alt+Shift+Down", "Duplicate line down", "Lines"),

+

+    // Movement

+    HelpKeybind::new("Arrow keys", "Move cursor", "Movement"),

+    HelpKeybind::new("Home / Ctrl+A", "Go to line start (smart)", "Movement"),

+    HelpKeybind::new("End / Ctrl+E", "Go to line end", "Movement"),

+    HelpKeybind::new("Alt+Left / Alt+B", "Move word left", "Movement"),

+    HelpKeybind::new("Alt+Right / Alt+F", "Move word right", "Movement"),

+    HelpKeybind::new("PageUp", "Page up", "Movement"),

+    HelpKeybind::new("PageDown", "Page down", "Movement"),

+    HelpKeybind::new("Ctrl+G / F5", "Go to line", "Movement"),

+

+    // Selection

+    HelpKeybind::new("Shift+Arrow", "Extend selection", "Selection"),

+    HelpKeybind::new("Ctrl+L", "Select line", "Selection"),

+    HelpKeybind::new("Ctrl+D", "Select word / next occurrence", "Selection"),

+    HelpKeybind::new("Escape", "Clear selection / collapse cursors", "Selection"),

+    HelpKeybind::new("Ctrl+Alt+Up", "Add cursor above", "Selection"),

+    HelpKeybind::new("Ctrl+Alt+Down", "Add cursor below", "Selection"),

+

+    // Search

+    HelpKeybind::new("Ctrl+F", "Find", "Search"),

+    HelpKeybind::new("Ctrl+R", "Find and replace", "Search"),

+    HelpKeybind::new("F3", "Find next", "Search"),

+    HelpKeybind::new("Shift+F3", "Find previous", "Search"),

+    HelpKeybind::new("F4", "Search in files", "Search"),

+    HelpKeybind::new("Alt+I", "Toggle case sensitivity (in find)", "Search"),

+    HelpKeybind::new("Alt+X", "Toggle regex mode (in find)", "Search"),

+    HelpKeybind::new("Alt+Enter", "Replace all (in find)", "Search"),

+

+    // Brackets & Quotes

+    HelpKeybind::new("Alt+[ / Alt+]", "Jump to matching bracket", "Brackets"),

+    HelpKeybind::new("Alt+'", "Cycle quote type (\"/'/`)", "Brackets"),

+    HelpKeybind::new("Alt+\"", "Remove surrounding quotes", "Brackets"),

+    HelpKeybind::new("Alt+(", "Cycle bracket type (/{/[)", "Brackets"),

+    HelpKeybind::new("Alt+)", "Remove surrounding brackets", "Brackets"),

+

+    // LSP / Code Intelligence

+    HelpKeybind::new("F1", "Show hover info", "LSP"),

+    HelpKeybind::new("F2", "Rename symbol", "LSP"),

+    HelpKeybind::new("F12", "Go to definition", "LSP"),

+    HelpKeybind::new("Shift+F12", "Find references", "LSP"),

+    HelpKeybind::new("Ctrl+N", "Trigger completion", "LSP"),

+    HelpKeybind::new("Alt+M", "LSP server manager", "LSP"),

+

+    // Help & Commands

+    HelpKeybind::new("Ctrl+P", "Command palette", "Help"),

+    HelpKeybind::new("Shift+F1", "Help / keybindings", "Help"),

+

+    // File Explorer (Fortress/Fuss mode)

+    HelpKeybind::new("Up/Down", "Navigate files", "Explorer"),

+    HelpKeybind::new("Enter", "Open file/directory", "Explorer"),

+    HelpKeybind::new("Right", "Expand directory", "Explorer"),

+    HelpKeybind::new("Left", "Collapse / go to parent", "Explorer"),

+    HelpKeybind::new("Space", "Toggle selection", "Explorer"),

+    HelpKeybind::new("a", "Add file", "Explorer"),

+    HelpKeybind::new("d", "Delete selected", "Explorer"),

+    HelpKeybind::new("m", "Move/rename selected", "Explorer"),

+    HelpKeybind::new("p", "Paste", "Explorer"),

+    HelpKeybind::new("u", "Undo last action", "Explorer"),

+    HelpKeybind::new("f", "Create folder", "Explorer"),

+    HelpKeybind::new("t", "Open in new tab", "Explorer"),

+    HelpKeybind::new("l", "Open in vertical split", "Explorer"),

+    HelpKeybind::new("Alt+G", "Git status", "Explorer"),

+    HelpKeybind::new("Alt+.", "Toggle hidden files", "Explorer"),

+    /// Help menu (Shift+F1)

+    HelpMenu {

+        /// Search/filter query

+        query: String,

+        /// Filtered keybinds matching query

+        filtered: Vec<HelpKeybind>,

+        /// Currently selected index

+        selected_index: usize,

+        /// Scroll offset for long lists

+        scroll_offset: usize,

+    },

+            // Render help menu if active

+            if let PromptState::HelpMenu {

+                ref query,

+                ref filtered,

+                selected_index,

+                scroll_offset,

+            } = self.prompt {

+                // Convert keybinds to tuple format for render function

+                let keybinds_tuples: Vec<(String, String, String)> = filtered

+                    .iter()

+                    .map(|kb| (kb.shortcut.to_string(), kb.description.to_string(), kb.category.to_string()))

+                    .collect();

+                self.screen.render_help_menu(

+                    query,

+                    &keybinds_tuples,

+                    selected_index,

+                    scroll_offset,

+                )?;

+                return Ok(()); // Modal handles cursor

+            }

+

+            (Key::F(1), Modifiers { shift: false, .. }) => self.lsp_hover(),

+            // === Help ===

+            // Help / keybindings: Shift+F1

+            (Key::F(1), Modifiers { shift: true, .. }) => self.open_help_menu(),

+

+            PromptState::HelpMenu {

+                ref mut query,

+                ref mut filtered,

+                ref mut selected_index,

+                ref mut scroll_offset,

+            } => {

+                match key {

+                    Key::Escape | Key::Enter => {

+                        self.prompt = PromptState::None;

+                    }

+                    Key::Up => {

+                        if *selected_index > 0 {

+                            *selected_index -= 1;

+                            if *selected_index < *scroll_offset {

+                                *scroll_offset = *selected_index;

+                            }

+                        }

+                    }

+                    Key::Down => {

+                        if *selected_index + 1 < filtered.len() {

+                            *selected_index += 1;

+                            let visible_rows = 18;

+                            if *selected_index >= *scroll_offset + visible_rows {

+                                *scroll_offset = selected_index.saturating_sub(visible_rows - 1);

+                            }

+                        }

+                    }

+                    Key::PageUp => {

+                        *selected_index = selected_index.saturating_sub(10);

+                        if *selected_index < *scroll_offset {

+                            *scroll_offset = *selected_index;

+                        }

+                    }

+                    Key::PageDown => {

+                        *selected_index = (*selected_index + 10).min(filtered.len().saturating_sub(1));

+                        let visible_rows = 18;

+                        if *selected_index >= *scroll_offset + visible_rows {

+                            *scroll_offset = selected_index.saturating_sub(visible_rows - 1);

+                        }

+                    }

+                    Key::Home => {

+                        *selected_index = 0;

+                        *scroll_offset = 0;

+                    }

+                    Key::End => {

+                        *selected_index = filtered.len().saturating_sub(1);

+                        let visible_rows = 18;

+                        *scroll_offset = selected_index.saturating_sub(visible_rows - 1);

+                    }

+                    Key::Backspace => {

+                        if !query.is_empty() {

+                            query.pop();

+                            *filtered = filter_keybinds(query);

+                            *selected_index = 0;

+                            *scroll_offset = 0;

+                        }

+                    }

+                    Key::Char(c) => {

+                        query.push(c);

+                        *filtered = filter_keybinds(query);

+                        *selected_index = 0;

+                        *scroll_offset = 0;

+                    }

+                    _ => {}

+                }

+            }

+            "help" => self.open_help_menu(),

+

+    // === Help Menu ===

+

+    /// Open the help menu with keybindings

+    fn open_help_menu(&mut self) {

+        let filtered = filter_keybinds("");

+        self.prompt = PromptState::HelpMenu {

+            query: String::new(),

+            filtered,

+            selected_index: 0,

+            scroll_offset: 0,

+        };

+    }

+/// Filter keybinds by fuzzy match (for help menu)

+fn filter_keybinds(query: &str) -> Vec<HelpKeybind> {

+    if query.is_empty() {

+        // Return all keybinds in original order (grouped by category)

+        return ALL_KEYBINDS.to_vec();

+    }

+

+    let mut filtered: Vec<(HelpKeybind, i32)> = ALL_KEYBINDS

+        .iter()

+        .filter_map(|kb| {

+            // Match against shortcut, description, or category

+            let shortcut_score = fuzzy_match_score(kb.shortcut, query);

+            let desc_score = fuzzy_match_score(kb.description, query);

+            let category_score = fuzzy_match_score(kb.category, query) / 2;

+

+            let score = shortcut_score.max(desc_score).max(category_score);

+            if score > 0 {

+                Some((kb.clone(), score))

+            } else {

+                None

+            }

+        })

+        .collect();

+

+    // Sort by score descending

+    filtered.sort_by(|a, b| b.1.cmp(&a.1));

+    filtered.into_iter().map(|(kb, _)| kb).collect()

+}

+

+    /// Render the help menu modal (Shift+F1)

+    pub fn render_help_menu(

+        &mut self,

+        query: &str,

+        keybinds: &[(String, String, String)], // (shortcut, description, category)

+        selected_index: usize,

+        scroll_offset: usize,

+    ) -> Result<()> {

+        let (width, height) = (self.cols as usize, self.rows as usize);

+

+        // Modal dimensions - larger to show keybindings comfortably

+        let modal_width = 70.min(width - 4);

+        let modal_height = 24.min(height - 4);

+        let start_col = (width.saturating_sub(modal_width)) / 2;

+        let start_row = 1; // Near top of screen

+

+        // Colors - sleek dark theme matching command palette

+        let bg = Color::AnsiValue(236);

+        let border_color = Color::AnsiValue(240);

+        let title_color = Color::Cyan;

+        let category_color = Color::AnsiValue(243);

+        let shortcut_color = Color::Yellow;

+        let desc_color = Color::White;

+        let selected_bg = Color::AnsiValue(24); // Blue highlight

+        let input_bg = Color::AnsiValue(238);

+

+        // Draw top border with title

+        let title = " Keybindings ";

+        let title_padding = (modal_width.saturating_sub(title.len() + 2)) / 2;

+        execute!(

+            self.stdout,

+            MoveTo(start_col as u16, start_row as u16),

+            SetBackgroundColor(bg),

+            SetForegroundColor(border_color),

+            Print("╭"),

+            Print(format!("{:─<width$}", "", width = title_padding)),

+            SetForegroundColor(title_color),

+            SetAttribute(crossterm::style::Attribute::Bold),

+            Print(title),

+            SetAttribute(crossterm::style::Attribute::Reset),

+            SetForegroundColor(border_color),

+            Print(format!("{:─<width$}", "", width = modal_width.saturating_sub(title_padding + title.len() + 2))),

+            Print("╮"),

+            ResetColor,

+        )?;

+

+        // Draw search input row

+        let display_query = if query.is_empty() { "Type to filter..." } else { query };

+        let input_display_width = modal_width.saturating_sub(6);

+        let placeholder_color = if query.is_empty() { Color::AnsiValue(243) } else { Color::White };

+        execute!(

+            self.stdout,

+            MoveTo(start_col as u16, (start_row + 1) as u16),

+            SetBackgroundColor(bg),

+            SetForegroundColor(border_color),

+            Print("│ "),

+            SetBackgroundColor(input_bg),

+            SetForegroundColor(placeholder_color),

+            Print(format!(" {:<width$}", display_query, width = input_display_width)),

+            SetBackgroundColor(bg),

+            SetForegroundColor(border_color),

+            Print(" │"),

+            ResetColor,

+        )?;

+

+        // Draw separator

+        execute!(

+            self.stdout,

+            MoveTo(start_col as u16, (start_row + 2) as u16),

+            SetBackgroundColor(bg),

+            SetForegroundColor(border_color),

+            Print(format!("├{:─<width$}┤", "", width = modal_width.saturating_sub(2))),

+            ResetColor,

+        )?;

+

+        // Calculate visible range

+        let visible_rows = modal_height.saturating_sub(5);

+

+        // Adjust scroll offset for visibility

+        let scroll = if selected_index < scroll_offset {

+            selected_index

+        } else if selected_index >= scroll_offset + visible_rows {

+            selected_index - visible_rows + 1

+        } else {

+            scroll_offset

+        };

+

+        // Track current category for headers

+        let mut last_category = String::new();

+

+        // Draw keybindings

+        let mut row_offset = 0;

+        for (idx, (shortcut, description, category)) in keybinds.iter().enumerate().skip(scroll) {

+            if row_offset >= visible_rows {

+                break;

+            }

+

+            let row = (start_row + 3 + row_offset) as u16;

+            let is_selected = idx == selected_index;

+

+            // Check if we're starting a new category (only when not filtering)

+            if query.is_empty() && category != &last_category {

+                last_category = category.clone();

+            }

+

+            let item_bg = if is_selected { selected_bg } else { bg };

+

+            // Format: Shortcut (fixed width)   Description

+            let shortcut_width = 20;

+            let desc_width = modal_width.saturating_sub(shortcut_width + 8);

+

+            // Truncate description if needed

+            let display_desc = if description.len() > desc_width {

+                format!("{}…", &description[..desc_width.saturating_sub(1)])

+            } else {

+                description.clone()

+            };

+

+            // Truncate shortcut if needed

+            let display_shortcut = if shortcut.len() > shortcut_width {

+                format!("{}…", &shortcut[..shortcut_width.saturating_sub(1)])

+            } else {

+                shortcut.clone()

+            };

+

+            execute!(

+                self.stdout,

+                MoveTo(start_col as u16, row),

+                SetBackgroundColor(item_bg),

+                SetForegroundColor(border_color),

+                Print("│ "),

+                SetForegroundColor(shortcut_color),

+                SetAttribute(crossterm::style::Attribute::Bold),

+                Print(format!("{:<width$}", display_shortcut, width = shortcut_width)),

+                SetAttribute(crossterm::style::Attribute::Reset),

+                SetBackgroundColor(item_bg),

+                SetForegroundColor(desc_color),

+                Print(format!(" {:<width$}", display_desc, width = desc_width)),

+                SetForegroundColor(category_color),

+                Print(format!(" {:>6}", if row_offset == 0 || query.is_empty() && keybinds.get(idx.wrapping_sub(1)).map(|(_, _, c)| c != category).unwrap_or(true) { category.as_str() } else { "" })),

+                SetForegroundColor(border_color),

+                Print(" │"),

+                ResetColor,

+            )?;

+

+            row_offset += 1;

+        }

+

+        // Fill remaining rows

+        for i in row_offset..visible_rows {

+            let row = (start_row + 3 + i) as u16;

+            execute!(

+                self.stdout,

+                MoveTo(start_col as u16, row),

+                SetBackgroundColor(bg),

+                SetForegroundColor(border_color),

+                Print(format!("│{:width$}│", "", width = modal_width.saturating_sub(2))),

+                ResetColor,

+            )?;

+        }

+

+        // Draw info row

+        let info_row = (start_row + 3 + visible_rows) as u16;

+        let result_count = if keybinds.is_empty() {

+            "No matches".to_string()

+        } else {

+            format!("{} keybinds", keybinds.len())

+        };

+        execute!(

+            self.stdout,

+            MoveTo(start_col as u16, info_row),

+            SetBackgroundColor(bg),

+            SetForegroundColor(border_color),

+            Print("├"),

+            SetForegroundColor(Color::AnsiValue(243)),

+            Print(format!(" {} ", result_count)),

+            SetForegroundColor(border_color),

+            Print(format!("{:─<width$}", "", width = modal_width.saturating_sub(result_count.len() + 4))),

+            Print("┤"),

+            ResetColor,

+        )?;

+

+        // Draw bottom border

+        execute!(

+            self.stdout,

+            MoveTo(start_col as u16, info_row + 1),

+            SetBackgroundColor(bg),

+            SetForegroundColor(border_color),

+            Print(format!("╰{:─<width$}╯", "", width = modal_width.saturating_sub(2))),

+            ResetColor,

+        )?;

+

+        // Show help text below

+        let help_text = "↑↓:scroll  PgUp/PgDn:page  Home/End:jump  Esc:close";

+        execute!(

+            self.stdout,

+            MoveTo(start_col as u16, info_row + 2),

+            SetForegroundColor(Color::AnsiValue(243)),

+            Print(format!("{:^width$}", help_text, width = modal_width)),

+            ResetColor,

+        )?;

+

+        // Hide cursor when in modal

+        execute!(self.stdout, Hide)?;

+

+        self.stdout.flush()?;

+        Ok(())

+    }

+