agentic-flow 1.9.0 → 1.9.2

package/agentic-flow/examples/crispr-cas13-pipeline/crates/alignment-engine/src/bwa.rs

@@ -1,255 +0,0 @@
-//! BWA (Burrows-Wheeler Aligner) wrapper implementation
-
-use crate::error::{AlignmentError, Result};
-use crate::{Aligner, AlignmentConfig};
-use async_trait::async_trait;
-use data_models::sequencing::{AlignedRead, FastqRecord, GenomicCoordinate};
-use rayon::prelude::*;
-use std::path::Path;
-use std::process::{Command, Stdio};
-use uuid::Uuid;
-
-/// BWA aligner implementation
-pub struct BwaAligner {
-    config: AlignmentConfig,
-    reference_indexed: bool,
-}
-
-impl BwaAligner {
-    /// Create a new BWA aligner
-    pub fn new(config: AlignmentConfig) -> Result<Self> {
-        if !Path::new(&config.reference_path).exists() {
-            return Err(AlignmentError::NotFound(format!(
-                "Reference file not found: {}",
-                config.reference_path
-            )));
-        }
-
-        Ok(Self {
-            config,
-            reference_indexed: false,
-        })
-    }
-
-    /// Index the reference genome if not already indexed
-    pub fn index_reference(&mut self) -> Result<()> {
-        tracing::info!("Indexing reference genome: {}", self.config.reference_path);
-
-        let output = Command::new("bwa")
-            .arg("index")
-            .arg(&self.config.reference_path)
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped())
-            .output()
-            .map_err(|e| AlignmentError::AlignmentFailed(format!("BWA index failed: {}", e)))?;
-
-        if !output.status.success() {
-            let stderr = String::from_utf8_lossy(&output.stderr);
-            return Err(AlignmentError::AlignmentFailed(format!(
-                "BWA index failed: {}",
-                stderr
-            )));
-        }
-
-        self.reference_indexed = true;
-        tracing::info!("Reference indexing completed");
-        Ok(())
-    }
-
-    /// Align reads using BWA MEM algorithm
-    fn align_with_bwa_mem(&self, reads: &[FastqRecord]) -> Result<Vec<AlignedRead>> {
-        // In a real implementation, this would:
-        // 1. Write reads to temporary FASTQ file
-        // 2. Run BWA MEM command
-        // 3. Parse SAM/BAM output
-        // 4. Convert to AlignedRead structures
-
-        // For now, return a mock implementation
-        let aligned: Vec<AlignedRead> = reads
-            .par_iter()
-            .filter_map(|read| self.mock_align_single(read).ok().flatten())
-            .collect();
-
-        Ok(aligned)
-    }
-
-    /// Mock alignment for a single read (placeholder for actual BWA integration)
-    fn mock_align_single(&self, read: &FastqRecord) -> Result<Option<AlignedRead>> {
-        // This is a simplified mock - real implementation would call BWA
-        let avg_quality = read.average_quality();
-
-        if avg_quality < self.config.min_mapq as f64 {
-            return Ok(None);
-        }
-
-        let position = GenomicCoordinate::new(0, 1000, 1000 + read.sequence.len() as u64, true)?;
-
-        let aligned = AlignedRead {
-            id: Uuid::new_v4(),
-            qname: read.id.clone(),
-            position,
-            mapq: avg_quality as u8,
-            cigar: format!("{}M", read.sequence.len()),
-            sequence: read.sequence.clone(),
-            quality: read.quality.clone(),
-            flags: 0,
-            nm: Some(0),
-        };
-
-        Ok(Some(aligned))
-    }
-
-    /// Calculate alignment score for a read
-    fn calculate_alignment_score(&self, read: &FastqRecord) -> i32 {
-        // Simplified scoring based on quality and length
-        let avg_qual = read.average_quality();
-        let length = read.sequence.len() as i32;
-        ((avg_qual * length as f64) / 40.0) as i32
-    }
-}
-
-#[async_trait]
-impl Aligner for BwaAligner {
-    async fn align_read(&self, read: &FastqRecord) -> Result<Option<AlignedRead>> {
-        self.mock_align_single(read)
-    }
-
-    async fn align_batch(&self, reads: Vec<FastqRecord>) -> Result<Vec<AlignedRead>> {
-        tokio::task::spawn_blocking({
-            let config = self.config.clone();
-            move || {
-                let aligner = BwaAligner {
-                    config,
-                    reference_indexed: true,
-                };
-                aligner.align_with_bwa_mem(&reads)
-            }
-        })
-        .await
-        .map_err(|e| AlignmentError::AlignmentFailed(format!("Task join error: {}", e)))?
-    }
-
-    fn name(&self) -> &str {
-        "BWA-MEM"
-    }
-
-    fn version(&self) -> &str {
-        "0.7.17"
-    }
-}
-
-/// CIGAR string parser for alignment operations
-pub struct CigarParser;
-
-impl CigarParser {
-    /// Parse CIGAR string into operations
-    pub fn parse(cigar: &str) -> Result<Vec<CigarOp>> {
-        let mut ops = Vec::new();
-        let mut num_str = String::new();
-
-        for ch in cigar.chars() {
-            if ch.is_ascii_digit() {
-                num_str.push(ch);
-            } else {
-                let length: u32 = num_str
-                    .parse()
-                    .map_err(|_| AlignmentError::Parse(format!("Invalid CIGAR: {}", cigar)))?;
-
-                let op = match ch {
-                    'M' => CigarOp::Match(length),
-                    'I' => CigarOp::Insertion(length),
-                    'D' => CigarOp::Deletion(length),
-                    'N' => CigarOp::Skip(length),
-                    'S' => CigarOp::SoftClip(length),
-                    'H' => CigarOp::HardClip(length),
-                    'P' => CigarOp::Padding(length),
-                    '=' => CigarOp::SequenceMatch(length),
-                    'X' => CigarOp::SequenceMismatch(length),
-                    _ => {
-                        return Err(AlignmentError::Parse(format!(
-                            "Unknown CIGAR operation: {}",
-                            ch
-                        )))
-                    }
-                };
-
-                ops.push(op);
-                num_str.clear();
-            }
-        }
-
-        Ok(ops)
-    }
-
-    /// Calculate reference length consumed by CIGAR operations
-    pub fn reference_length(ops: &[CigarOp]) -> u32 {
-        ops.iter()
-            .map(|op| match op {
-                CigarOp::Match(len)
-                | CigarOp::Deletion(len)
-                | CigarOp::Skip(len)
-                | CigarOp::SequenceMatch(len)
-                | CigarOp::SequenceMismatch(len) => *len,
-                _ => 0,
-            })
-            .sum()
-    }
-
-    /// Calculate query length consumed by CIGAR operations
-    pub fn query_length(ops: &[CigarOp]) -> u32 {
-        ops.iter()
-            .map(|op| match op {
-                CigarOp::Match(len)
-                | CigarOp::Insertion(len)
-                | CigarOp::SoftClip(len)
-                | CigarOp::SequenceMatch(len)
-                | CigarOp::SequenceMismatch(len) => *len,
-                _ => 0,
-            })
-            .sum()
-    }
-}
-
-/// CIGAR operation types
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum CigarOp {
-    Match(u32),
-    Insertion(u32),
-    Deletion(u32),
-    Skip(u32),
-    SoftClip(u32),
-    HardClip(u32),
-    Padding(u32),
-    SequenceMatch(u32),
-    SequenceMismatch(u32),
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_cigar_parser() {
-        let cigar = "10M2I5M3D8M";
-        let ops = CigarParser::parse(cigar).unwrap();
-
-        assert_eq!(ops.len(), 5);
-        assert_eq!(ops[0], CigarOp::Match(10));
-        assert_eq!(ops[1], CigarOp::Insertion(2));
-        assert_eq!(ops[2], CigarOp::Match(5));
-        assert_eq!(ops[3], CigarOp::Deletion(3));
-        assert_eq!(ops[4], CigarOp::Match(8));
-    }
-
-    #[test]
-    fn test_cigar_lengths() {
-        let ops = vec![
-            CigarOp::Match(10),
-            CigarOp::Insertion(2),
-            CigarOp::Deletion(3),
-        ];
-
-        assert_eq!(CigarParser::reference_length(&ops), 13);
-        assert_eq!(CigarParser::query_length(&ops), 12);
-    }
-}

