feat: Add progress reporting with --progress flag

- Add --progress CLI flag to show progress bar during scanning
- Implement progress callback system in scanner core
- Add indicatif dependency for beautiful progress bars
- Show file count, percentage, and findings count in real-time
- Progress bar displays: [████████████████████████████████████████] 8943/10880 files (82%) | Found 8 findings
- Works with parallel processing using crossbeam channels
- Optional feature - no progress shown by default
- Update README with new --progress flag documentation

Example usage:
  cryptofind --progress /path/to/large/project
  cryptofind --patterns custom.toml --progress --threads 8 /src

Author: script3r

Cargo.lock

@@ -21,6 +21,7 @@ Key flags:
 - `--threads N`: set thread pool size
 - `--max-file-size MB`: skip large files (default 2)
 - `--patterns PATH`: specify patterns file (default: `patterns.toml`)
+- `--progress`: show progress bar during scanning
 - `--include-glob GLOB` / `--exclude-glob GLOB`
 - `--allow LIB` / `--deny LIB`
 - `--deterministic`: stable output ordering

README.md

@@ -16,6 +16,7 @@ once_cell = { workspace = true }
 regex = { workspace = true }
 aho-corasick = { workspace = true }
 crossbeam-channel = { workspace = true }
+indicatif = "0.17"
 scanner-core = { path = "../scanner-core" }
 
 [[bin]]

crates/cli/Cargo.toml

@@ -1,5 +1,6 @@
 use anyhow::{Context, Result};
 use clap::{ArgAction, Parser};
+use indicatif::{ProgressBar, ProgressStyle};
 use scanner_core::*;
 use std::fs;
 use std::path::PathBuf;
@@ -68,6 +69,10 @@ struct Args {
     /// Path to patterns file
     #[arg(long, value_name = "FILE", default_value = "patterns.toml")]
     patterns: PathBuf,
+
+    /// Show progress bar during scanning
+    #[arg(long, action = ArgAction::SetTrue)]
+    progress: bool,
 }
 
 fn main() -> Result<()> {
@@ -140,6 +145,24 @@ fn main() -> Result<()> {
     cfg.deny_libs = args.deny.clone();
     cfg.deterministic = args.deterministic;
 
+    // Set up progress reporting if requested
+    if args.progress {
+        let pb = ProgressBar::new(0);
+        pb.set_style(
+            ProgressStyle::default_bar()
+                .template("{spinner:.green} [{elapsed_precise}] [{bar:40.cyan/blue}] {pos}/{len} files ({percent}%) | {msg}")
+                .unwrap()
+                .progress_chars("#>-"),
+        );
+        pb.set_message("Scanning files...");
+        
+        cfg.progress_callback = Some(Arc::new(move |processed, total, findings| {
+            pb.set_length(total as u64);
+            pb.set_position(processed as u64);
+            pb.set_message(format!("Found {} findings", findings));
+        }));
+    }
+
     let scanner = Scanner::new(&reg, dets, cfg);
     if args.dry_run {
         let files = scanner.discover_files(&args.paths);
@@ -151,6 +174,11 @@ fn main() -> Result<()> {
 
     let findings = scanner.run(&args.paths)?;
 
+    // Clear progress bar if it was shown
+    if args.progress {
+        println!(); // Move to next line after progress bar
+    }
+
     if args.json {
         for f in &findings {
             println!("{}", serde_json::to_string(f)?);

crates/cli/src/main.rs

@@ -169,7 +169,7 @@ pub struct LibraryPatterns {
     pub apis: Vec<String>,
 }
 
-#[derive(Debug, Clone, Deserialize)]
+#[derive(Deserialize)]
 pub struct Config {
     #[serde(default = "default_max_file_size")]
     pub max_file_size: usize, // bytes
@@ -185,12 +185,44 @@ pub struct Config {
     pub min_confidence: Option<f32>,
     #[serde(default)]
     pub deterministic: bool,
+    #[serde(skip)]
+    pub progress_callback: Option<Arc<dyn Fn(usize, usize, usize) + Send + Sync>>,
 }
 
 fn default_max_file_size() -> usize {
     2 * 1024 * 1024
 }
 
+impl std::fmt::Debug for Config {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Config")
+            .field("max_file_size", &self.max_file_size)
+            .field("include_globs", &self.include_globs)
+            .field("exclude_globs", &self.exclude_globs)
+            .field("allow_libs", &self.allow_libs)
+            .field("deny_libs", &self.deny_libs)
+            .field("min_confidence", &self.min_confidence)
+            .field("deterministic", &self.deterministic)
+            .field("progress_callback", &"<callback>")
+            .finish()
+    }
+}
+
+impl Clone for Config {
+    fn clone(&self) -> Self {
+        Self {
+            max_file_size: self.max_file_size,
+            include_globs: self.include_globs.clone(),
+            exclude_globs: self.exclude_globs.clone(),
+            allow_libs: self.allow_libs.clone(),
+            deny_libs: self.deny_libs.clone(),
+            min_confidence: self.min_confidence,
+            deterministic: self.deterministic,
+            progress_callback: self.progress_callback.clone(),
+        }
+    }
+}
+
 impl Default for Config {
     fn default() -> Self {
         Self {
@@ -201,6 +233,7 @@ impl Default for Config {
             deny_libs: Vec::new(),
             min_confidence: None,
             deterministic: false,
+            progress_callback: None,
         }
     }
 }
@@ -791,10 +824,34 @@ impl<'a> Scanner<'a> {
 
     pub fn run(&self, roots: &[PathBuf]) -> Result<Vec<Finding>> {
         let files = self.discover_files(roots);
+        let total_files = files.len();
         let mut findings: Vec<Finding> = Vec::new();
 
+        // Call progress callback with initial state
+        if let Some(ref callback) = self.config.progress_callback {
+            callback(0, total_files, 0);
+        }
+
         let (tx, rx) = bounded::<Finding>(8192);
-        files.par_iter().for_each_with(tx.clone(), |tx, path| {
+        let (progress_tx, progress_rx) = bounded::<usize>(1000);
+        
+        // Spawn a thread to collect progress updates
+        let progress_handle = if let Some(ref callback) = self.config.progress_callback {
+            let callback = callback.clone();
+            Some(std::thread::spawn(move || {
+                let mut processed = 0;
+                let mut findings_count = 0;
+                
+                while let Ok(_) = progress_rx.recv() {
+                    processed += 1;
+                    callback(processed, total_files, findings_count);
+                }
+            }))
+        } else {
+            None
+        };
+
+        files.par_iter().for_each_with((tx.clone(), progress_tx.clone()), |(tx, progress_tx), path| {
             if let Some(lang) = Self::detect_language(path) {
                 if let Ok(bytes) = Self::load_file(path) {
                     let unit = ScanUnit {
@@ -822,13 +879,27 @@ impl<'a> Scanner<'a> {
                     }
                 }
             }
+            // Signal that this file has been processed
+            let _ = progress_tx.send(1);
         });
 
         drop(tx);
+        drop(progress_tx);
+        
         for f in rx.iter() {
             findings.push(f);
         }
 
+        // Wait for progress thread to finish
+        if let Some(handle) = progress_handle {
+            let _ = handle.join();
+        }
+
+        // Final progress update
+        if let Some(ref callback) = self.config.progress_callback {
+            callback(total_files, total_files, findings.len());
+        }
+
         if self.config.deterministic {
             findings.sort_by(|a, b| {
                 (