src/server/run/mod.rs (2)

264-288: Consider a more robust mechanism for matching references to genome releases

The current implementation uses substring matching on filenames, which could lead to incorrect matches if filenames contain both "GRCh37" and "GRCh38". Additionally, if multiple references match the same genome release, only the first match is used.

A more robust approach might be to:

1. Use a more explicit mapping syntax in the CLI, e.g., --reference GRCh38=path/to/reference.fna
2. Or implement a fallback pattern-matching approach with stricter rules

let reference = {
    args.reference
        .iter()
        .filter_map(|reference_path| {
+           // First try for exact matches in format like "GRCh38.fna" or "GRCh38_reference.fna"
+           let filename = reference_path.file_name().map(|f| f.to_string_lossy().to_lowercase());
+           let matches_pattern = filename.as_ref().map_or(false, |name| {
+               name == genome_release.name().to_lowercase() || 
+               name.starts_with(&format!("{}.", genome_release.name().to_lowercase())) ||
+               name.starts_with(&format!("{}_", genome_release.name().to_lowercase()))
+           });
+           
+           if matches_pattern {
+               tracing::info!(
+                   "Found reference genome for {:?}: {}",
+                   genome_release,
+                   reference_path.display()
+               );
+               return Some(reference_path.clone());
+           }
+           
            // Fall back to substring matching
            if reference_path
                .file_name()
                .map(|f| {
                    f.to_string_lossy()
                        .to_lowercase()
                        .contains(&genome_release.name().to_lowercase())
                })
                .unwrap_or(false)
            {
                tracing::info!(
                    "Found reference genome for {:?}: {}",
                    genome_release,
                    reference_path.display()
                );
                Some(reference_path.clone())
            } else {
                None
            }
        })
        .next()
};

---

294-323: Consider adding a check for ambiguous reference matches

The current implementation doesn't warn users if a reference file might match multiple genome releases.

Before this section, you could add code to check if any reference matches multiple genome releases and log a warning:

// Check for ambiguous reference matches
let mut ambiguous_refs = Vec::new();
for ref_path in &args.reference {
    let matches = GenomeRelease::value_variants()
        .iter()
        .filter(|gr| {
            ref_path
                .file_name()
                .map(|f| {
                    f.to_string_lossy()
                        .to_lowercase()
                        .contains(&gr.name().to_lowercase())
                })
                .unwrap_or(false)
        })
        .count();
    
    if matches > 1 {
        ambiguous_refs.push(ref_path);
    }
}

if !ambiguous_refs.is_empty() {
    tracing::warn!(
        "The following reference paths match multiple genome releases and may be ambiguous: {:?}",
        ambiguous_refs
    );
}

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro