feat: Git recency bonuses

README.md

@@ -374,6 +374,11 @@ require('fff').setup({
   },
   git = {
     status_text_color = false, -- true to color filenames by git status
+    recency = {
+      enabled = true, -- boost files from recent commits of the current branch
+      max_commits = 10, -- analyze the last N branch-specific commits
+      max_files_per_commit = 50, -- skip bulk commits touching more files than this
+    },
   },
   file_picker = {
     fuzzy_query_highlighting = false, -- true to highlight fuzzy query matches in file picker results
@@ -468,6 +473,26 @@ Caveat: the chosen file replaces the buffer in the invoking window even if it's
 
 Sign-column indicators are on by default. To color filename text by git status, set `git.status_text_color = true` and adjust the `hl.git_*` groups. See `:help fff.nvim` for the full list.
 
+### Git recency ranking
+
+Files that participated in recent commits of your current branch get a small additive score bonus: +1 point per commit within the analyzed window. A file touched by all of the last 10 commits gets +10; if your branch only has 2 commits, its files get at most +2. This surfaces the files you are actively working on — especially right after switching branches or pulling.
+
+- Only commits unique to the current branch are counted (against the merge bases with the repo's base branch: `origin/HEAD`, `main`/`master`, or your configured `init.defaultBranch`); on the base branch itself the last `max_commits` commits are used, even when it is ahead of its remote counterpart.
+- Merge commits and bulk commits touching more than `git.recency.max_files_per_commit` files are ignored.
+- Scores refresh automatically after commits, checkouts, and rebases; refreshes are skipped entirely while `HEAD` stays put, so it costs nothing during regular editing.
+
+```lua
+require('fff').setup({
+  git = {
+    recency = {
+      enabled = true, -- default: true
+      max_commits = 10, -- window of branch commits to analyze (also the max bonus)
+      max_files_per_commit = 50, -- skip merge/bulk commits touching more files
+    },
+  },
+})
+```
+
 ### Float colors
 
 The picker maps its float content to `NormalFloat` (via `hl.normal`) and the border to `FloatBorder`. Default `FloatBorder` links to `NormalFloat`, so border and content share a background out of the box and the picker reads as a single popup. Override `hl.normal = 'Normal'` to make the picker blend with the editor instead.

crates/fff-c/src/lib.rs

@@ -266,6 +266,7 @@ pub unsafe extern "C" fn fff_create_instance_with(opts: *const FffCreateOptions)
             follow_symlinks: opts.version >= 2 && opts.follow_symlinks,
             enable_fs_root_scanning: opts.enable_fs_root_scanning,
             enable_home_dir_scanning: opts.enable_home_dir_scanning,
+            git_recency: Default::default(),
         },
     ) {
         return FffResult::err(&format!("Failed to init file picker: {}", e));
@@ -932,6 +933,10 @@ pub unsafe extern "C" fn fff_restart_index(
         } else {
             (false, true, true, FFFMode::default(), false, false, false)
         };
+    let git_recency = guard
+        .as_ref()
+        .map(|p| p.git_recency_config())
+        .unwrap_or_default();
 
     drop(guard);
 
@@ -948,6 +953,7 @@ pub unsafe extern "C" fn fff_restart_index(
             follow_symlinks,
             enable_fs_root_scanning: fs_root,
             enable_home_dir_scanning: home_dir,
+            git_recency,
         },
     ) {
         Ok(()) => FffResult::ok_empty(),

crates/fff-core/src/file_picker.rs

@@ -33,6 +33,7 @@ use crate::constants::{MAX_OVERFLOW_FILES, PATH_BUF_SIZE};
 use crate::error::Error;
 use crate::frecency::FrecencyTracker;
 use crate::git::GitStatusCache;
+use crate::git_recency::{self, GitRecencyConfig};
 use crate::grep::{GrepResult, GrepSearchOptions, grep_search, multi_grep_search};
 use crate::index::{BigramFilter, BigramOverlay};
 use crate::query_tracker::QueryTracker;
@@ -47,6 +48,7 @@ use crate::types::{
 };
 use crate::walk::WalkOutput;
 use crate::watch::BackgroundWatcher;
+use ahash::AHashMap;
 use fff_query_parser::FFFQuery;
 use git2::{Repository, Status};
 use rayon::prelude::*;
@@ -195,8 +197,6 @@ impl FileSync {
 
     #[inline]
     fn find_file_index(&self, path: &Path, base_path: &Path) -> Option<usize> {
-        let arena = self.arena_base_ptr();
-
         // Strip base_path prefix to get the relative path. On Windows this
         // can fail for 8.3 short names or a different casing; fall back to
         // canonicalize-then-strip so watcher events still land on the right
@@ -216,8 +216,13 @@ impl FileSync {
         };
         // The dir table and stored file paths are '/'-canonical; fold the
         // native relative path so the byte-wise comparisons below match.
-        let rel_path_owned = crate::path_utils::to_canonical_slashes(&rel_path_owned).into_owned();
-        let rel_path: &str = &rel_path_owned;
+        self.find_by_relative_path(&crate::path_utils::to_canonical_slashes(&rel_path_owned))
+    }
+
+    // Lookup for a base-relative, '/'-canonical path — the form paths are
+    // stored in, so no normalization is needed.
+    fn find_by_relative_path(&self, rel_path: &str) -> Option<usize> {
+        let arena = self.arena_base_ptr();
 
         // Split into directory (with trailing '/') and filename.
         let parent_end = rel_path
@@ -549,6 +554,9 @@ pub struct FilePickerOptions {
     /// Allow indexing the user's home directory. Off by default for the same
     /// reason as `enable_fs_root_scanning`
     pub enable_home_dir_scanning: bool,
+    /// Ranking boost for files that participated in recent commits of the
+    /// current branch. Enabled with default limits unless overridden.
+    pub git_recency: GitRecencyConfig,
 }
 
 impl Default for FilePickerOptions {
@@ -563,6 +571,7 @@ impl Default for FilePickerOptions {
             follow_symlinks: false,
             enable_fs_root_scanning: false,
             enable_home_dir_scanning: false,
+            git_recency: GitRecencyConfig::default(),
         }
     }
 }
@@ -586,6 +595,7 @@ pub struct FilePicker {
     follow_symlinks: bool,
     enable_fs_root_scanning: bool,
     enable_home_dir_scanning: bool,
+    git_recency_config: GitRecencyConfig,
     trace_span: tracing::Span,
     trace_id: String,
 }
@@ -669,6 +679,10 @@ impl FilePicker {
         self.enable_home_dir_scanning
     }
 
+    pub fn git_recency_config(&self) -> GitRecencyConfig {
+        self.git_recency_config
+    }
+
     pub fn trace_id(&self) -> &str {
         &self.trace_id
     }
@@ -848,6 +862,8 @@ impl FilePicker {
     /// Always prefer new_with_shared_state for the consumer application, use this only if you know
     /// what you are doing. This won't spawn the backgraound watcher and won't walk the file tree.
     pub fn new(options: FilePickerOptions) -> Result<Self, Error> {
+        crate::git::tune_libgit2_for_local_reads();
+
         let path = PathBuf::from(&options.base_path);
         if !path.exists() {
             error!("Base path does not exist: {}", options.base_path);
@@ -903,6 +919,7 @@ impl FilePicker {
             follow_symlinks: options.follow_symlinks,
             enable_fs_root_scanning: options.enable_fs_root_scanning,
             enable_home_dir_scanning: options.enable_home_dir_scanning,
+            git_recency_config: options.git_recency,
             trace_span,
             trace_id,
         })
@@ -1030,6 +1047,15 @@ impl FilePicker {
             }
         }
 
+        if let Some(workdir) = self.sync_data.git_workdir.clone()
+            && let Ok(repo) = Repository::open(&workdir)
+                .inspect_err(|e| debug!(?e, ?workdir, "git recency: failed to open repo"))
+        {
+            let recency =
+                git_recency::compute_git_recency(&repo, &self.git_recency_config, &self.base_path);
+            self.apply_git_recency(recency.as_ref());
+        }
+
         self.signals.scanning.store(false, Ordering::Relaxed);
         Ok(())
     }
@@ -1535,6 +1561,32 @@ impl FilePicker {
         Ok(())
     }
 
+    // Replaces every recency score with a freshly computed set. `None` zeroes
+    // them, so a vanished window (orphan HEAD, repo gone) leaves no stale boost.
+    pub(crate) fn apply_git_recency(&mut self, scores: Option<&AHashMap<String, i16>>) {
+        if !self.git_recency_config.enabled {
+            return;
+        }
+
+        for file in self.sync_data.files.iter_mut() {
+            file.git_recency_score = 0;
+        }
+
+        let Some(scores) = scores else { return };
+
+        let mut applied = 0usize;
+        for (relative_path, score) in scores {
+            if let Some(index) = self.sync_data.find_by_relative_path(relative_path)
+                && let Some((_, file)) = self.sync_data.get_file_mut(index)
+            {
+                file.git_recency_score = *score;
+                applied += 1;
+            }
+        }
+
+        debug!(files_scored = applied, "Git recency scores applied");
+    }
+
     pub fn update_single_file_frecency(
         &mut self,
         file_path: impl AsRef<Path>,

crates/fff-core/src/git.rs

@@ -6,6 +6,22 @@ use std::{
     path::{Path, PathBuf},
 };
 
+/// Process-wide libgit2 tuning for read-heavy local use. By default libgit2
+/// never caches trees over 4KB (large repos re-inflate every directory tree on
+/// every diff) and SHA-verifies each object read; measured on chromium this
+/// takes a 10-commit recency walk from 1.4s down to 0.56s.
+pub(crate) fn tune_libgit2_for_local_reads() {
+    static TUNE: std::sync::Once = std::sync::Once::new();
+    TUNE.call_once(|| {
+        // Same tradeoff cargo makes: local objects are trusted, skip hashing.
+        git2::opts::strict_hash_verification(false);
+        // SAFETY: plain process-global size limit; total memory stays bounded
+        // by libgit2's 256MB odb cache.
+        let _ =
+            unsafe { git2::opts::set_cache_object_limit(git2::ObjectType::Tree, 8 * 1024 * 1024) };
+    });
+}
+
 pub(crate) fn default_status_options() -> StatusOptions {
     let mut opts = StatusOptions::new();
     opts.include_untracked(true)
@@ -52,7 +68,10 @@ impl GitStatusCache {
     }
 
     #[tracing::instrument(skip(repo, status_options))]
-    fn read_status_impl(repo: &Repository, status_options: &mut StatusOptions) -> Result<Self> {
+    pub(crate) fn read_status(
+        repo: &Repository,
+        status_options: &mut StatusOptions,
+    ) -> Result<Self> {
         let statuses = repo.statuses(Some(status_options))?;
         let Some(repo_path) = repo.workdir() else {
             return Ok(Self(AHashMap::new())); // repo is bare
@@ -80,7 +99,7 @@ impl GitStatusCache {
         let git_workdir = git_workdir.as_ref()?;
         let repository = Repository::open(git_workdir).ok()?;
 
-        let status = Self::read_status_impl(&repository, status_options);
+        let status = Self::read_status(&repository, status_options);
 
         match status {
             Ok(status) => Some(status),
@@ -123,7 +142,7 @@ impl GitStatusCache {
             status_options.pathspec(path.as_ref().strip_prefix(&workdir)?);
         }
 
-        let git_status_cache = Self::read_status_impl(repo, &mut status_options)?;
+        let git_status_cache = Self::read_status(repo, &mut status_options)?;
         Ok(git_status_cache)
     }
 }