Merge pull request #1 from digicrafts/fix/merge

feat: fix merge

Author: tsangwailam

CHANGELOG.md

@@ -0,0 +1,29 @@
+# Changelog
+
+## [0.1.4] - 2026-03-06
+
+### Added
+
+- **Mouse selection & copy in preview pane** — click and drag to select text, copied to clipboard on release via OSC 52 with tmux passthrough support. Writes to `/dev/tty` for reliable SSH clipboard forwarding.
+- **Horizontal scrolling** — scroll preview content horizontally when word wrap is disabled:
+  - `[` / `]` keys to scroll left/right
+  - Shift+Left / Shift+Right arrow keys
+  - Left/Right arrows in fullscreen preview mode
+  - Shift+MouseWheel for horizontal mouse scroll
+- **Shift+Up/Down** scrolls preview vertically from any pane (not just when preview is focused)
+- **Git status in directory preview** — when a directory is selected, the preview pane shows git status indicators (`[M]`, `[A]`, `[D]`, `[R]`, `[?]`, etc.) next to each file entry
+- **"Copy Completed" overlay** — a bold inverted-color indicator appears at the top-right of the preview pane after a successful copy, disappears on next action
+- `PreviewScrollLeft` / `PreviewScrollRight` actions available for custom keybinding
+- **Auto-refresh** — tree list and preview automatically update when files/directories change on disk (polling every 2 seconds)
+- **Manual refresh** — press `F5` to force refresh the tree and preview immediately
+
+### Changed
+
+- Selection highlight uses light blue background (instead of REVERSED modifier) for better visibility across terminals
+- Clipboard copy now always sends OSC 52 via `/dev/tty` first, then also tries local tools (`xclip`, `xsel`, `wl-copy`, `pbcopy`) as a bonus
+- OSC 52 uses proper `ESC \` string terminator instead of BEL for wider terminal compatibility
+- tmux `allow-passthrough` is automatically enabled per-pane during copy and restored afterward
+
+## [0.1.3] - 2025-01-01
+
+- Initial public release

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "fpv"
-version = "0.1.3"
+version = "0.1.4"
 edition = "2021"
 description = "A minimal, keyboard-first TUI file previewer with syntax highlighting"
 license = "MIT"

Cargo.toml

@@ -1,5 +1,6 @@
 use crate::app::state::{LoadState, NodeType, PreviewDocument, SessionState, TreeNode};
 use crate::fs::current_dir::{list_current_directory_with_visibility, selected_entry_metadata};
+use crate::fs::git::{git_repo_status_for_path, GitFileStatus, GitRepoStatus};
 use crate::fs::preview::load_preview;
 use crate::highlight::syntax::HighlightContext;
 use std::path::Path;
@@ -16,14 +17,74 @@ fn directory_entry_label(node: &TreeNode) -> String {
     }
 }
 
+fn git_status_for_entry(
+    node: &TreeNode,
+    dir_path: &Path,
+    git: &GitRepoStatus,
+) -> Option<GitFileStatus> {
+    let rel = node.path.strip_prefix(&git.repo_root).ok()?;
+
+    // Direct match for files
+    if let Some(status) = git.file_statuses.get(rel) {
+        return Some(*status);
+    }
+
+    // For directories, check if any child has a status
+    if node.node_type == NodeType::Directory {
+        for (path, status) in &git.file_statuses {
+            if path.starts_with(rel) && *status != GitFileStatus::Ignored {
+                return Some(GitFileStatus::Modified);
+            }
+        }
+        return None;
+    }
+
+    // Try relative to the directory being previewed
+    let dir_rel = dir_path
+        .strip_prefix(&git.repo_root)
+        .ok()
+        .map(|d| d.join(&node.name));
+    if let Some(dr) = dir_rel {
+        if let Some(status) = git.file_statuses.get(&dr) {
+            return Some(*status);
+        }
+    }
+
+    None
+}
+
+fn format_git_label(status: GitFileStatus) -> &'static str {
+    match status {
+        GitFileStatus::Added => "[A]",
+        GitFileStatus::Modified => "[M]",
+        GitFileStatus::Deleted => "[D]",
+        GitFileStatus::Renamed => "[R]",
+        GitFileStatus::Copied => "[C]",
+        GitFileStatus::Untracked => "[?]",
+        GitFileStatus::Conflicted => "[U]",
+        GitFileStatus::Ignored => "[!]",
+    }
+}
+
 fn directory_preview(path: &Path, show_hidden: bool) -> PreviewDocument {
     match list_current_directory_with_visibility(path, DIRECTORY_PREVIEW_MAX_ENTRIES, show_hidden) {
         Ok(entries) => {
+            let git = git_repo_status_for_path(path);
             let mut lines = Vec::with_capacity(entries.len().saturating_add(1));
             if entries.is_empty() {
                 lines.push("(empty directory)".to_string());
             } else {
-                lines.extend(entries.iter().map(directory_entry_label));
+                for node in &entries {
+                    let name = directory_entry_label(node);
+                    if let Some(git_status) = git
+                        .as_ref()
+                        .and_then(|g| git_status_for_entry(node, path, g))
+                    {
+                        lines.push(format!("{} {}", format_git_label(git_status), name));
+                    } else {
+                        lines.push(format!("    {}", name));
+                    }
+                }
             }
             PreviewDocument {
                 source_path: path.to_path_buf(),

src/app/preview_controller.rs

@@ -28,6 +28,13 @@ use ratatui::Terminal;
 use std::env;
 use std::io;
 use std::path::PathBuf;
+use std::time::Instant;
+
+fn dir_mtime(path: &PathBuf) -> Option<std::time::SystemTime> {
+    std::fs::metadata(path)
+        .and_then(|m| m.modified())
+        .ok()
+}
 
 fn parse_args() -> (PathBuf, Option<PathBuf>) {
     let mut root = PathBuf::from(".");
@@ -125,7 +132,30 @@ pub fn run() -> Result<()> {
     let backend = CrosstermBackend::new(stdout);
     let mut terminal = Terminal::new(backend)?;
 
+    let mut last_auto_refresh = Instant::now();
+    let auto_refresh_interval = std::time::Duration::from_secs(2);
+    let mut last_dir_mtime = dir_mtime(&state.current_path);
+
     loop {
+        // Auto-refresh: check if directory mtime changed
+        if last_auto_refresh.elapsed() >= auto_refresh_interval {
+            last_auto_refresh = Instant::now();
+            let current_mtime = dir_mtime(&state.current_path);
+            if current_mtime != last_dir_mtime {
+                last_dir_mtime = current_mtime;
+                let prev_path = state.selected_path.clone();
+                nodes = list_current_directory_with_visibility(
+                    &state.current_path,
+                    2000,
+                    state.show_hidden,
+                )?;
+                state.restore_or_default_selection(&nodes, Some(&prev_path));
+                state.update_selected_path(&nodes);
+                state.git_status = git_repo_status_for_path(&state.current_path);
+                preview = refresh_preview(&mut state, &nodes, &highlight, 1024 * 1024);
+            }
+        }
+
         let frame_size = terminal.size()?;
         state.normalize_preview_width(frame_size.width);
         let preview_viewport_rows = frame_size.height.saturating_sub(4) as usize;
@@ -149,7 +179,7 @@ pub fn run() -> Result<()> {
             }
 
             if state.preview_fullscreen {
-                draw_preview(f, chunks[1], &preview, &state, &theme);
+                draw_preview(f, chunks[1], &preview, &mut state, &theme);
             } else {
                 let main = Layout::default()
                     .direction(Direction::Horizontal)
@@ -162,7 +192,7 @@ pub fn run() -> Result<()> {
                     })
                     .split(chunks[1]);
                 draw_tree(f, main[0], &nodes, &state, &theme);
-                draw_preview(f, main[1], &preview, &state, &theme);
+                draw_preview(f, main[1], &preview, &mut state, &theme);
             }
             draw_status(f, chunks[2], &state, &bindings);
 
@@ -183,21 +213,37 @@ pub fn run() -> Result<()> {
         })?;
 
         let previous_path = state.current_path.clone();
-        let (should_quit, should_refresh_preview) = process_once(
+        let (should_quit, should_refresh_preview, should_refresh_tree) = process_once(
             &mut state,
             &mut nodes,
             &bindings,
             total_preview_lines,
             preview_viewport_rows,
+            &preview,
         )?;
         if should_quit {
             break;
         }
-        if state.current_path != previous_path {
+        if should_refresh_tree {
+            let prev_selected = state.selected_path.clone();
+            nodes = list_current_directory_with_visibility(
+                &state.current_path,
+                2000,
+                state.show_hidden,
+            )?;
+            state.restore_or_default_selection(&nodes, Some(&prev_selected));
+            state.update_selected_path(&nodes);
             state.git_status = git_repo_status_for_path(&state.current_path);
-        }
-        if should_refresh_preview {
+            last_dir_mtime = dir_mtime(&state.current_path);
             preview = refresh_preview(&mut state, &nodes, &highlight, 1024 * 1024);
+        } else {
+            if state.current_path != previous_path {
+                state.git_status = git_repo_status_for_path(&state.current_path);
+                last_dir_mtime = dir_mtime(&state.current_path);
+            }
+            if should_refresh_preview {
+                preview = refresh_preview(&mut state, &nodes, &highlight, 1024 * 1024);
+            }
         }
     }
 

src/app/run.rs

@@ -46,6 +46,30 @@ pub enum PreviewFallbackReason {
     DecodeUncertain,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct ContentPosition {
+    pub row: usize,
+    pub col: usize,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PreviewSelection {
+    pub anchor: ContentPosition,
+    pub cursor: ContentPosition,
+}
+
+impl PreviewSelection {
+    pub fn ordered(&self) -> (ContentPosition, ContentPosition) {
+        if self.anchor.row < self.cursor.row
+            || (self.anchor.row == self.cursor.row && self.anchor.col <= self.cursor.col)
+        {
+            (self.anchor, self.cursor)
+        } else {
+            (self.cursor, self.anchor)
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct StyledPreviewSegment {
     pub text: String,
@@ -153,6 +177,13 @@ pub struct SessionState {
     pub preview_wrap_enabled: bool,
     pub preview_fullscreen: bool,
     pub divider_drag_active: bool,
+    pub preview_scroll_col: usize,
+    pub preview_selection: Option<PreviewSelection>,
+    pub preview_selecting: bool,
+    pub preview_inner_rect: (u16, u16, u16, u16),
+    pub preview_line_number_cols: usize,
+    pub preview_copy_indicator: bool,
+    pub preview_copying_indicator: bool,
     pub help_overlay_visible: bool,
     pub status_display_mode: StatusDisplayMode,
     pub git_status: Option<GitRepoStatus>,
@@ -185,6 +216,13 @@ impl SessionState {
             preview_wrap_enabled: false,
             preview_fullscreen: false,
             divider_drag_active: false,
+            preview_scroll_col: 0,
+            preview_selection: None,
+            preview_selecting: false,
+            preview_inner_rect: (0, 0, 0, 0),
+            preview_line_number_cols: 0,
+            preview_copy_indicator: false,
+            preview_copying_indicator: false,
             help_overlay_visible: false,
             status_display_mode: StatusDisplayMode::Bar,
             git_status: None,
@@ -207,6 +245,9 @@ impl SessionState {
 
     pub fn reset_preview_scroll(&mut self) {
         self.preview_scroll_row = 0;
+        self.preview_scroll_col = 0;
+        self.preview_selection = None;
+        self.preview_selecting = false;
     }
 
     pub fn clamp_preview_scroll(&mut self, total_lines: usize, viewport_rows: usize) {
@@ -228,6 +269,18 @@ impl SessionState {
         }
     }
 
+    pub fn scroll_preview_cols(&mut self, delta: isize, max_width: usize, viewport_cols: usize) {
+        let max_scroll = max_width.saturating_sub(viewport_cols);
+        if delta < 0 {
+            self.preview_scroll_col = self.preview_scroll_col.saturating_sub((-delta) as usize);
+        } else {
+            self.preview_scroll_col = self
+                .preview_scroll_col
+                .saturating_add(delta as usize)
+                .min(max_scroll);
+        }
+    }
+
     pub fn page_scroll_preview_down(&mut self, total_lines: usize, viewport_rows: usize) {
         let page = viewport_rows.max(1) as isize;
         self.scroll_preview_lines(page, total_lines, viewport_rows);

src/app/state.rs

@@ -16,12 +16,15 @@ pub enum Action {
     PageDown,
     PreviewScrollUp,
     PreviewScrollDown,
+    PreviewScrollLeft,
+    PreviewScrollRight,
     TogglePreviewLineNumbers,
     TogglePreviewWrap,
     ToggleHelp,
     ToggleHidden,
     ResizePreviewNarrower,
     ResizePreviewWider,
+    Refresh,
     Quit,
 }
 
@@ -78,6 +81,14 @@ pub fn default_keymap() -> HashMap<Action, KeyEvent> {
             Action::PreviewScrollDown,
             KeyEvent::new(KeyCode::Char('/'), KeyModifiers::NONE),
         ),
+        (
+            Action::PreviewScrollLeft,
+            KeyEvent::new(KeyCode::Char('['), KeyModifiers::NONE),
+        ),
+        (
+            Action::PreviewScrollRight,
+            KeyEvent::new(KeyCode::Char(']'), KeyModifiers::NONE),
+        ),
         (
             Action::TogglePreviewLineNumbers,
             KeyEvent::new(KeyCode::Char('l'), KeyModifiers::NONE),
@@ -102,6 +113,10 @@ pub fn default_keymap() -> HashMap<Action, KeyEvent> {
             Action::ResizePreviewWider,
             KeyEvent::new(KeyCode::Right, KeyModifiers::CONTROL),
         ),
+        (
+            Action::Refresh,
+            KeyEvent::new(KeyCode::F(5), KeyModifiers::NONE),
+        ),
         (
             Action::Quit,
             KeyEvent::new(KeyCode::Char('q'), KeyModifiers::NONE),
@@ -122,12 +137,15 @@ pub fn action_from_name(name: &str) -> Option<Action> {
         "page_down" => Some(Action::PageDown),
         "preview_scroll_up" => Some(Action::PreviewScrollUp),
         "preview_scroll_down" => Some(Action::PreviewScrollDown),
+        "preview_scroll_left" => Some(Action::PreviewScrollLeft),
+        "preview_scroll_right" => Some(Action::PreviewScrollRight),
         "toggle_preview_line_numbers" => Some(Action::TogglePreviewLineNumbers),
         "toggle_preview_wrap" => Some(Action::TogglePreviewWrap),
         "toggle_help" => Some(Action::ToggleHelp),
         "toggle_hidden" => Some(Action::ToggleHidden),
         "resize_preview_narrower" => Some(Action::ResizePreviewNarrower),
         "resize_preview_wider" => Some(Action::ResizePreviewWider),
+        "refresh" => Some(Action::Refresh),
         "quit" => Some(Action::Quit),
         _ => None,
     }
@@ -153,6 +171,13 @@ pub fn parse_key_combo(value: &str) -> Result<KeyEvent> {
             "pageup" => code = Some(KeyCode::PageUp),
             "pagedown" => code = Some(KeyCode::PageDown),
             "esc" => code = Some(KeyCode::Esc),
+            s if s.starts_with('f') && s.len() > 1 => {
+                if let Ok(n) = s[1..].parse::<u8>() {
+                    code = Some(KeyCode::F(n));
+                } else {
+                    return Err(anyhow!("invalid key combo: {value}"));
+                }
+            }
             single if single.len() == 1 => {
                 code = Some(KeyCode::Char(single.chars().next().unwrap_or(' ')));
             }