tandemox 0.1.0

Pure-Rust tandem repeat finder: indel-tolerant detection of approximate tandem repeats in DNA, validated for concordance against Tandem Repeats Finder (TRF).
Documentation
//! tandemox CLI — pure-Rust tandem repeat finder.
//!
//! Usage: `tandemox <input.fasta>`
//!
//! Reads a FASTA file, runs [`tandemox::detect`] on each record, and prints a
//! TRF-.dat-like TSV to stdout:
//!
//! ```text
//! seqname  start  end  period  copies  identity  score
//! ```
//!
//! `start`/`end` are 1-based inclusive.

use std::env;
use std::process;
use std::thread;

use needletail::parse_fastx_file;
use tandemox::detect_parallel;

/// Threads for per-sequence detection. Honours `TANDEMOX_THREADS`, else uses the
/// machine's parallelism capped at 16 (period-loop returns diminish past that).
fn thread_count() -> usize {
    if let Ok(v) = env::var("TANDEMOX_THREADS") {
        if let Ok(n) = v.parse::<usize>() {
            return n.max(1);
        }
    }
    thread::available_parallelism()
        .map(|n| n.get().min(16))
        .unwrap_or(1)
}

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() != 2 || args[1] == "-h" || args[1] == "--help" {
        eprintln!("Usage: {} <input.fasta>", args.first().map(String::as_str).unwrap_or("tandemox"));
        eprintln!();
        eprintln!("Pure-Rust tandem repeat finder. Prints a TSV of detected");
        eprintln!("tandem repeats (seqname, start, end, period, copies, identity, score).");
        eprintln!();
        eprintln!("Uses up to 16 threads per sequence; override with TANDEMOX_THREADS=N.");
        process::exit(if args.len() == 2 { 0 } else { 2 });
    }
    let path = &args[1];
    let threads = thread_count();

    let mut reader = match parse_fastx_file(path) {
        Ok(r) => r,
        Err(e) => {
            eprintln!("tandemox: failed to open {}: {}", path, e);
            process::exit(1);
        }
    };

    // TSV header.
    println!("seqname\tstart\tend\tperiod\tcopies\tidentity\tscore");

    while let Some(rec) = reader.next() {
        let rec = match rec {
            Ok(r) => r,
            Err(e) => {
                eprintln!("tandemox: error reading record: {}", e);
                process::exit(1);
            }
        };
        // Sequence name = first whitespace-delimited token of the FASTA id.
        let id = rec.id();
        let name = id
            .split(|&b| b == b' ' || b == b'\t')
            .next()
            .unwrap_or(id);
        let name = String::from_utf8_lossy(name);

        let seq = rec.seq();
        for r in detect_parallel(&seq, threads) {
            println!(
                "{}\t{}\t{}\t{}\t{:.1}\t{:.3}\t{:.0}",
                name, r.start, r.end, r.period, r.copies, r.identity, r.score
            );
        }
    }
}