Crate ffs_search 

ffs-search — High-performance file finder core

This crate provides the core search engine for [ffs(https://github.com/dmtrKovalenko/ffs.nvim). It includes filesystem indexing with real-time watching, fuzzy matching powered by frizbee, frecency scoring backed by LMDB, and multi-mode grep search.

Architecture

• file_picker::FilePicker — Main entry point. Indexes a directory tree in a background thread, maintains a sorted file list, watches the filesystem for changes, and performs fuzzy search with frecency-weighted scoring.
• frecency::FrecencyTracker — LMDB-backed database that tracks file access and modification patterns for intelligent result ranking.
• query_tracker::QueryTracker — Tracks search query history and provides “combo-boost” scoring for repeatedly matched files.
• grep — Live grep search supporting regex, plain-text, and fuzzy modes with optional constraint filtering.
• git — Git status caching and repository detection.

Shared State

SharedFilePicker, SharedFrecency, and SharedQueryTracker are newtype wrappers around Arc<RwLock<Option<T>>> for thread-safe shared access. They provide read() / write() methods with built-in error conversion and convenience helpers like wait_for_scan().

Quick Start

use ffs_search::file_picker::FilePicker;
use ffs_search::frecency::FrecencyTracker;
use ffs_search::query_tracker::QueryTracker;
use ffs_search::{
    FfsMode, FilePickerOptions, FuzzySearchOptions, PaginationArgs, QueryParser,
    SharedFrecency, SharedFilePicker, SharedQueryTracker,
};

let shared_picker = SharedFilePicker::default();
let shared_frecency = SharedFrecency::default();
let shared_query_tracker = SharedQueryTracker::default();

let tmp = std::env::temp_dir().join("ffs-doctest");
std::fs::create_dir_all(&tmp).unwrap();

// 1. Optionally initialize frecency and query tracker databases
let frecency = FrecencyTracker::open(tmp.join("frecency"))?;
shared_frecency.init(frecency)?;

let query_tracker = QueryTracker::open(tmp.join("queries"))?;
shared_query_tracker.init(query_tracker)?;

// 2. Init the file picker (spawns background scan + watcher)
FilePicker::new_with_shared_state(
    shared_picker.clone(),
    shared_frecency.clone(),
    FilePickerOptions {
        base_path: ".".into(),
        mode: FfsMode::Ai,
        ..Default::default()
    },
)?;

// 3. Wait for scan
shared_picker.wait_for_scan(std::time::Duration::from_secs(10));

// 4. Search: lock the picker and query tracker
let picker_guard = shared_picker.read()?;
let picker = picker_guard.as_ref().unwrap();
let qt_guard = shared_query_tracker.read()?;

// 5. Parse the query and perform fuzzy search
let parser = QueryParser::default();
let query = parser.parse("lib.rs");

let results = picker.fuzzy_search(
    &query,
    qt_guard.as_ref(),
    FuzzySearchOptions {
        max_threads: 0,
        current_file: None,
        pagination: PaginationArgs { offset: 0, limit: 50 },
        ..Default::default()
    },
);

assert!(results.total_matched > 0);
assert!(results.items.first().unwrap().relative_path(picker).ends_with("lib.rs"));

let _ = std::fs::remove_dir_all(&tmp);

Re-exports

pub use dbs::frecency;

pub use dbs::query_tracker;

pub use dbs::db_healthcheck::DbHealth;

pub use dbs::db_healthcheck::DbHealthChecker;

pub use file_picker::*;

pub use frecency::*;

pub use grep::*;

pub use query_tracker::*;

pub use shared::*;

pub use types::*;

Modules

bigram_query

Regex → bigram decomposition for the inverted bigram index.

case_insensitive_memmem

SIMD-accelerated case-insensitive substring search.

dbs

Database-backed persistence: frecency, query history, LMDB plumbing.

file_picker

Core file picker: filesystem indexing, background watching, and fuzzy search.

git

Git status caching and repository detection utilities.

glob_detect

Glob wildcard detection — delegates to zlob when available, pure-Rust fallback otherwise.

grep

Live grep search with regex, plain-text, and fuzzy matching modes.

location

Location parsing for file:line:col patterns

log

Tracing/logging initialization and panic hook setup. Shared logging utilities for ffs crates.

path_utils

Path manipulation utilities: cross platform canonicalization, tilde expansion, and directory distance penalties for search scoring.

shared

Thread-safe shared handles for FilePicker, FrecencyTracker, and QueryTracker.

types

Core data types shared across the crate.

Structs

AiGrepConfig

Configuration for AI-mode grep — extends GrepConfig behavior with automatic file-path constraint detection.

DirSearchConfig

Configuration for directory and mixed search modes.

FfsQuery

FileSearchConfig

Default configuration for file picker - all features enabled

GrepConfig

Configuration for full-text search (grep) - file constraints enabled for filtering which files to search, git status disabled since it’s not useful when searching file contents.

MixedSearchConfig

Configuration for mixed (files + directories) search.

QueryParser

Main query parser - zero-cost wrapper around configuration

Enums

Constraint

Constraint types that can be extracted from a query

Error

FuzzyQuery

GitStatusFilter

Location

Traits

ParserConfig

Parser configuration trait - allows different picker types to customize parsing

Type Aliases

ConstraintVec

Result