feat: improve filter test reporting, add CLI usage hints, and fix TOML regex escaping for numeric placeholders

Author: fajarhide

scratch/debug_escape.rs

@@ -0,0 +1,4 @@
+use regex;
+fn main() {
+    println!("Escaped: {}", regex::escape("Step #/#:"));
+}

src/cli/learn.rs

@@ -90,26 +90,66 @@ pub fn run_learn(args: &[String]) -> Result<()> {
                 .bold()
                 .bright_white()
         );
-        let report = crate::pipeline::toml_filter::run_inline_tests(
-            crate::pipeline::toml_filter::load_all_filters(),
-        );
-        let total = report.passes + report.failures.len();
+        let all_filters = crate::pipeline::toml_filter::load_all_filters();
+        let report = crate::pipeline::toml_filter::run_inline_tests(all_filters);
 
-        let status = if report.failures.is_empty() {
-            "ALL PASSED".green()
-        } else {
-            "FAILURES DETECTED".red()
-        };
+        let (mut built_in_fails, mut user_fails) = (0, 0);
+        let (mut built_in_total, mut user_total) = (0, 0);
 
-        println!("  Status:  {} ({} / {})", status, report.passes, total);
+        for filter in all_filters {
+            let count = filter.inline_tests.len();
+            if filter.name.starts_with("sys_") {
+                built_in_total += count;
+            } else {
+                user_total += count;
+            }
+        }
+
+        for fail in &report.failures {
+            if fail.contains("Filter 'sys_") {
+                built_in_fails += 1;
+            } else {
+                user_fails += 1;
+            }
+        }
+
+        let total_tests = built_in_total + user_total;
+        let total_passes = report.passes;
+
+        println!(
+            "  Total Tests: {} ({} passed, {} failed)",
+            total_tests,
+            total_passes,
+            report.failures.len()
+        );
+        println!(
+            "  - Built-in:  {} tests ({} failed)",
+            built_in_total, built_in_fails
+        );
+        println!(
+            "  - User:      {} tests ({} failed)",
+            user_total, user_fails
+        );
 
         if !report.failures.is_empty() {
-            println!("\n{}", "Details:".bold().red());
+            println!("\n{}", "Failure Details:".bold().red());
             for f in report.failures {
                 println!("  {} {}", "✗".red(), f);
             }
+            if user_fails > 0 {
+                println!(
+                    "\n{}",
+                    "TIP: Learned filters often fail if the noise pattern has changed. You can clear them by deleting ~/.omni/filters/learned.toml"
+                        .dimmed()
+                );
+            }
+        } else {
+            println!(
+                "\n{}",
+                "✓ All loaded filters pass their inline tests!".green()
+            );
         }
-        println!();
+
         return Ok(());
     }
 

src/cli/stats.rs

@@ -484,7 +484,7 @@ fn run_detail(args: &[String], store: &Store) -> Result<()> {
                 println!(
                     "\n   {}",
                     format!(
-                        "Showing top 10 of {} commands with active savings.",
+                        "Showing top 10 of {} commands with active savings. --all-commands to see all",
                         filtered_count
                     )
                     .bright_black()

src/session/learn.rs

@@ -133,8 +133,14 @@ pub fn generate_toml(
 
         // Escape characters for RegEx safeties
         let escaped_prefix = regex::escape(&clean_prefix);
-        let toml_safe = escaped_prefix.replace('\\', "\\\\").replace('"', "\\\"");
-        strips.push(format!("\"^{}\"", toml_safe));
+        // Replace the '#' placeholder with the memory-safe regex placeholder (single backslash \d+)
+        let mem_regex = format!("^{}", escaped_prefix.replace('#', r"\d+"));
+
+        // Use toml crate to handle ALL string escaping correctly for TOML
+        let toml_val = toml::Value::String(mem_regex);
+        let toml_safe = toml_val.to_string();
+
+        strips.push(toml_safe);
         sample_lines.push_str(&format!("{}\n", clean_sample));
     }
 
@@ -325,4 +331,23 @@ mod tests {
         // Will fire the thread in the background
         queue_for_learn("x".repeat(300).as_str(), "make build");
     }
+
+    #[test]
+    fn test_generate_toml_with_numeric_placeholders() {
+        let c = vec![PatternCandidate {
+            trigger_prefix: "Step #/#:".to_string(),
+            sample_line: "Step 1/2: FROM alpine".to_string(),
+            count: 3,
+            confidence: 0.85,
+            suggested_action: LearnAction::Strip,
+        }];
+        let toml = generate_toml(&c, "numeric_test", None);
+        // The generated regex in TOML will have escaped backslashes
+        // Step #/#: -> Step \d+/\d+: -> Step \\d+/\\d+:
+        assert!(
+            toml.contains(r"Step \\d+/\\d+:"),
+            "TOML did not contain expected regex. Got: {}",
+            toml
+        );
+    }
 }