`5212888`

implement fuzzy jumping for faster staging. fix commit modalss

Authored by

espadonne 5 months ago

SHA: 52128880944c5d54ce5ee3f45c010314637d4029
Parents: f782186
Tree: d18cf37

5 changed files

Status	File	+	-
M	`src/app.rs`	203	34
M	`src/git.rs`	30	20
M	`src/main.rs`	110	50
M	`src/types.rs`	10	1
M	`src/ui.rs`	66	18

src/app.rsmodified

  use crate::tree::{build_tree, flatten_tree, toggle_expanded};
  use crate::types::{AppMode, FileEntry, InputMode, SelectableItem, TreeNode};
  use std::path::PathBuf;
 +use std::time::Instant;
  /// Main application state
  pub struct App {
      pub should_quit: bool,
      /// Status message to display
      pub status_message: Option<String>,
 +    /// Fuzzy search buffer
 +    pub search_buffer: String,
 +    /// Last search keystroke time (for timeout)
 +    pub last_search_time: Option<Instant>,
+ }
  impl App {
              input_mode: InputMode::Navigation,
              should_quit: false,
              status_message: None,
 +            search_buffer: String::new(),
 +            last_search_time: None,
          };
          app.refresh_files()?;
              buffer: initial_buffer,
              cursor,
              amend,
 +            status: crate::types::CommitStatus::Editing,
          };
+     }
 -    /// Apply commit
 +    /// Start the commit process (show "Committing..." state)
 +    pub fn start_commit(&mut self) {
 +        if let InputMode::Commit { status, .. } = &mut self.input_mode {
 +            *status = crate::types::CommitStatus::Committing;
 +        }
 +    }
