Struct IndexProgressTracker 

pub struct IndexProgressTracker {
    pub total_files: usize,
    pub total_bytes: u64,
    pub chunk_size: usize,
    pub estimated_chunks: usize,
    pub chunks_per_sec: Option<f64>,
    pub embedder_model: Option<String>,
    pub processed_chunks: usize,
    pub processed_files: usize,
    pub skipped_files: usize,
    pub failed_files: usize,
    pub indexed_files: usize,
    /* private fields */
}

Progress tracker for batch indexing operations.

Implements a three-phase progress display:

1. Pre-scan phase: counts files and estimates total chunks
2. Calibration phase: measures embedding speed on first file
3. Indexing phase: displays progress bar with ETA

Fields

total_files: usize

Total number of files to process

total_bytes: u64

Total size of all files in bytes

chunk_size: usize

Average chunk size in characters (used for estimation)

estimated_chunks: usize

Estimated total chunks based on file sizes

chunks_per_sec: Option<f64>

Measured chunks per second (EMA - updated dynamically)

embedder_model: Option<String>

Name of the embedder model (for display)

processed_chunks: usize

Number of chunks processed so far

processed_files: usize

Number of files processed (indexed + skipped + failed)

skipped_files: usize

Number of files skipped (duplicates)

failed_files: usize

Number of files that failed to index

indexed_files: usize

Number of files successfully indexed

Implementations

impl IndexProgressTracker

pub fn pre_scan(paths: &[PathBuf]) -> Self

Create a new progress tracker by pre-scanning the given paths.

This performs Phase 1: Pre-scan to count files and estimate chunks.

pub fn display_pre_scan(&self)

Display Phase 1 pre-scan summary to stderr.

pub fn start_calibration(&mut self)

Start the calibration phase (Phase 2).

Call this before processing the first file.

pub fn finish_calibration(&mut self, chunks_processed: usize, model: &str)

Finish calibration with results from first file.

Arguments

• chunks_processed - Number of chunks indexed in first file
• model - Name of the embedder model used

pub fn is_calibrated(&self) -> bool

Check if calibration has been completed.

pub fn start_progress_bar(&mut self)

Start the progress bar for Phase 3: Indexing.

Creates a progress bar based on estimated chunks.

pub fn inc_chunks(&mut self, count: usize)

Increment the chunk counter and update progress bar.

Also updates the rolling average speed (EMA) every 2 seconds to reflect actual embedding performance after GPU warm-up.

pub fn file_indexed(&mut self, chunks: usize)

Record a successfully indexed file.

Arguments

• chunks - Number of chunks created from this file

pub fn file_skipped(&mut self)

Record a skipped file (duplicate).

pub fn file_failed(&mut self)

Record a failed file.

pub fn set_message(&mut self, msg: &str)

Set the current message on the progress bar.

pub fn finish(&mut self)

Finish the progress bar with completion message.

pub fn display_summary(&self)

Display final summary after indexing is complete.

pub fn adjust_estimate(&mut self, file_bytes: u64, actual_chunks: usize)

Adjust estimated chunks based on actual chunk count from calibration file.

This improves ETA accuracy after calibration by using the actual bytes-to-chunks ratio observed in the first file.