`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
 -        if let Some(path) = self.filename() {
 +        // Update diagnostics for current file (need full path to match LSP URIs)
 +        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
 -            (Key::Char(' '), Modifiers { ctrl: true, .. }) => self.lsp_complete(),
 +            // Code completion: Ctrl+N (vim-style)
 +            (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
 -            (Key::Char('.'), _) => {
 +            // Toggle hidden files: Alt+.
 +            (Key::Char('.'), Modifiers { alt: true, .. }) => {
                  self.workspace.fuss.toggle_hidden();
+             }
                  self.workspace.fuss.toggle_hints();
+             }
 -            // Also allow 'h' for hints toggle as fallback
 -            (Key::Char('h'), Modifiers { ctrl: false, alt: false, .. }) => {
 -                self.workspace.fuss.toggle_hints();
 -            }
+-
 -            // Open file in vertical split (v)
 -            (Key::Char('v'), Modifiers { ctrl: false, alt: false, .. }) => {
 +            // Open file in vertical split: Ctrl+V
 +            (Key::Char('v'), Modifiers { ctrl: true, .. }) => {
                  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)
 -            (Key::Char('s'), Modifiers { ctrl: false, alt: false, .. }) => {
 +            // Open file in horizontal split: Ctrl+S
 +            (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",
 -                "a:stage u:unstage d:diff m:commit",
 -                "p:push l:pull f:fetch t:tag",
 -                "ctrl-b:close ctrl-/:hints",
 +                "type:jump  spc:toggle  enter:open",
 +                "alt-.:hidden  alt-g:git  ctrl-v/s:split",
 +                "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(())
+     }