package/agentic-flow/examples/crispr-cas13-pipeline/crates/alignment-engine/src/error.rs

@@ -1,34 +0,0 @@
-//! Error types for alignment engine
-
-use thiserror::Error;
-
-/// Result type for alignment operations
-pub type Result<T> = std::result::Result<T, AlignmentError>;
-
-/// Errors that can occur during alignment
-#[derive(Debug, Error)]
-pub enum AlignmentError {
-    #[error("IO error: {0}")]
-    Io(#[from] std::io::Error),
-
-    #[error("Invalid reference file: {0}")]
-    InvalidReference(String),
-
-    #[error("Alignment failed: {0}")]
-    AlignmentFailed(String),
-
-    #[error("Invalid BAM file: {0}")]
-    InvalidBam(String),
-
-    #[error("Data model error: {0}")]
-    DataModel(#[from] data_models::error::DataModelError),
-
-    #[error("Configuration error: {0}")]
-    Config(String),
-
-    #[error("Resource not found: {0}")]
-    NotFound(String),
-
-    #[error("Parse error: {0}")]
-    Parse(String),
-}

package/agentic-flow/examples/crispr-cas13-pipeline/crates/alignment-engine/src/lib.rs

@@ -1,136 +0,0 @@
-//! # Alignment Engine
-//!
-//! Read alignment module for the CRISPR-Cas13 pipeline.
-//! Provides interfaces for aligning sequencing reads to reference genomes.
-
-pub mod bwa;
-pub mod error;
-pub mod quality;
-
-use async_trait::async_trait;
-use data_models::sequencing::{AlignedRead, FastqRecord};
-pub use error::{AlignmentError, Result};
-
-/// Main alignment interface
-#[async_trait]
-pub trait Aligner: Send + Sync {
-    /// Align a single read to the reference
-    async fn align_read(&self, read: &FastqRecord) -> Result<Option<AlignedRead>>;
-
-    /// Align multiple reads in batch
-    async fn align_batch(&self, reads: Vec<FastqRecord>) -> Result<Vec<AlignedRead>>;
-
-    /// Get aligner name
-    fn name(&self) -> &str;
-
-    /// Get aligner version
-    fn version(&self) -> &str;
-}
-
-/// Alignment configuration
-#[derive(Debug, Clone)]
-pub struct AlignmentConfig {
-    /// Reference genome path
-    pub reference_path: String,
-    /// Minimum mapping quality
-    pub min_mapq: u8,
-    /// Number of threads
-    pub threads: usize,
-    /// Maximum number of mismatches allowed
-    pub max_mismatches: u32,
-    /// Seed length for alignment
-    pub seed_length: usize,
-}
-
-impl Default for AlignmentConfig {
-    fn default() -> Self {
-        Self {
-            reference_path: String::new(),
-            min_mapq: 20,
-            threads: 4,
-            max_mismatches: 3,
-            seed_length: 19,
-        }
-    }
-}
-
-/// Alignment statistics collector
-pub struct AlignmentStatsCollector {
-    pub total_reads: u64,
-    pub mapped_reads: u64,
-    pub unmapped_reads: u64,
-    pub low_quality_reads: u64,
-    pub duplicates: u64,
-    sum_mapq: u64,
-}
-
-impl AlignmentStatsCollector {
-    pub fn new() -> Self {
-        Self {
-            total_reads: 0,
-            mapped_reads: 0,
-            unmapped_reads: 0,
-            low_quality_reads: 0,
-            duplicates: 0,
-            sum_mapq: 0,
-        }
-    }
-
-    pub fn record_alignment(&mut self, read: &AlignedRead, min_mapq: u8) {
-        self.total_reads += 1;
-
-        if read.is_mapped() {
-            self.mapped_reads += 1;
-            self.sum_mapq += read.mapq as u64;
-
-            if read.mapq < min_mapq {
-                self.low_quality_reads += 1;
-            }
-
-            if read.is_duplicate() {
-                self.duplicates += 1;
-            }
-        } else {
-            self.unmapped_reads += 1;
-        }
-    }
-
-    pub fn average_mapq(&self) -> f64 {
-        if self.mapped_reads == 0 {
-            return 0.0;
-        }
-        self.sum_mapq as f64 / self.mapped_reads as f64
-    }
-
-    pub fn mapping_rate(&self) -> f64 {
-        if self.total_reads == 0 {
-            return 0.0;
-        }
-        (self.mapped_reads as f64 / self.total_reads as f64) * 100.0
-    }
-}
-
-impl Default for AlignmentStatsCollector {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_alignment_config_default() {
-        let config = AlignmentConfig::default();
-        assert_eq!(config.min_mapq, 20);
-        assert_eq!(config.threads, 4);
-    }
-
-    #[test]
-    fn test_stats_collector() {
-        let mut collector = AlignmentStatsCollector::new();
-        assert_eq!(collector.total_reads, 0);
-        assert_eq!(collector.mapping_rate(), 0.0);
-    }
-}

package/agentic-flow/examples/crispr-cas13-pipeline/crates/alignment-engine/src/quality.rs

@@ -1,287 +0,0 @@
-//! Quality scoring and filtering for aligned reads
-
-use crate::error::Result;
-use data_models::sequencing::AlignedRead;
-
-/// Quality metrics for aligned reads
-#[derive(Debug, Clone)]
-pub struct QualityMetrics {
-    /// Mapping quality score
-    pub mapq: u8,
-    /// Average base quality
-    pub avg_base_quality: f64,
-    /// Number of mismatches
-    pub mismatches: u32,
-    /// Alignment score
-    pub alignment_score: i32,
-    /// Percent identity
-    pub percent_identity: f64,
-}
-
-impl QualityMetrics {
-    /// Calculate quality metrics for an aligned read
-    pub fn from_aligned_read(read: &AlignedRead) -> Self {
-        let avg_base_quality = Self::calculate_average_quality(&read.quality);
-        let mismatches = read.nm.unwrap_or(0);
-        let percent_identity = Self::calculate_percent_identity(read, mismatches);
-
-        Self {
-            mapq: read.mapq,
-            avg_base_quality,
-            mismatches,
-            alignment_score: (read.mapq as i32) * 2,
-            percent_identity,
-        }
-    }
-
-    /// Calculate average base quality from Phred scores
-    fn calculate_average_quality(quality: &[u8]) -> f64 {
-        if quality.is_empty() {
-            return 0.0;
-        }
-        let sum: u32 = quality.iter().map(|&q| (q - 33) as u32).sum();
-        sum as f64 / quality.len() as f64
-    }
-
-    /// Calculate percent identity for alignment
-    fn calculate_percent_identity(read: &AlignedRead, mismatches: u32) -> f64 {
-        let read_length = read.sequence.len() as f64;
-        if read_length == 0.0 {
-            return 0.0;
-        }
-        ((read_length - mismatches as f64) / read_length) * 100.0
-    }
-
-    /// Check if read passes quality thresholds
-    pub fn passes_thresholds(&self, min_mapq: u8, min_identity: f64) -> bool {
-        self.mapq >= min_mapq && self.percent_identity >= min_identity
-    }
-}
-
-/// Quality filter for aligned reads
-pub struct QualityFilter {
-    /// Minimum mapping quality
-    pub min_mapq: u8,
-    /// Minimum base quality
-    pub min_base_quality: f64,
-    /// Maximum mismatches allowed
-    pub max_mismatches: u32,
-    /// Minimum percent identity
-    pub min_percent_identity: f64,
-    /// Filter duplicates
-    pub filter_duplicates: bool,
-    /// Filter secondary alignments
-    pub filter_secondary: bool,
-}
-
-impl QualityFilter {
-    /// Create a new quality filter with default settings
-    pub fn new() -> Self {
-        Self {
-            min_mapq: 20,
-            min_base_quality: 25.0,
-            max_mismatches: 3,
-            min_percent_identity: 95.0,
-            filter_duplicates: true,
-            filter_secondary: true,
-        }
-    }
-
-    /// Create a strict quality filter
-    pub fn strict() -> Self {
-        Self {
-            min_mapq: 30,
-            min_base_quality: 30.0,
-            max_mismatches: 2,
-            min_percent_identity: 98.0,
-            filter_duplicates: true,
-            filter_secondary: true,
-        }
-    }
-
-    /// Create a lenient quality filter
-    pub fn lenient() -> Self {
-        Self {
-            min_mapq: 10,
-            min_base_quality: 20.0,
-            max_mismatches: 5,
-            min_percent_identity: 90.0,
-            filter_duplicates: false,
-            filter_secondary: false,
-        }
-    }
-
-    /// Check if a read passes all filters
-    pub fn passes(&self, read: &AlignedRead) -> bool {
-        // Check if read is mapped
-        if !read.is_mapped() {
-            return false;
-        }
-
-        // Filter duplicates
-        if self.filter_duplicates && read.is_duplicate() {
-            return false;
-        }
-
-        // Filter secondary alignments
-        if self.filter_secondary && !read.is_primary() {
-            return false;
-        }
-
-        // Check mapping quality
-        if read.mapq < self.min_mapq {
-            return false;
-        }
-
-        // Calculate and check quality metrics
-        let metrics = QualityMetrics::from_aligned_read(read);
-
-        if metrics.avg_base_quality < self.min_base_quality {
-            return false;
-        }
-
-        if metrics.mismatches > self.max_mismatches {
-            return false;
-        }
-
-        if metrics.percent_identity < self.min_percent_identity {
-            return false;
-        }
-
-        true
-    }
-
-    /// Filter a collection of reads
-    pub fn filter_reads(&self, reads: Vec<AlignedRead>) -> Vec<AlignedRead> {
-        reads.into_iter().filter(|read| self.passes(read)).collect()
-    }
-
-    /// Count how many reads pass the filter
-    pub fn count_passing(&self, reads: &[AlignedRead]) -> usize {
-        reads.iter().filter(|read| self.passes(read)).count()
-    }
-}
-
-impl Default for QualityFilter {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-/// Quality statistics for a batch of reads
-#[derive(Debug, Default)]
-pub struct BatchQualityStats {
-    pub total_reads: usize,
-    pub passed_reads: usize,
-    pub failed_mapq: usize,
-    pub failed_base_quality: usize,
-    pub failed_mismatches: usize,
-    pub failed_identity: usize,
-    pub duplicates: usize,
-    pub secondary: usize,
-}
-
-impl BatchQualityStats {
-    /// Calculate passing rate
-    pub fn passing_rate(&self) -> f64 {
-        if self.total_reads == 0 {
-            return 0.0;
-        }
-        (self.passed_reads as f64 / self.total_reads as f64) * 100.0
-    }
-
-    /// Generate detailed statistics for a batch of reads
-    pub fn analyze(reads: &[AlignedRead], filter: &QualityFilter) -> Self {
-        let mut stats = Self {
-            total_reads: reads.len(),
-            ..Default::default()
-        };
-
-        for read in reads {
-            if filter.passes(read) {
-                stats.passed_reads += 1;
-            } else {
-                // Categorize failures
-                if read.mapq < filter.min_mapq {
-                    stats.failed_mapq += 1;
-                }
-
-                let metrics = QualityMetrics::from_aligned_read(read);
-                if metrics.avg_base_quality < filter.min_base_quality {
-                    stats.failed_base_quality += 1;
-                }
-                if metrics.mismatches > filter.max_mismatches {
-                    stats.failed_mismatches += 1;
-                }
-                if metrics.percent_identity < filter.min_percent_identity {
-                    stats.failed_identity += 1;
-                }
-            }
-
-            if read.is_duplicate() {
-                stats.duplicates += 1;
-            }
-            if !read.is_primary() {
-                stats.secondary += 1;
-            }
-        }
-
-        stats
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use data_models::sequencing::GenomicCoordinate;
-    use uuid::Uuid;
-
-    fn create_test_read(mapq: u8, quality: Vec<u8>, nm: u32) -> AlignedRead {
-        let position = GenomicCoordinate::new(0, 1000, 1100, true).unwrap();
-        AlignedRead {
-            id: Uuid::new_v4(),
-            qname: "test_read".to_string(),
-            position,
-            mapq,
-            cigar: "100M".to_string(),
-            sequence: "A".repeat(100),
-            quality,
-            flags: 0,
-            nm: Some(nm),
-        }
-    }
-
-    #[test]
-    fn test_quality_metrics() {
-        let read = create_test_read(30, vec![40; 100], 2);
-        let metrics = QualityMetrics::from_aligned_read(&read);
-
-        assert_eq!(metrics.mapq, 30);
-        assert_eq!(metrics.avg_base_quality, 7.0); // 40 - 33 = 7
-        assert_eq!(metrics.mismatches, 2);
-    }
-
-    #[test]
-    fn test_quality_filter_default() {
-        let filter = QualityFilter::new();
-        let good_read = create_test_read(25, vec![58; 100], 1); // Quality 25
-        let bad_read = create_test_read(15, vec![53; 100], 1); // Quality 20
-
-        assert!(filter.passes(&good_read));
-        assert!(!filter.passes(&bad_read));
-    }
-
-    #[test]
-    fn test_batch_quality_stats() {
-        let filter = QualityFilter::new();
-        let reads = vec![
-            create_test_read(30, vec![58; 100], 1),
-            create_test_read(15, vec![58; 100], 1),
-            create_test_read(25, vec![53; 100], 1),
-        ];
-
-        let stats = BatchQualityStats::analyze(&reads, &filter);
-        assert_eq!(stats.total_reads, 3);
-        assert!(stats.passing_rate() > 0.0);
-    }
-}