`99366a9`

feat: fuss fuzzy filter and references panel visual fix

- Add fuzzy filter to fuss mode: type to jump to matching files
- Filter auto-resets after 500ms of inactivity
- Move git operations behind Alt+G prefix (git sub-mode)
- Move toggle hidden behind Alt+.
- Fix references panel row padding calculation
- Add ResetColor after panel rows to prevent color bleed
- Change code completion keybinding from Ctrl+Space to Ctrl+N

Authored by

espadonne 5 months ago

SHA: 99366a9c2b9a6e8f3404b07ed13eb728ed26c70a
Parents: 422bf81
Tree: 996558d

3 changed files

Status	File	+	-
M	`src/editor/state.rs`	63	26
M	`src/fuss/state.rs`	100	0
M	`src/render/screen.rs`	37	6

src/editor/state.rsmodified

+             }
+         }
--        // Update diagnostics for current file
++        // Update diagnostics for current file (need full path to match LSP URIs)
--        if let Some(path) = self.filename() {
++        if let Some(path) = self.current_file_path() {
              let path_str = path.to_string_lossy();
              self.lsp_state.diagnostics = self.workspace.lsp.get_diagnostics(&path_str);
+         }
                      self.workspace.fuss.hints_expanded,
                      &repo_name,
                      branch.as_deref(),
++                    self.workspace.fuss.git_mode,
                  )?;
+             }
+         }
              (Key::F(12), Modifiers { shift: true, .. }) => self.lsp_find_references(),
              // Hover info: F1
              (Key::F(1), _) => self.lsp_hover(),
--            // Code completion: Ctrl+Space
++            // Code completion: Ctrl+N (vim-style)
--            (Key::Char(' '), Modifiers { ctrl: true, .. }) => self.lsp_complete(),
++            (Key::Char('n'), Modifiers { ctrl: true, .. }) => self.lsp_complete(),
              // Rename: F2
              (Key::F(2), _) => self.lsp_rename(),
              // Server manager: Alt+M
+     }
      fn handle_fuss_key(&mut self, key: Key, mods: Modifiers) -> Result<()> {
++        // Handle git mode separately
++        if self.workspace.fuss.git_mode {
++            return self.handle_fuss_git_key(key, mods);
++        }
++
          match (&key, &mods) {
              // Quit: Ctrl+Q (still works in fuss mode)
              (Key::Char('q'), Modifiers { ctrl: true, .. }) => {
              // Exit fuss mode (Escape or F3)
              (Key::Escape, _) | (Key::F(3), _) => {
++                self.workspace.fuss.filter_clear();
                  self.workspace.fuss.deactivate();
+             }
              // Navigation
--            (Key::Up, _) | (Key::Char('k'), Modifiers { ctrl: false, alt: false, .. }) => {
++            (Key::Up, _) => {
++                self.workspace.fuss.filter_clear();
                  self.workspace.fuss.move_up();
+             }
--            (Key::Down, _) | (Key::Char('j'), Modifiers { ctrl: false, alt: false, .. }) => {
++            (Key::Down, _) => {
++                self.workspace.fuss.filter_clear();
                  self.workspace.fuss.move_down();
+             }
              // Toggle expand/collapse directory, or collapse parent if on a file/collapsed dir
              (Key::Char(' '), _) => {
++                self.workspace.fuss.filter_clear();
                  if self.workspace.fuss.is_dir_selected() {
                      // If on a directory, toggle its expand state
                      self.workspace.fuss.toggle_expand();
              // Expand directory (right arrow)
              (Key::Right, _) => {
++                self.workspace.fuss.filter_clear();
                  if self.workspace.fuss.is_dir_selected() {
                      // Only expand if not already expanded
                      if let Some(ref tree) = self.workspace.fuss.tree {
              // Collapse directory or go to parent (left arrow)
              (Key::Left, _) => {
++                self.workspace.fuss.filter_clear();
                  let mut collapsed = false;
                  if self.workspace.fuss.is_dir_selected() {
                      // If on an expanded directory, collapse it
+             }
              // Open file or toggle directory
--            (Key::Enter, _) | (Key::Char('o'), Modifiers { ctrl: false, alt: false, .. }) => {
++            (Key::Enter, _) => {
++                self.workspace.fuss.filter_clear();
                  if self.workspace.fuss.is_dir_selected() {
                      self.workspace.fuss.toggle_expand();
                  } else if let Some(path) = self.workspace.fuss.selected_file() {
+                 }
+             }
--            // Toggle hidden files
++            // Toggle hidden files: Alt+.
--            (Key::Char('.'), _) => {
++            (Key::Char('.'), Modifiers { alt: true, .. }) => {
                  self.workspace.fuss.toggle_hidden();
+             }
                  self.workspace.fuss.toggle_hints();
+             }
--            // Also allow 'h' for hints toggle as fallback
++            // Open file in vertical split: Ctrl+V
--            (Key::Char('h'), Modifiers { ctrl: false, alt: false, .. }) => {
++            (Key::Char('v'), Modifiers { ctrl: true, .. }) => {
--                self.workspace.fuss.toggle_hints();
--            }
--
--            // Open file in vertical split (v)
--            (Key::Char('v'), Modifiers { ctrl: false, alt: false, .. }) => {
                  if !self.workspace.fuss.is_dir_selected() {
                      if let Some(path) = self.workspace.fuss.selected_file() {
                          self.open_file_in_vsplit(&path)?;
+                 }
+             }
--            // Open file in horizontal split (s)
++            // Open file in horizontal split: Ctrl+S
--            (Key::Char('s'), Modifiers { ctrl: false, alt: false, .. }) => {
++            (Key::Char('s'), Modifiers { ctrl: true, .. }) => {
                  if !self.workspace.fuss.is_dir_selected() {
                      if let Some(path) = self.workspace.fuss.selected_file() {
                          self.open_file_in_hsplit(&path)?;
+                 }
+             }
++            // Enter git mode: Alt+G
++            (Key::Char('g'), Modifiers { alt: true, .. }) => {
++                self.workspace.fuss.enter_git_mode();
++                self.message = Some("Git: [a]dd [u]nstage [d]iff [m]sg [p]ush pu[l]l [f]etch [t]ag".to_string());
++            }
++
++            // Backspace: remove last filter character
++            (Key::Backspace, _) => {
++                self.workspace.fuss.filter_pop();
++            }
++
++            // Regular characters: add to filter for fuzzy jump
++            (Key::Char(c), Modifiers { ctrl: false, alt: false, .. }) => {
++                self.workspace.fuss.filter_push(*c);
++            }
++
++            _ => {}
++        }
++        Ok(())
++    }
++
++    /// Handle keys when in git sub-mode within fuss
++    fn handle_fuss_git_key(&mut self, key: Key, mods: Modifiers) -> Result<()> {
++        // Any key exits git mode (after potentially doing an action)
++        self.workspace.fuss.exit_git_mode();
++        self.message = None;
++
++        match (&key, &mods) {
              // Git: Stage file (a)
--            (Key::Char('a'), Modifiers { ctrl: false, alt: false, .. }) => {
++            (Key::Char('a'), _) => {
                  if self.workspace.fuss.stage_selected() {
                      self.message = Some("Staged".to_string());
                  } else {
+             }
              // Git: Unstage file (u)
--            (Key::Char('u'), Modifiers { ctrl: false, alt: false, .. }) => {
++            (Key::Char('u'), _) => {
                  if self.workspace.fuss.unstage_selected() {
                      self.message = Some("Unstaged".to_string());
                  } else {
+             }
              // Git: Show diff (d)
--            (Key::Char('d'), Modifiers { ctrl: false, alt: false, .. }) => {
++            (Key::Char('d'), _) => {
                  if let Some((filename, diff)) = self.workspace.fuss.get_diff_for_selected() {
                      let display_name = format!("[diff] {}", filename);
                      self.workspace.open_content_tab(&diff, &display_name);
+             }
              // Git: Commit (m) - opens prompt for commit message
--            (Key::Char('m'), Modifiers { ctrl: false, alt: false, .. }) => {
++            (Key::Char('m'), _) => {
                  self.prompt = PromptState::TextInput {
                      label: "Commit message: ".to_string(),
                      buffer: String::new(),
+             }
              // Git: Push (p)
--            (Key::Char('p'), Modifiers { ctrl: false, alt: false, .. }) => {
++            (Key::Char('p'), _) => {
                  let (_, msg) = self.workspace.fuss.git_push();
                  self.message = Some(msg);
+             }
              // Git: Pull (l)
--            (Key::Char('l'), Modifiers { ctrl: false, alt: false, .. }) => {
++            (Key::Char('l'), _) => {
                  let (_, msg) = self.workspace.fuss.git_pull();
                  self.message = Some(msg);
+             }
              // Git: Fetch (f)
--            (Key::Char('f'), Modifiers { ctrl: false, alt: false, .. }) => {
++            (Key::Char('f'), _) => {
                  let (_, msg) = self.workspace.fuss.git_fetch();
                  self.message = Some(msg);
+             }
              // Git: Tag (t) - opens prompt for tag name
--            (Key::Char('t'), Modifiers { ctrl: false, alt: false, .. }) => {
++            (Key::Char('t'), _) => {
                  self.prompt = PromptState::TextInput {
                      label: "Tag name: ".to_string(),
                      buffer: String::new(),
                  self.message = Some("Enter tag name (Enter to create, Esc to cancel)".to_string());
+             }
++            // Escape or any other key just cancels git mode
              _ => {}
+         }
          Ok(())

src/fuss/state.rsmodified

  use std::path::{Path, PathBuf};
  use std::process::Command;
++use std::time::Instant;
  use super::tree::FileTree;
++/// Timeout for filter reset (in milliseconds)
++const FILTER_TIMEOUT_MS: u128 = 500;
++
  /// Fuss mode state
  #[derive(Debug)]
  pub struct FussMode {
      pub hints_expanded: bool,
      /// Workspace root path
      root_path: Option<PathBuf>,
++    /// Current fuzzy filter query
++    pub filter: String,
++    /// Last time a filter character was typed
++    filter_last_input: Option<Instant>,
++    /// Whether git mode is active (after pressing Alt+G)
++    pub git_mode: bool,
+ }
  impl Default for FussMode {
              width_percent: 30,
              hints_expanded: false,
              root_path: None,
++            filter: String::new(),
++            filter_last_input: None,
++            git_mode: false,
+         }
+     }
+ }
              None
+         }
+     }
++
++    /// Add a character to the filter and jump to first match
++    /// Resets the filter if too much time has passed since last input
++    pub fn filter_push(&mut self, c: char) {
++        let now = Instant::now();
++
++        // Check if we should reset the filter due to timeout
++        if let Some(last) = self.filter_last_input {
++            if now.duration_since(last).as_millis() > FILTER_TIMEOUT_MS {
++                self.filter.clear();
++            }
++        }
++
++        self.filter.push(c);
++        self.filter_last_input = Some(now);
++        self.jump_to_filter_match();
++    }
++
++    /// Remove last character from filter
++    pub fn filter_pop(&mut self) {
++        self.filter.pop();
++        if !self.filter.is_empty() {
++            self.jump_to_filter_match();
++        }
++    }
++
++    /// Clear the filter
++    pub fn filter_clear(&mut self) {
++        self.filter.clear();
++        self.filter_last_input = None;
++    }
++
++    /// Jump to the first item matching the current filter (fuzzy match)
++    fn jump_to_filter_match(&mut self) {
++        if self.filter.is_empty() {
++            return;
++        }
++
++        let tree = match &self.tree {
++            Some(t) => t,
++            None => return,
++        };
++
++        let items = tree.visible_items();
++        let query = self.filter.to_lowercase();
++
++        // Find best matching item starting from current position + 1
++        // This allows pressing the same keys repeatedly to cycle through matches
++        let start = (self.selected + 1) % items.len().max(1);
++
++        // First try: find match starting from current position
++        for offset in 0..items.len() {
++            let idx = (start + offset) % items.len();
++            let name = items[idx].name.to_lowercase();
++
++            if fuzzy_match(&name, &query) {
++                self.selected = idx;
++                return;
++            }
++        }
++    }
++
++    /// Enter git mode (after Alt+G)
++    pub fn enter_git_mode(&mut self) {
++        self.git_mode = true;
++    }
++
++    /// Exit git mode
++    pub fn exit_git_mode(&mut self) {
++        self.git_mode = false;
++    }
++}
++
++/// Simple fuzzy matching: checks if query characters appear in order in the target
++fn fuzzy_match(target: &str, query: &str) -> bool {
++    let mut query_chars = query.chars().peekable();
++
++    for c in target.chars() {
++        if query_chars.peek() == Some(&c) {
++            query_chars.next();
++        }
++        if query_chars.peek().is_none() {
++            return true;
++        }
++    }
++
++    query_chars.peek().is_none()
+ }

src/render/screen.rsmodified

          hints_expanded: bool,
          repo_name: &str,
          branch: Option<&str>,
++        git_mode: bool,
      ) -> Result<()> {
          let width = width as usize;
          let text_rows = self.rows.saturating_sub(1) as usize;
          let hint_rows = if hints_expanded { 4 } else { 1 };
--        let header_rows = 2; // Header line + separator
++        // Header line + separator + optional git mode line
++        let header_rows = if git_mode { 3 } else { 2 };
          let tree_rows = text_rows.saturating_sub(hint_rows + header_rows);
          // Draw header: repo_name:branch
              ResetColor,
          )?;
++        // Draw git mode indicator line
++        if git_mode {
++            let git_row = 2u16;
++            execute!(self.stdout, MoveTo(0, git_row))?;
++            let git_hint = "Git: a/u/d/m/p/l/f/t";
++            let padded = format!("{:<width$}", git_hint, width = width);
++            execute!(
++                self.stdout,
++                SetBackgroundColor(Color::AnsiValue(235)),
++                SetForegroundColor(Color::Yellow),
++                Print(&padded),
++                ResetColor,
++            )?;
++        }
++
          // Draw file tree (starting after header)
          for row in 0..tree_rows {
              let screen_row = (row + header_rows) as u16;
          let hint_start = header_rows + tree_rows;
          if hints_expanded {
              let hints = [
--                "j/k:nav spc:toggle o:open .:hidden",
++                "type:jump  spc:toggle  enter:open",
--                "a:stage u:unstage d:diff m:commit",
++                "alt-.:hidden  alt-g:git  ctrl-v/s:split",
--                "p:push l:pull f:fetch t:tag",
++                "ctrl-b:close  ctrl-/:hints",
--                "ctrl-b:close ctrl-/:hints",
++                "",
              ];
              for (i, hint) in hints.iter().enumerate() {
                  if hint_start + i < text_rows {
              Print(&title),
              SetForegroundColor(border_color),
              Print(format!("{:─<width$}┐", "", width = panel_width.saturating_sub(title.len() + 2))),
++            ResetColor,
          )?;
          // Draw filter input row
              SetBackgroundColor(bg),
              SetForegroundColor(border_color),
              Print("│"),
++            ResetColor,
          )?;
          // Draw separator
              SetBackgroundColor(bg),
              SetForegroundColor(border_color),
              Print(format!("├{:─<width$}┤", "", width = panel_width.saturating_sub(2))),
++            ResetColor,
          )?;
          // Calculate visible range with scrolling
              let item_bg = if is_selected { selected_bg } else { bg };
++            // Build a fixed-width line: "│ " + path (padded to max_path_width) + line_info + " │"
++            // Total: 2 + max_path_width + line_info.len() + 2 = panel_width
++            // So we need: max_path_width = panel_width - line_info.len() - 4
++            // The remaining padding goes after line_info
++            let remaining = panel_width.saturating_sub(max_path_width + line_info.len() + 4);
++
              execute!(
                  self.stdout,
                  MoveTo(start_col as u16, row),
                  Print(format!("{:<width$}", truncated_path, width = max_path_width)),
                  SetForegroundColor(line_num_color),
                  Print(&line_info),
++                Print(format!("{:width$}", "", width = remaining)),
                  SetForegroundColor(border_color),
--                Print(format!("{:>width$}│", "", width = panel_width.saturating_sub(truncated_path.len() + line_info.len() + 3))),
++                Print(" │"),
++                ResetColor,
              )?;
          }
                  SetBackgroundColor(bg),
                  SetForegroundColor(border_color),
                  Print(format!("│{:width$}│", "", width = panel_width.saturating_sub(2))),
++                ResetColor,
              )?;
          }
              Print(format!(" {:<width$}", help_text, width = panel_width.saturating_sub(3))),
              SetForegroundColor(border_color),
              Print("┤"),
++            ResetColor,
          )?;
          // Draw bottom border
          // Hide cursor when in references panel
          execute!(self.stdout, Hide)?;
++        self.stdout.flush()?;
          Ok(())
      }