feat(cli): rosalind locate — load + exact-match query a prebuilt index

IndexReader::open -> GenomeIndexView::locate_exact -> prints contig<TAB>pos (sorted). Memory-mapped load, no rebuild, exact-match only (not the aligner — that's B4). Verified against an in-RAM GenomeIndex::locate_exact ground truth over a multi-contig + N-bearing battery.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: logannye

src/main.rs

@@ -10,7 +10,7 @@ use rosalind::core::MemoryBudget;
 use rosalind::genomics::{
     compare_callsets, create_bam_writer, estimate_build_working_set, read_vcf_variants,
     render_plan_line, sort_bam_deterministic, AlignedRead, BWTAligner, BedIndex, CigarOp,
-    CigarOpKind, GenomeIndex, IndexBuildReport, IndexWriter,
+    CigarOpKind, GenomeIndex, IndexBuildReport, IndexReader, IndexWriter,
 };
 use rosalind::io::decompress::open_input;
 use rosalind::io::fasta::{FastaReader, FastaRecord};
@@ -159,6 +159,18 @@ enum Commands {
         #[arg(long)]
         memory_budget_mb: Option<u64>,
     },
+    /// Locate exact occurrences of a pattern in a prebuilt index (load + query).
+    Locate {
+        /// Index artifact built by `rosalind index`.
+        #[arg(long)]
+        index: PathBuf,
+        /// Pattern to locate (ASCII A/C/G/T/N; case-insensitive).
+        #[arg(long)]
+        pattern: String,
+        /// Maximum number of candidate hits to locate.
+        #[arg(long, default_value_t = 1024)]
+        max_hits: usize,
+    },
 }
 
 #[derive(Copy, Clone, Debug, ValueEnum, Eq, PartialEq)]
@@ -270,6 +282,11 @@ fn main() -> Result<()> {
             output,
             memory_budget_mb,
         } => run_index(reference, output, memory_budget_mb)?,
+        Commands::Locate {
+            index,
+            pattern,
+            max_hits,
+        } => run_locate(index, pattern, max_hits)?,
     }
 
     Ok(())
@@ -371,6 +388,34 @@ fn run_index(reference: PathBuf, output: PathBuf, memory_budget_mb: Option<u64>)
     Ok(())
 }
 
+/// Load a prebuilt index and print exact-match loci for `pattern` (B3c). This is
+/// a memory-mapped load + exact match — it never rebuilds the index.
+fn run_locate(index: PathBuf, pattern: String, max_hits: usize) -> Result<()> {
+    let loaded = IndexReader::open(&index)
+        .with_context(|| format!("failed to open index {}", index.display()))?;
+    let view = loaded
+        .genome_view()
+        .with_context(|| format!("failed to view index {}", index.display()))?;
+
+    let loci = view.locate_exact(pattern.as_bytes(), max_hits);
+    if loci.is_empty() {
+        eprintln!("no hits");
+        return Ok(());
+    }
+
+    let mut stdout = io::BufWriter::new(io::stdout().lock());
+    for locus in loci {
+        let name = view
+            .contigs()
+            .by_id(locus.contig)
+            .map(|c| c.name.to_string())
+            .unwrap_or_else(|| locus.contig.to_string());
+        writeln!(stdout, "{name}\t{}", locus.pos.0)?;
+    }
+    stdout.flush()?;
+    Ok(())
+}
+
 fn run_somatic(
     reference_path: PathBuf,
     tumor_fastq: Option<PathBuf>,

tests/index_cli.rs

@@ -106,3 +106,67 @@ fn index_memory_budget_prints_plan_line_and_never_refuses() {
 
     std::fs::remove_dir_all(&dir).ok();
 }
+
+#[test]
+fn locate_matches_in_ram_ground_truth() {
+    use rosalind::genomics::GenomeIndex;
+
+    let dir = tmpdir();
+    let fa = write_fasta(&dir);
+    let idx = dir.join("ref.idx");
+    let build = Command::new(bin())
+        .args([
+            "index",
+            "--reference",
+            fa.to_str().unwrap(),
+            "--output",
+            idx.to_str().unwrap(),
+        ])
+        .output()
+        .expect("index");
+    assert!(build.status.success());
+
+    // In-RAM ground truth over the same sequences.
+    let gi = GenomeIndex::from_named_sequences(&[
+        (
+            "chr1".to_string(),
+            b"ACGTACGTNNACGTACGTACGTAAGGCCTT".to_vec(),
+        ),
+        (
+            "chr2".to_string(),
+            b"TTTTGGGGCCCCAAAANNNNACGTACGTAC".to_vec(),
+        ),
+        (
+            "chr3".to_string(),
+            b"GATTACATTTTGATTACAGGGGGCCCCAAA".to_vec(),
+        ),
+    ])
+    .unwrap();
+
+    for pat in ["GATTACA", "ACGT", "GGGGG", "NNNN", "TTTTGGGG", "ZZZZ"] {
+        let out = Command::new(bin())
+            .args(["locate", "--index", idx.to_str().unwrap(), "--pattern", pat])
+            .output()
+            .expect("locate");
+        assert!(
+            out.status.success(),
+            "locate {pat} failed: {}",
+            String::from_utf8_lossy(&out.stderr)
+        );
+        let stdout = String::from_utf8_lossy(&out.stdout);
+
+        let mut expected: Vec<String> = gi
+            .locate_exact(pat.as_bytes(), 1024)
+            .into_iter()
+            .map(|l| {
+                let name = gi.contigs().by_id(l.contig).unwrap().name.to_string();
+                format!("{name}\t{}", l.pos.0)
+            })
+            .collect();
+        expected.sort();
+        let mut got: Vec<String> = stdout.lines().map(|s| s.to_string()).collect();
+        got.sort();
+        assert_eq!(got, expected, "locate mismatch for {pat}");
+    }
+    std::fs::remove_dir_all(&dir).ok();
+}