++
 +    /// Apply commit and update status
      pub fn apply_commit(&mut self) -> Result<()> {
 -        if let InputMode::Commit { buffer, amend, .. } = &self.input_mode {
 -            let message = buffer.trim();
 -            if !message.is_empty() {
 -                if *amend {
 -                    self.repo.commit_amend(message)?;
 -                    self.set_status("Commit amended".to_string());
 -                } else {
 -                    self.repo.commit(message)?;
 -                    self.set_status("Committed".to_string());
 +        // Extract values we need before modifying
 +        let (message, amend) = if let InputMode::Commit { buffer, amend, .. } = &self.input_mode {
 +            (buffer.trim().to_string(), *amend)
 +        } else {
 +            return Ok(());
 +        };
++
 +        if message.is_empty() {
 +            self.input_mode = InputMode::Navigation;
 +            return Ok(());
 +        }
++
 +        // Perform the commit
 +        let result = if amend {
 +            self.repo.commit_amend(&message)
 +        } else {
 +            self.repo.commit(&message)
 +        };
++
 +        // Update status based on result
 +        match result {
 +            Ok(()) => {
 +                if let InputMode::Commit { status, .. } = &mut self.input_mode {
 +                    *status = crate::types::CommitStatus::Success;
+                 }
 +                self.set_status("Committed".to_string());
                  self.refresh_files()?;
+             }
 +            Err(_) => {
 +                if let InputMode::Commit { status, .. } = &mut self.input_mode {
 +                    *status = crate::types::CommitStatus::Failed;
 +                }
 +            }
+         }
 -        self.input_mode = InputMode::Navigation;
++
          Ok(())
+     }
 +    /// Close commit modal and return to navigation
 +    pub fn close_commit(&mut self) {
 +        self.input_mode = InputMode::Navigation;
 +    }
++
      /// Cancel commit mode
      pub fn cancel_commit(&mut self) {
          self.input_mode = InputMode::Navigation;
+     }
 -    /// Fuzzy search and jump to match
 -    pub fn fuzzy_jump(&mut self, pattern: &str) {
 -        if pattern.is_empty() {
 +    /// Check if search timeout has elapsed (0.5 seconds) and reset if needed
 +    pub fn check_search_timeout(&mut self) {
 +        if let Some(last_time) = self.last_search_time {
 +            if last_time.elapsed().as_millis() > 500 {
 +                self.search_buffer.clear();
 +                self.last_search_time = None;
 +            }
 +        }
 +    }
++
 +    /// Add a character to the search buffer and jump to match
 +    pub fn search_add_char(&mut self, c: char) {
 +        // Check timeout first - if elapsed, start fresh
 +        self.check_search_timeout();
++
 +        // Add character to buffer
 +        if self.search_buffer.len() < 32 {
 +            self.search_buffer.push(c);
 +            self.last_search_time = Some(Instant::now());
++
 +            // Jump to best match
 +            self.fuzzy_jump_to_match();
 +        }
 +    }
++
 +    /// Remove last character from search buffer
 +    pub fn search_backspace(&mut self) {
 +        if !self.search_buffer.is_empty() {
 +            self.search_buffer.pop();
 +            self.last_search_time = Some(Instant::now());
++
 +            if !self.search_buffer.is_empty() {
 +                self.fuzzy_jump_to_match();
 +            }
 +        }
 +    }
++
 +    /// Clear the search buffer
 +    pub fn clear_search(&mut self) {
 +        self.search_buffer.clear();
 +        self.last_search_time = None;
 +    }
++
 +    /// Jump to the best matching item using fzf-style scoring
 +    fn fuzzy_jump_to_match(&mut self) {
 +        if self.search_buffer.is_empty() || self.items.is_empty() {
              return;
+         }
 -        let pattern_lower = pattern.to_lowercase();
 +        let pattern = self.search_buffer.to_lowercase();
          let mut best_idx = self.selected;
 -        let mut best_score = 0;
 +        let mut best_score: i32 = 0;
++
 +        // Check current item first - if exact match, stay on it
 +        if let Some(item) = self.items.get(self.selected) {
 +            let current_score = fuzzy_match_score(&pattern, &item.name.to_lowercase());
 +            if current_score >= 10000 {
 +                return; // Exact match - stay here
 +            }
 +            best_score = current_score;
 +        }
++
 +        // PASS 1: Search for basename matches (file/folder names)
 +        for (i, item) in self.items.iter().enumerate() {
 +            if i == self.selected {
 +                continue;
 +            }
 +            let score = fuzzy_match_score(&pattern, &item.name.to_lowercase());
 +            if score > best_score {
 +                best_score = score;
 +                best_idx = i;
 +            }
 +        }
++
 +        // If we found a good basename match (prefix or exact), use it
 +        if best_score >= 5000 {
 +            self.selected = best_idx;
 +            return;
 +        }
 +        // PASS 2: Search full paths if no good basename match
          for (i, item) in self.items.iter().enumerate() {
 -            let score = fuzzy_score(&pattern_lower, &item.name.to_lowercase());
 +            if i == self.selected {
 +                continue;
 +            }
 +            let path_str = item.path.to_string_lossy().to_lowercase();
 +            let score = fuzzy_match_score(&pattern, &path_str);
              if score > best_score {
                  best_score = score;
                  best_idx = i;
+             }
+         }
 +        // Jump to best match if any was found
          if best_score > 0 {
              self.selected = best_idx;
+         }
+     }
+ }
 -/// Simple fuzzy matching score
 -fn fuzzy_score(pattern: &str, text: &str) -> usize {
 +/// Fuzzy matching with fzf-style scoring
 +/// Returns a score (higher is better), 0 means no match
 +fn fuzzy_match_score(pattern: &str, text: &str) -> i32 {
 +    if pattern.is_empty() {
 +        return 1;
 +    }
++
 +    // Exact match (highest score)
 +    if pattern == text {
 +        return 10000;
 +    }
++
 +    // Prefix match (very high score)
      if text.starts_with(pattern) {
 -        return 1000 + (100 - text.len()); // Prefix match bonus
 +        return 5000;
+     }
 -    let mut score = 0;
 -    let mut pattern_idx = 0;
 +    // Fuzzy match with scoring
      let pattern_chars: Vec<char> = pattern.chars().collect();
 -    let mut consecutive = 0;
 +    let text_chars: Vec<char> = text.chars().collect();
++
 +    let mut score: i32 = 0;
 +    let mut pattern_idx = 0;
 +    let mut consecutive_bonus: i32 = 0;
 +    let mut is_consecutive = false;
 +    let mut match_started = false;
++
 +    for (text_idx, &c) in text_chars.iter().enumerate() {
 +        if pattern_idx >= pattern_chars.len() {
 +            break;
 +        }
++
 +        if c == pattern_chars[pattern_idx] {
 +            match_started = true;
++
 +            // Base score for each matched character
 +            score += 100;
++
 +            // Bonus for consecutive characters
 +            if is_consecutive {
 +                consecutive_bonus += 1;
 +                score += consecutive_bonus * 50;
 +            } else {
 +                consecutive_bonus = 1;
 +                is_consecutive = true;
 +            }
 -    for (i, c) in text.chars().enumerate() {
 -        if pattern_idx < pattern_chars.len() && c == pattern_chars[pattern_idx] {
 -            score += 10 + consecutive * 5;
 -            if i == 0 {
 -                score += 20; // Start match bonus
 +            // Bonus for matching at start of text
 +            if text_idx == 0 {
 +                score += 200;
 +            }
++
 +            // Bonus for matching after separator (word boundary)
 +            if text_idx > 0 {
 +                let prev = text_chars[text_idx - 1];
 +                if prev == '/' || prev == '_' || prev == '-' || prev == '.' {
 +                    score += 150;
 +                }
+             }
 -            consecutive += 1;
++
              pattern_idx += 1;
          } else {
 -            consecutive = 0;
 +            // Reset consecutive bonus
 +            is_consecutive = false;
 +            consecutive_bonus = 0;
 +            // Small penalty for gaps
 +            if match_started {
 +                score -= 1;
 +            }
+         }
+     }
 -    if pattern_idx == pattern_chars.len() {
 -        score
 -    } else {
 -        0 // Not all chars matched
 +    // No match if we didn't find all pattern characters
 +    if pattern_idx < pattern_chars.len() {
 +        return 0;
+     }
++
 +    // Penalty for longer strings (prefer concise matches)
 +    score -= text.len() as i32;
++
 +    score.max(1) // Ensure positive score if we matched
+ }

src/git.rsmodified

          Ok(())
+     }
 -    /// Create a commit with the given message
 +    /// Create a commit with the given message (captures output to not corrupt TUI)
      pub fn commit(&self, message: &str) -> Result<()> {
 -        let status = Command::new("git")
 +        let output = Command::new("git")
              .args(["commit", "-m", message])
 -            .status()?;
 +            .stdout(std::process::Stdio::piped())
 +            .stderr(std::process::Stdio::piped())
 +            .output()?;
 -        if status.success() {
 +        if output.status.success() {
              Ok(())
          } else {
              Err(FussrError::Git(git2::Error::from_str("Failed to commit")))
+         }
+     }
 -    /// Amend the last commit
 +    /// Amend the last commit (captures output to not corrupt TUI)
      pub fn commit_amend(&self, message: &str) -> Result<()> {
 -        let status = Command::new("git")
 +        let output = Command::new("git")
              .args(["commit", "--amend", "-m", message])
 -            .status()?;
 +            .stdout(std::process::Stdio::piped())
 +            .stderr(std::process::Stdio::piped())
 +            .output()?;
 -        if status.success() {
 +        if output.status.success() {
              Ok(())
          } else {
              Err(FussrError::Git(git2::Error::from_str("Failed to amend commit")))
+         }
+     }
 -    /// Fetch from remote
 +    /// Fetch from remote (captures output to not corrupt TUI)
      pub fn fetch(&self) -> Result<()> {
 -        let status = Command::new("git")
 +        let output = Command::new("git")
              .args(["fetch"])
 -            .status()?;
 +            .stdout(std::process::Stdio::piped())
 +            .stderr(std::process::Stdio::piped())
 +            .output()?;
 -        if status.success() {
 +        if output.status.success() {
              Ok(())
          } else {
              Err(FussrError::Git(git2::Error::from_str("Failed to fetch")))
+         }
+     }
 -    /// Pull from remote
 +    /// Pull from remote (captures output to not corrupt TUI)
      pub fn pull(&self) -> Result<()> {
 -        let status = Command::new("git")
 +        let output = Command::new("git")
              .args(["pull"])
 -            .status()?;
 +            .stdout(std::process::Stdio::piped())
 +            .stderr(std::process::Stdio::piped())
 +            .output()?;
 -        if status.success() {
 +        if output.status.success() {
              Ok(())
          } else {
              Err(FussrError::Git(git2::Error::from_str("Failed to pull")))
+         }
+     }
 -    /// Push to remote
 +    /// Push to remote (captures output to not corrupt TUI)
      pub fn push(&self) -> Result<()> {
 -        let status = Command::new("git")
 +        let output = Command::new("git")
              .args(["push"])
 -            .status()?;
 +            .stdout(std::process::Stdio::piped())
 +            .stderr(std::process::Stdio::piped())
 +            .output()?;
 -        if status.success() {
 +        if output.status.success() {
              Ok(())
          } else {
              Err(FussrError::Git(git2::Error::from_str("Failed to push")))

src/main.rsmodified

  /// Handle keys in navigation mode
  fn handle_navigation_key(app: &mut App, code: KeyCode, modifiers: KeyModifiers) -> Result<()> {
 +    // Check search timeout on every key
 +    app.check_search_timeout();
++
      // Check for Alt+key combinations
      if modifiers.contains(KeyModifiers::ALT) {
          match code {
          return Ok(());
+     }
 +    // In normal mode, handle fuzzy search for printable characters
 +    if app.mode == AppMode::Normal {
 +        match code {
 +            // Fuzzy search - letters, numbers, and common filename chars
 +            KeyCode::Char(c) if c.is_ascii_alphanumeric() || c == '_' || c == '-' => {
 +                app.search_add_char(c);
 +                return Ok(());
 +            }
 +            // Backspace removes from search buffer
 +            KeyCode::Backspace => {
 +                if !app.search_buffer.is_empty() {
 +                    app.search_backspace();
 +                    return Ok(());
 +                }
 +            }
 +            // ESC clears search buffer in normal mode
 +            KeyCode::Esc => {
 +                if !app.search_buffer.is_empty() {
 +                    app.clear_search();
 +                    return Ok(());
 +                }
 +            }
 +            _ => {}
 +        }
 +    }
++
      match code {
 -        // Navigation
 -        KeyCode::Char('j') | KeyCode::Down => app.navigate_down(),
 -        KeyCode::Char('k') | KeyCode::Up => app.navigate_up(),
 -        KeyCode::Left => app.navigate_left(),
 -        KeyCode::Right => app.navigate_right(),
 -        KeyCode::Char(' ') => app.toggle_selected(),
 +        // Navigation (clears search buffer)
 +        KeyCode::Char('j') | KeyCode::Down => {
 +            app.clear_search();
 +            app.navigate_down();
 +        }
 +        KeyCode::Char('k') | KeyCode::Up => {
 +            app.clear_search();
 +            app.navigate_up();
 +        }
 +        KeyCode::Left => {
 +            app.clear_search();
 +            app.navigate_left();
 +        }
 +        KeyCode::Right => {
 +            app.clear_search();
 +            app.navigate_right();
 +        }
 +        KeyCode::Char(' ') => {
 +            app.clear_search();
 +            app.toggle_selected();
 +        }
          KeyCode::Char('.') => app.toggle_dotfiles(),
          // Mode switching
              app.delete_selected()?;
+         }
          KeyCode::Char('f') if app.mode == AppMode::Git => {
 -            app.fetch()?;
 +            match app.fetch() {
 +                Ok(()) => {}
 +                Err(e) => app.set_status(format!("Fetch failed: {}", e)),
 +            }
+         }
          KeyCode::Char('l') if app.mode == AppMode::Git => {
 -            app.pull()?;
 +            match app.pull() {
 +                Ok(()) => {}
 +                Err(e) => app.set_status(format!("Pull failed: {}", e)),
 +            }
+         }
          KeyCode::Char('p') if app.mode == AppMode::Git => {
 -            app.push()?;
 +            match app.push() {
 +                Ok(()) => {}
 +                Err(e) => app.set_status(format!("Push failed: {}", e)),
 +            }
+         }
          KeyCode::Char('m') if app.mode == AppMode::Git => {
              app.enter_commit_mode(false);
  /// Handle keys in commit mode
  fn handle_commit_key(app: &mut App, code: KeyCode) -> Result<()> {
 -    match code {
 -        KeyCode::Esc => app.cancel_commit(),
 -        KeyCode::Enter => app.apply_commit()?,
 -        KeyCode::Backspace => {
 -            if let InputMode::Commit { buffer, cursor, .. } = &mut app.input_mode {
 -                if *cursor > 0 {
 -                    buffer.remove(*cursor - 1);
 -                    *cursor -= 1;
 +    use crate::types::CommitStatus;
++
 +    // Get current status
 +    let status = if let InputMode::Commit { status, .. } = &app.input_mode {
 +        status.clone()
 +    } else {
 +        return Ok(());
 +    };
++
 +    match status {
 +        CommitStatus::Editing => {
 +            // Normal editing mode
 +            match code {
 +                KeyCode::Esc => app.cancel_commit(),
 +                KeyCode::Enter => app.apply_commit()?,
 +                KeyCode::Backspace => {
 +                    if let InputMode::Commit { buffer, cursor, .. } = &mut app.input_mode {
 +                        if *cursor > 0 {
 +                            buffer.remove(*cursor - 1);
 +                            *cursor -= 1;
 +                        }
 +                    }
+                 }
 -            }
 -        }
 -        KeyCode::Left => {
 -            if let InputMode::Commit { cursor, .. } = &mut app.input_mode {
 -                if *cursor > 0 {
 -                    *cursor -= 1;
 +                KeyCode::Left => {
 +                    if let InputMode::Commit { cursor, .. } = &mut app.input_mode {
 +                        if *cursor > 0 {
 +                            *cursor -= 1;
 +                        }
 +                    }
+                 }
 -            }
 -        }
 -        KeyCode::Right => {
 -            if let InputMode::Commit { buffer, cursor, .. } = &mut app.input_mode {
 -                if *cursor < buffer.len() {
 -                    *cursor += 1;
 +                KeyCode::Right => {
 +                    if let InputMode::Commit { buffer, cursor, .. } = &mut app.input_mode {
 +                        if *cursor < buffer.len() {
 +                            *cursor += 1;
 +                        }
 +                    }
 +                }
 +                KeyCode::Char(c) => {
 +                    if let InputMode::Commit { buffer, cursor, .. } = &mut app.input_mode {
 +                        buffer.insert(*cursor, c);
 +                        *cursor += 1;
 +                    }
+                 }
 +                _ => {}
+             }
+         }
 -        KeyCode::Char(c) => {
 -            if let InputMode::Commit { buffer, cursor, .. } = &mut app.input_mode {
 -                buffer.insert(*cursor, c);
 -                *cursor += 1;
 -            }
 +        CommitStatus::Committing => {
 +            // Don't respond to keys while committing
 +        }
 +        CommitStatus::Success | CommitStatus::Failed => {
 +            // Any key closes the modal
 +            app.close_commit();
+         }
 -        _ => {}
+     }
      Ok(())
+ }
 -/// Handle keys in search mode
 +/// Handle keys in search mode (legacy - not currently used)
  fn handle_search_key(app: &mut App, code: KeyCode) -> Result<()> {
      match code {
          KeyCode::Esc => {
              app.input_mode = InputMode::Navigation;
+         }
          KeyCode::Backspace => {
 -            // Extract, modify, and reassign to avoid borrow conflicts
              if let InputMode::Search { buffer } = &mut app.input_mode {
                  buffer.pop();
+             }
 -            // Now do fuzzy jump with cloned buffer
 -            if let InputMode::Search { buffer } = &app.input_mode {
 -                if !buffer.is_empty() {
 -                    let pattern = buffer.clone();
 -                    app.fuzzy_jump(&pattern);
 -                }
 -            }
+         }
          KeyCode::Char(c) => {
 -            // Extract, modify, and reassign to avoid borrow conflicts
              if let InputMode::Search { buffer } = &mut app.input_mode {
                  buffer.push(c);
+             }
 -            // Now do fuzzy jump with cloned buffer
 -            if let InputMode::Search { buffer } = &app.input_mode {
 -                let pattern = buffer.clone();
 -                app.fuzzy_jump(&pattern);
 -            }
+         }
          _ => {}
+     }

src/types.rsmodified

+     }
+ }
 +/// Status of commit operation
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub enum CommitStatus {
 +    Editing,
 +    Committing,
 +    Success,
 +    Failed,
 +}
++
  /// Input mode for special states
  #[derive(Debug, Clone, PartialEq, Eq)]
  pub enum InputMode {
      Navigation,
      Rename { buffer: String, cursor: usize },
      Search { buffer: String },
 -    Commit { buffer: String, cursor: usize, amend: bool },
 +    Commit { buffer: String, cursor: usize, amend: bool, status: CommitStatus },
      Confirm { message: String, action: ConfirmAction },
+ }

src/ui.rsmodified

  use crate::app::App;
 -use crate::types::{AppMode, InputMode, SelectableItem};
 +use crate::types::{AppMode, CommitStatus, InputMode, SelectableItem};
  use ratatui::{
      layout::{Constraint, Direction, Layout, Rect},
      style::{Color, Modifier, Style},
      draw_help(frame, app, chunks[2]);
      // Draw modal overlay if in commit mode
 -    if let InputMode::Commit { buffer, cursor, amend } = &app.input_mode {
 -        draw_commit_modal(frame, buffer, *cursor, *amend);
 +    if let InputMode::Commit { buffer, cursor, amend, status } = &app.input_mode {
 +        draw_commit_modal(frame, buffer, *cursor, *amend, status);
+     }
+ }
  /// Draw commit message modal
 -fn draw_commit_modal(frame: &mut Frame, buffer: &str, cursor: usize, amend: bool) {
 +fn draw_commit_modal(frame: &mut Frame, buffer: &str, cursor: usize, amend: bool, status: &CommitStatus) {
      let area = frame.area();
      // Center the modal
      // Clear area behind modal
      frame.render_widget(Clear, modal_area);
 -    // Title based on amend
 -    let title = if amend { " Amend Commit " } else { " Commit " };
 +    // Title and border color based on status
 +    let (title, border_color) = match status {
 +        CommitStatus::Editing => {
 +            let t = if amend { " Amend Commit " } else { " Commit " };
 +            (t, Color::Green)
 +        }
 +        CommitStatus::Committing => (" Committing... ", Color::Yellow),
 +        CommitStatus::Success => (" ✓ Committed ", Color::Green),
 +        CommitStatus::Failed => (" ✗ Failed ", Color::Red),
 +    };
      let block = Block::default()
          .title(title)
          .borders(Borders::ALL)
 -        .border_style(Style::default().fg(Color::Green));
 +        .border_style(Style::default().fg(border_color));
 -    // Build input line with cursor
 -    let display_text = if cursor >= buffer.len() {
 -        format!("{}█", buffer)
 -    } else {
 -        format!("{}█{}", &buffer[..cursor], &buffer[cursor..])
 +    // Content based on status
 +    let content = match status {
 +        CommitStatus::Editing => {
 +            // Build input line with cursor
 +            let display_text = if cursor >= buffer.len() {
 +                format!("{}█", buffer)
 +            } else {
 +                format!("{}█{}", &buffer[..cursor], &buffer[cursor..])
 +            };
 +            vec![
 +                Line::from(""),
 +                Line::from(Span::raw(display_text)),
 +            ]
 +        }
 +        CommitStatus::Committing => {
 +            vec![
 +                Line::from(""),
 +                Line::from(Span::styled(
 +                    "  Committing changes...",
 +                    Style::default().fg(Color::Yellow),
 +                )),
 +            ]
 +        }
 +        CommitStatus::Success => {
 +            vec![
 +                Line::from(""),
 +                Line::from(Span::styled(
 +                    "  ✓ Changes committed successfully!",
 +                    Style::default().fg(Color::Green),
 +                )),
 +            ]
 +        }
 +        CommitStatus::Failed => {
 +            vec![
 +                Line::from(""),
 +                Line::from(Span::styled(
 +                    "  ✗ Commit failed (nothing staged?)",
 +                    Style::default().fg(Color::Red),
 +                )),
 +            ]
 +        }
      };
 -    let input = Paragraph::new(vec![
 -        Line::from(""),
 -        Line::from(Span::raw(display_text)),
 -    ])
 -    .block(block);
+-
 +    let input = Paragraph::new(content).block(block);
      frame.render_widget(input, modal_area);
+ }
          ));
+     }
 +    // Show search buffer if active
 +    if !app.search_buffer.is_empty() {
 +        spans.push(Span::raw(" "));
 +        spans.push(Span::styled(
 +            format!("/{}", &app.search_buffer),
 +            Style::default().fg(Color::Magenta).add_modifier(Modifier::BOLD),
 +        ));
 +    }
++
      // Show status message if any
      if let Some(ref msg) = app.status_message {
          spans.push(Span::raw(" - "));