chore: development v0.4.2 - comprehensive testing complete [auto-commit]

Author: githubrobbi

Cargo.toml

@@ -36,7 +36,7 @@ exclude = [
 # Workspace Package Metadata (inherited by all crates)
 # ─────────────────────────────────────────────────────────────────────────────
 [workspace.package]
-version = "0.4.1"
+version = "0.4.2"
 edition = "2024"
 rust-version = "1.85"
 license = "MPL-2.0 OR LicenseRef-UFFS-Commercial"

LOG/Output

@@ -434,7 +434,11 @@ fn write_cpp_drive_footer<W: Write + ?Sized>(
     )?;
     write!(writer, "\r\n")?;
 
-    if ctx.row_count < 20_000 {
+    // Only show the "too few results" warning for full-scan patterns (* or empty).
+    // Filtered/regex/glob queries naturally return few results — that's not an
+    // error.
+    let is_full_scan = matches!(ctx.pattern, "" | "*" | "**" | "**/*");
+    if ctx.row_count < 20_000 && is_full_scan {
         write!(
             writer,
             "MMMmmm that was FAST ... maybe your searchstring was wrong?\t{pattern}\r\n",

crates/uffs-cli/src/commands/output/mod.rs

@@ -171,7 +171,8 @@ fn test_write_results_custom_file_appends_cpp_drive_footer() -> Result<()> {
     let written = fs::read_to_string(&path)?;
     drop(fs::remove_file(&path));
 
-    // With 1 row (< 20,000), should include fast-scan message
+    // With glob pattern "*.txt", few results is expected — no MMMmmm warning.
+    // The warning only triggers for full-scan patterns (*, **, **/*).
     assert_eq!(
         written,
         concat!(
@@ -180,8 +181,6 @@ fn test_write_results_custom_file_appends_cpp_drive_footer() -> Result<()> {
             "\r\n",
             "Drives? \t2\tC:|D:\r\n",
             "\r\n",
-            "MMMmmm that was FAST ... maybe your searchstring was wrong?\t*.txt\r\n",
-            "Search path. E.g. 'C:/' or 'C:\\Prog**' \r\n"
         )
     );
     Ok(())
@@ -308,21 +307,22 @@ fn test_streaming_output_custom_format_includes_footer() -> TestResult {
 }
 
 #[test]
-fn test_cpp_footer_includes_fast_scan_message_when_elapsed_le_1s() -> TestResult {
+fn test_cpp_footer_includes_fast_scan_message_for_full_scan_pattern() -> TestResult {
     let path = temp_output_path("txt");
     let results = sample_df()?;
     let output_config = OutputConfig::new()
         .with_columns("path,name")
         .with_header(false);
 
+    // Full-scan pattern "*" with few results → should trigger the warning
     write_results(
         &results,
         "custom",
         &path.to_string_lossy(),
         &output_config,
         &['G'],
         Duration::from_millis(999),
-        ">G:.*",
+        "*",
     )?;
 
     let written = fs::read_to_string(&path)?;
@@ -336,13 +336,49 @@ fn test_cpp_footer_includes_fast_scan_message_when_elapsed_le_1s() -> TestResult
             "\r\n",
             "Drives? \t1\tG:\r\n",
             "\r\n",
-            "MMMmmm that was FAST ... maybe your searchstring was wrong?\t>G:.*\r\n",
+            "MMMmmm that was FAST ... maybe your searchstring was wrong?\t*\r\n",
             "Search path. E.g. 'C:/' or 'C:\\Prog**' \r\n"
         )
     );
     Ok(())
 }
 
+#[test]
+fn test_cpp_footer_omits_fast_scan_message_for_regex_pattern() -> TestResult {
+    let path = temp_output_path("txt");
+    let results = sample_df()?;
+    let output_config = OutputConfig::new()
+        .with_columns("path,name")
+        .with_header(false);
+
+    // Regex pattern with few results → should NOT trigger the warning
+    // (few results is expected for filtered queries)
+    write_results(
+        &results,
+        "custom",
+        &path.to_string_lossy(),
+        &output_config,
+        &['G'],
+        Duration::from_millis(999),
+        ">G:.*",
+    )?;
+
+    let written = fs::read_to_string(&path)?;
+    drop(fs::remove_file(&path));
+
+    assert_eq!(
+        written,
+        concat!(
+            "\"C:\\Temp\\file.txt\",\"file.txt\"\n",
+            "\r\n",
+            "\r\n",
+            "Drives? \t1\tG:\r\n",
+            "\r\n",
+        )
+    );
+    Ok(())
+}
+
 #[test]
 fn test_cpp_footer_omits_fast_scan_message_when_elapsed_gt_1s() -> TestResult {
     let path = temp_output_path("txt");

crates/uffs-cli/src/commands/output/output_tests.rs

@@ -73,11 +73,15 @@ struct IndexStreamConfig<'a> {
 /// Stream results from a preloaded MFT index.
 #[cfg(windows)]
 fn run_index_streaming(config: &IndexStreamConfig<'_>) -> Result<usize> {
-    let cpp_pattern = format!(
-        ">{}:{}",
-        config.index.volume,
-        config.pattern.replace('*', ".*")
-    );
+    let cpp_pattern = if config.pattern.starts_with('>') {
+        config.pattern.to_owned()
+    } else {
+        format!(
+            ">{}:{}",
+            config.index.volume,
+            config.pattern.replace('*', ".*")
+        )
+    };
 
     if config.is_full_scan {
         info!(

crates/uffs-cli/src/commands/search/live.rs

@@ -88,11 +88,16 @@ pub(super) fn run_single_file_streaming(config: &SingleFileStreamConfig<'_>) ->
     )?;
 
     let t_output = std::time::Instant::now();
-    let cpp_pattern = format!(
-        ">{}:{}",
-        native_index.index.volume,
-        config.pattern.replace('*', ".*")
-    );
+    let cpp_pattern = if config.pattern.starts_with('>') {
+        // Already a regex — pass through unchanged for footer display
+        config.pattern.to_owned()
+    } else {
+        format!(
+            ">{}:{}",
+            native_index.index.volume,
+            config.pattern.replace('*', ".*")
+        )
+    };
 
     let row_count = if config.is_full_scan {
         info!(

crates/uffs-cli/src/commands/search/single_file.rs

@@ -6,7 +6,7 @@ use uffs_core::output::OutputConfig;
 
 use super::super::output;
 use super::super::raw_io::QueryFilters;
-use super::util::extract_trailing_extension;
+use super::util::{extract_extensions_from_regex, extract_trailing_extension};
 
 /// Shared helper: write streaming output from an `MftIndex` to file or console.
 ///
@@ -159,17 +159,21 @@ where
     }
 }
 
-/// Try to get record indices from the extension index for simple suffix
-/// patterns.
+/// Try to get record indices from the extension index for patterns with
+/// recognizable file extensions.
 ///
-/// Returns `Some(Vec<u32>)` for patterns like `*.rs`, `*.txt` where the
-/// extension index provides O(matches) lookup.  Returns `None` for complex
-/// patterns that need full-scan matching.
+/// Supports two modes:
+/// - **Glob**: `*.rs`, `*hallo*.txt` → single extension lookup
+/// - **Regex**: `>.*\.(jpg|png|heic)` → union of multiple extension lookups
+///
+/// Returns `Some(Vec<u32>)` with the pre-filtered record indices, or `None`
+/// if the pattern doesn't have extractable extensions.
 pub(super) fn try_get_extension_indices(
     index: &uffs_mft::MftIndex,
     filters: &QueryFilters<'_>,
 ) -> Option<Vec<u32>> {
-    // Only works for simple glob suffix patterns with no other filters.
+    // Skip extension optimization when other filters are active —
+    // the streaming writer applies these filters inline anyway.
     if filters.files_only
         || filters.dirs_only
         || filters.hide_system
@@ -181,22 +185,54 @@ pub(super) fn try_get_extension_indices(
         return None;
     }
 
+    let ext_index = index.extension_index.as_ref()?;
     let pattern = filters.parsed.pattern();
 
-    // Extract a trailing literal extension from ANY pattern.
-    // Examples:
-    //   "*.txt"         → ext = "txt"
-    //   "*hallo*.txt"   → ext = "txt"
-    //   "foo*.rs"       → ext = "rs"
-    //   "*.tar.gz"      → None (multi-dot)
-    //   "*hallo*"       → None (no extension)
-    //   "nice"          → None (no dot)
-    let ext = extract_trailing_extension(pattern)?;
+    // Strategy 1: Glob patterns — single extension from trailing `.ext`
+    if let Some(ext) = extract_trailing_extension(pattern) {
+        let ext_lower = ext.to_ascii_lowercase();
+        let ext_id = index.extensions.map.get(ext_lower.as_str())?;
+        info!(
+            ext = ext_lower,
+            records = ext_index.get_records(*ext_id).len(),
+            "📊 extension index hit (glob)"
+        );
+        return Some(ext_index.get_records(*ext_id).to_vec());
+    }
+
+    // Strategy 2: Regex patterns — extract extensions from alternation group
+    //   >.*\.(jpg|png|heic)  → ["jpg", "png", "heic"]
+    //   >.*\.txt             → ["txt"]
+    if let Some(extensions) = extract_extensions_from_regex(pattern) {
+        let mut combined: Vec<u32> = Vec::new();
+        let mut matched_exts: Vec<&str> = Vec::new();
 
-    let ext_index = index.extension_index.as_ref()?;
-    let ext_lower = ext.to_ascii_lowercase();
-    let ext_id = index.extensions.map.get(ext_lower.as_str())?;
-    Some(ext_index.get_records(*ext_id).to_vec())
+        for ext in &extensions {
+            if let Some(&ext_id) = index.extensions.map.get(ext.as_str()) {
+                let records = ext_index.get_records(ext_id);
+                combined.extend_from_slice(records);
+                matched_exts.push(ext);
+            }
+        }
+
+        if combined.is_empty() {
+            return None;
+        }
+
+        // Deduplicate — a record could match multiple extensions
+        // (unlikely but possible with hardlinks having different names).
+        combined.sort_unstable();
+        combined.dedup();
+
+        info!(
+            extensions = ?matched_exts,
+            records = combined.len(),
+            "📊 extension index hit (regex alternation)"
+        );
+        return Some(combined);
+    }
+
+    None
 }
 
 /// Build a `StreamingRecordFilter` from `QueryFilters` + extra CLI params.