add only-imperfect option

src/main.rs

···
         /// Pretty-print output. With `--output json` this prints pretty JSON. With `--output debug` this prints human-friendly text.
         #[arg(long)]
         pretty: bool,
+
+        /// Only output files that fail one or more validations (imperfect data)
+        #[arg(long)]
+        only_imperfect: bool,
     /// Directory to scan
     directory: String,
 }
···
 
 type ResultType = Result<Vec<AudioFileEntry>, Box<dyn std::error::Error>>;
 
+/// A validation result: None == ok, Some(reason) == failed with reason
+type ValidationResult = Option<String>;
+
+/// Validator trait for AudioFileEntry
+trait Validator {
+    fn validate(&self, entry: &AudioFileEntry) -> ValidationResult;
+}
+
+struct TitleValidator;
+impl Validator for TitleValidator {
+    fn validate(&self, entry: &AudioFileEntry) -> ValidationResult {
+        let title = entry.tags.title();
+        if title.is_none() || title == Some("") {
+            Some("missing title".to_string())
+        } else {
+            None
+        }
+    }
+}
+
+struct ArtistValidator;
+impl Validator for ArtistValidator {
+    fn validate(&self, entry: &AudioFileEntry) -> ValidationResult {
+        let artist = entry.tags.artist();
+        if artist.is_none() || artist == Some("") {
+            Some("missing artist".to_string())
+        } else {
+            None
+        }
+    }
+}
+
+struct AlbumValidator;
+impl Validator for AlbumValidator {
+    fn validate(&self, entry: &AudioFileEntry) -> ValidationResult {
+        match entry.tags.album() {
+            Some(a) => {
+                if a.title.trim().is_empty() {
+                    Some("missing album title".to_string())
+                } else {
+                    None
+                }
+            }
+            None => Some("missing album".to_string()),
+        }
+    }
+}
+
+struct CoverValidator;
+impl Validator for CoverValidator {
+    fn validate(&self, entry: &AudioFileEntry) -> ValidationResult {
+        match entry.tags.album() {
+            Some(a) => match a.cover.as_ref() {
+                Some(c) => {
+                    if c.data.is_empty() {
+                        Some("empty cover".to_string())
+                    } else {
+                        None
+                    }
+                }
+                None => Some("missing cover".to_string()),
+            },
+            None => Some("missing cover".to_string()),
+        }
+    }
+}
+
+fn default_validators() -> Vec<Box<dyn Validator>> {
+    vec![
+        Box::new(TitleValidator),
+        Box::new(ArtistValidator),
+        Box::new(AlbumValidator),
+        Box::new(CoverValidator),
+    ]
+}
+
 fn is_audio_file(path: &Path) -> bool {
     if let Some(extension) = path.extension().and_then(|s| s.to_str()) {
         matches!(
···
     match read_folder(&args.directory, args.recursive) {
         Ok(audio_files) => {
             println!("Found {} audio files in '{}':", audio_files.len(), args.directory);
+
+            // total files before filtering
+            let total_files = audio_files.len();
+
+            // build validators (future: could be dynamic from CLI)
+            let validators = default_validators();
+
+            // if user requested only imperfect, filter entries that fail any validator
+            let audio_files: Vec<AudioFileEntry> = if args.only_imperfect {
+                audio_files
+                    .into_iter()
+                    .filter(|e| validators.iter().any(|v| v.validate(e).is_some()))
+                    .collect()
+            } else {
+                audio_files
+            };
+
+            // how many imperfect files we have after filtering
+            let imperfect_count = audio_files.len();
             // Decide behavior based on `--pretty` and `--output`
             if args.pretty {
                 match args.output {
···
                         }
                     }
                 }
+            }
+
+            // If requested, print an imperfect summary in yellow at the end
+            if args.only_imperfect {
+                let percent = if total_files > 0 {
+                    (imperfect_count as f64 / total_files as f64) * 100.0
+                } else {
+                    0.0
+                };
+                // ANSI yellow
+                let yellow = "\x1b[33m";
+                let reset = "\x1b[0m";
+                eprintln!("{}Imperfect files: {}/{} ({:.2}%){}", yellow, imperfect_count, total_files, percent, reset);
             }
         }
         Err(e) => {