agentic-flow 1.9.0 → 1.9.2

package/agentic-flow/examples/crispr-cas13-pipeline/crates/immune-analyzer/tests/analysis_test.rs

@@ -1,258 +0,0 @@
-// Unit tests for immune analyzer - differential expression and statistical analysis
-#[cfg(test)]
-mod immune_analyzer_tests {
-    use super::*;
-
-    // Normalization tests
-    #[test]
-    fn test_tpm_normalization() {
-        // TODO: Test TPM (Transcripts Per Million) normalization
-        // Given: raw read counts for genes
-        // Expected: TPM values sum to 1,000,000
-        // Verify gene length normalization is correct
-        assert!(true, "Placeholder - implement when normalization exists");
-    }
-
-    #[test]
-    fn test_fpkm_normalization() {
-        // TODO: Test FPKM (Fragments Per Kilobase Million) normalization
-        // Given: raw read counts and gene lengths
-        // Expected: FPKM accounts for gene length and library size
-        // Verify calculations match DESeq2/edgeR standards
-        assert!(true, "Placeholder - implement when normalization exists");
-    }
-
-    #[test]
-    fn test_log_transformation() {
-        // TODO: Test log transformation of expression values
-        // Given: normalized expression values
-        // Expected: log2(x + 1) transformation applied correctly
-        // Verify zero counts handled properly
-        assert!(true, "Placeholder - implement when transformation exists");
-    }
-
-    #[test]
-    fn test_quantile_normalization() {
-        // TODO: Test quantile normalization across samples
-        // Given: expression matrices from multiple samples
-        // Expected: distributions matched after normalization
-        // Verify rank ordering preserved within samples
-        assert!(true, "Placeholder - implement when quantile norm exists");
-    }
-
-    // Differential expression tests
-    #[test]
-    fn test_deseq2_differential_expression() {
-        // TODO: Test DESeq2-style differential expression
-        // Given: control vs treatment expression data
-        // Expected: identifies known differentially expressed genes
-        // Verify p-values and fold-changes calculated correctly
-        assert!(true, "Placeholder - implement when DE analysis exists");
-    }
-
-    #[test]
-    fn test_fold_change_calculation() {
-        // TODO: Test log2 fold-change calculation
-        // Given: expression levels in two conditions
-        // Expected: log2(treatment/control) calculated correctly
-        // Verify pseudo-count added to avoid division by zero
-        assert!(true, "Placeholder - implement when fold change exists");
-    }
-
-    #[test]
-    fn test_multiple_testing_correction() {
-        // TODO: Test multiple testing correction (FDR/Benjamini-Hochberg)
-        // Given: raw p-values from statistical tests
-        // Expected: adjusted p-values (q-values) control FDR
-        // Verify FDR < 0.05 gives reasonable gene list
-        assert!(true, "Placeholder - implement when FDR correction exists");
-    }
-
-    #[test]
-    fn test_volcano_plot_data() {
-        // TODO: Test volcano plot data generation
-        // Given: differential expression results
-        // Expected: fold-change vs -log10(p-value) data
-        // Verify significant genes flagged correctly
-        assert!(true, "Placeholder - implement when DE results exist");
-    }
-
-    // Statistical tests
-    #[test]
-    fn test_t_test_implementation() {
-        // TODO: Test Student's t-test implementation
-        // Given: two groups of expression measurements
-        // Expected: t-statistic and p-value calculated correctly
-        // Verify assumptions checked (normality, equal variance)
-        assert!(true, "Placeholder - implement when t-test exists");
-    }
-
-    #[test]
-    fn test_wilcoxon_rank_sum_test() {
-        // TODO: Test non-parametric Wilcoxon test
-        // Given: non-normally distributed expression data
-        // Expected: rank-sum test gives valid p-values
-        // Verify handles ties correctly
-        assert!(true, "Placeholder - implement when Wilcoxon exists");
-    }
-
-    #[test]
-    fn test_anova_multi_group_comparison() {
-        // TODO: Test ANOVA for multi-group comparison
-        // Given: expression data from 3+ experimental groups
-        // Expected: identifies genes with significant group differences
-        // Verify post-hoc tests (Tukey HSD) work correctly
-        assert!(true, "Placeholder - implement when ANOVA exists");
-    }
-
-    // Immune response specific tests
-    #[test]
-    fn test_interferon_response_detection() {
-        // TODO: Test interferon response signature detection
-        // Given: expression data including interferon-stimulated genes
-        // Expected: identifies IFN response activation
-        // Verify signature scoring matches literature
-        assert!(true, "Placeholder - implement when signatures exist");
-    }
-
-    #[test]
-    fn test_inflammatory_pathway_enrichment() {
-        // TODO: Test inflammatory pathway enrichment analysis
-        // Given: differentially expressed genes
-        // Expected: identifies enriched inflammatory pathways
-        // Verify against GSEA/KEGG pathway databases
-        assert!(true, "Placeholder - implement when enrichment exists");
-    }
-
-    #[test]
-    fn test_cytokine_expression_analysis() {
-        // TODO: Test cytokine expression profiling
-        // Given: RNA-seq data including cytokine genes
-        // Expected: quantifies cytokine response signature
-        // Verify specific cytokines (IL-6, TNF-α, etc.) tracked
-        assert!(
-            true,
-            "Placeholder - implement when cytokine analysis exists"
-        );
-    }
-
-    #[test]
-    fn test_immune_cell_type_deconvolution() {
-        // TODO: Test immune cell type deconvolution
-        // Given: bulk RNA-seq data from tissue
-        // Expected: estimates proportions of immune cell types
-        // Verify against CIBERSORTx or xCell benchmarks
-        assert!(true, "Placeholder - implement when deconvolution exists");
-    }
-
-    // Edge cases and robustness
-    #[test]
-    fn test_low_count_gene_filtering() {
-        // TODO: Test filtering of low-count genes
-        // Given: genes with <10 reads across all samples
-        // Expected: low-count genes filtered before DE analysis
-        // Verify filter threshold is configurable
-        assert!(true, "Placeholder - implement when filtering exists");
-    }
-
-    #[test]
-    fn test_outlier_sample_detection() {
-        // TODO: Test outlier sample detection
-        // Given: expression matrix with one aberrant sample
-        // Expected: PCA/hierarchical clustering identifies outlier
-        // Verify sample quality metrics calculated
-        assert!(true, "Placeholder - implement when QC exists");
-    }
-
-    #[test]
-    fn test_batch_effect_correction() {
-        // TODO: Test batch effect correction (Combat-seq)
-        // Given: samples processed in multiple batches
-        // Expected: batch effects removed while preserving biology
-        // Verify PCA shows batches mixed after correction
-        assert!(true, "Placeholder - implement when batch correction exists");
-    }
-
-    #[test]
-    fn test_missing_data_handling() {
-        // TODO: Test handling of missing expression values
-        // Given: expression matrix with some missing values
-        // Expected: imputation or appropriate handling
-        // Verify statistical tests account for missing data
-        assert!(true, "Placeholder - implement when missing data handled");
-    }
-
-    // Performance tests
-    #[test]
-    fn test_large_gene_set_performance() {
-        // TODO: Test performance with full transcriptome
-        // Given: 20,000 genes × 100 samples
-        // Expected: DE analysis completes in <5 minutes
-        // Verify memory usage < 8 GB
-        assert!(true, "Placeholder - implement when analysis exists");
-    }
-
-    #[test]
-    fn test_parallel_gene_processing() {
-        // TODO: Test parallel processing of genes
-        // Given: multi-core system
-        // Expected: linear speedup with number of cores
-        // Verify thread safety of statistical functions
-        assert!(true, "Placeholder - implement when parallelization exists");
-    }
-}
-
-// Property-based tests
-#[cfg(test)]
-mod immune_property_tests {
-    use super::*;
-
-    #[test]
-    fn proptest_normalization_properties() {
-        // TODO: Property-based test for normalization
-        // Property: Sum invariance - TPM sums to 1M
-        // Property: Non-negativity - no negative values after normalization
-        // Property: Scale independence - relative ordering preserved
-        assert!(true, "Placeholder - implement with proptest");
-    }
-
-    #[test]
-    fn proptest_fold_change_symmetry() {
-        // TODO: Property-based test for fold-change symmetry
-        // Property: log2(A/B) = -log2(B/A)
-        // Property: FC(A,B) * FC(B,A) = 1 (in linear space)
-        assert!(true, "Placeholder - implement with proptest");
-    }
-
-    #[test]
-    fn proptest_statistical_test_validity() {
-        // TODO: Property-based test for p-value properties
-        // Property: p-values uniformly distributed under null hypothesis
-        // Property: 0 ≤ p-value ≤ 1
-        // Property: FDR correction maintains monotonicity
-        assert!(true, "Placeholder - implement with proptest");
-    }
-}
-
-// Integration tests with statistical libraries
-#[cfg(test)]
-mod statistics_integration_tests {
-    use super::*;
-
-    #[test]
-    fn test_ndarray_integration() {
-        // TODO: Test integration with ndarray for matrix operations
-        // Verify efficient matrix computations
-        // Test BLAS integration if available
-        assert!(true, "Placeholder - implement when ndarray used");
-    }
-
-    #[test]
-    fn test_known_dataset_replication() {
-        // TODO: Test against published benchmark datasets
-        // Given: Pasilla dataset (Drosophila RNA-seq)
-        // Expected: results match DESeq2 reference analysis
-        // Verify gene lists overlap > 95%
-        assert!(true, "Placeholder - implement with benchmark data");
-    }
-}

package/agentic-flow/examples/crispr-cas13-pipeline/crates/offtarget-predictor/Cargo.toml

@@ -1,26 +0,0 @@
-[package]
-name = "offtarget-predictor"
-version = "0.1.0"
-edition = "2021"
-authors = ["CRISPR-Cas13 Team"]
-description = "ML-based off-target prediction for CRISPR-Cas13"
-license = "MIT"
-
-[dependencies]
-data-models = { path = "../data-models" }
-alignment-engine = { path = "../alignment-engine" }
-tokio = { version = "1.40", features = ["full"] }
-async-trait = "0.1"
-thiserror = "1.0"
-tracing = "0.1"
-ndarray = "0.16"
-rayon = "1.8"
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-uuid = { version = "1.10", features = ["v4", "serde"] }
-chrono = { version = "0.4", features = ["serde"] }
-
-[dev-dependencies]
-proptest = "1.5"
-tempfile = "3.8"
-approx = "0.5"

package/agentic-flow/examples/crispr-cas13-pipeline/crates/offtarget-predictor/src/error.rs

@@ -1,34 +0,0 @@
-//! Error types for off-target prediction
-
-use thiserror::Error;
-
-/// Result type for prediction operations
-pub type Result<T> = std::result::Result<T, PredictionError>;
-
-/// Errors that can occur during off-target prediction
-#[derive(Debug, Error)]
-pub enum PredictionError {
-    #[error("IO error: {0}")]
-    Io(#[from] std::io::Error),
-
-    #[error("Model error: {0}")]
-    Model(String),
-
-    #[error("Feature extraction error: {0}")]
-    FeatureExtraction(String),
-
-    #[error("Invalid configuration: {0}")]
-    Config(String),
-
-    #[error("Data model error: {0}")]
-    DataModel(#[from] data_models::error::DataModelError),
-
-    #[error("Alignment error: {0}")]
-    Alignment(#[from] alignment_engine::error::AlignmentError),
-
-    #[error("Serialization error: {0}")]
-    Serialization(#[from] serde_json::Error),
-
-    #[error("Computation error: {0}")]
-    Computation(String),
-}

package/agentic-flow/examples/crispr-cas13-pipeline/crates/offtarget-predictor/src/features.rs

@@ -1,272 +0,0 @@
-//! Feature extraction for off-target prediction
-
-use crate::error::{PredictionError, Result};
-use data_models::sequencing::AlignedRead;
-use data_models::targets::{CrisprTarget, OffTargetFeatures};
-use ndarray::{Array1, Array2};
-use std::collections::HashMap;
-
-/// Feature extractor for machine learning models
-pub struct FeatureExtractor {
-    /// Include position-weighted features
-    pub position_weighted: bool,
-    /// Include thermodynamic features
-    pub thermodynamic: bool,
-    /// Include sequence context features
-    pub sequence_context: bool,
-}
-
-impl FeatureExtractor {
-    pub fn new() -> Self {
-        Self {
-            position_weighted: true,
-            thermodynamic: true,
-            sequence_context: true,
-        }
-    }
-
-    /// Extract features from a potential off-target site
-    pub fn extract(&self, target: &CrisprTarget, candidate_sequence: &str) -> Result<Array1<f64>> {
-        let mut features = Vec::new();
-
-        // Basic mismatch features
-        let mismatches = self.count_mismatches(&target.guide_rna, candidate_sequence);
-        features.push(mismatches as f64);
-
-        // Position-weighted mismatch score
-        if self.position_weighted {
-            let position_score =
-                self.position_weighted_score(&target.guide_rna, candidate_sequence);
-            features.push(position_score);
-        }
-
-        // GC content features
-        let target_gc = self.calculate_gc_content(&target.guide_rna);
-        let candidate_gc = self.calculate_gc_content(candidate_sequence);
-        features.push(target_gc);
-        features.push(candidate_gc);
-        features.push((target_gc - candidate_gc).abs());
-
-        // Seed region mismatches (first 10 nucleotides)
-        let seed_mismatches = self.count_seed_mismatches(&target.guide_rna, candidate_sequence, 10);
-        features.push(seed_mismatches as f64);
-
-        // Thermodynamic features
-        if self.thermodynamic {
-            let tm_diff = (target.calculate_tm() - self.calculate_tm(candidate_sequence)).abs();
-            features.push(tm_diff);
-        }
-
-        // Sequence context features
-        if self.sequence_context {
-            let context = self.extract_context_features(candidate_sequence);
-            features.extend(context);
-        }
-
-        Ok(Array1::from(features))
-    }
-
-    /// Extract features for batch prediction
-    pub fn extract_batch(
-        &self,
-        target: &CrisprTarget,
-        candidates: &[String],
-    ) -> Result<Array2<f64>> {
-        let num_features = self.count_features();
-        let mut feature_matrix = Array2::zeros((candidates.len(), num_features));
-
-        for (i, candidate) in candidates.iter().enumerate() {
-            let features = self.extract(target, candidate)?;
-            feature_matrix.row_mut(i).assign(&features);
-        }
-
-        Ok(feature_matrix)
-    }
-
-    /// Count number of features extracted
-    fn count_features(&self) -> usize {
-        let mut count = 6; // Base features
-        if self.position_weighted {
-            count += 1;
-        }
-        if self.thermodynamic {
-            count += 1;
-        }
-        if self.sequence_context {
-            count += 4; // 4 context features
-        }
-        count
-    }
-
-    /// Count mismatches between two sequences
-    fn count_mismatches(&self, seq1: &str, seq2: &str) -> usize {
-        seq1.chars()
-            .zip(seq2.chars())
-            .filter(|(a, b)| a.to_ascii_uppercase() != b.to_ascii_uppercase())
-            .count()
-    }
-
-    /// Count mismatches in seed region
-    fn count_seed_mismatches(&self, seq1: &str, seq2: &str, seed_length: usize) -> usize {
-        let len = seed_length.min(seq1.len()).min(seq2.len());
-        seq1.chars()
-            .take(len)
-            .zip(seq2.chars().take(len))
-            .filter(|(a, b)| a.to_ascii_uppercase() != b.to_ascii_uppercase())
-            .count()
-    }
-
-    /// Calculate position-weighted mismatch score
-    /// Higher penalties for mismatches closer to 5' end (PAM-proximal)
-    fn position_weighted_score(&self, seq1: &str, seq2: &str) -> f64 {
-        let mut score = 0.0;
-        let length = seq1.len().min(seq2.len());
-
-        for (pos, (a, b)) in seq1.chars().zip(seq2.chars()).enumerate() {
-            if a.to_ascii_uppercase() != b.to_ascii_uppercase() {
-                // Weight decreases linearly from 5' to 3'
-                let weight = 1.0 - (pos as f64 / length as f64);
-                score += weight;
-            }
-        }
-
-        score
-    }
-
-    /// Calculate GC content percentage
-    pub fn calculate_gc_content(&self, sequence: &str) -> f64 {
-        let gc_count = sequence
-            .chars()
-            .filter(|&c| matches!(c.to_ascii_uppercase(), 'G' | 'C'))
-            .count();
-        (gc_count as f64 / sequence.len() as f64) * 100.0
-    }
-
-    /// Calculate melting temperature
-    fn calculate_tm(&self, sequence: &str) -> f64 {
-        let gc_count = sequence
-            .chars()
-            .filter(|&c| matches!(c.to_ascii_uppercase(), 'G' | 'C'))
-            .count() as f64;
-        let at_count = sequence.len() as f64 - gc_count;
-        4.0 * gc_count + 2.0 * at_count
-    }
-
-    /// Extract sequence context features
-    fn extract_context_features(&self, sequence: &str) -> Vec<f64> {
-        vec![
-            self.count_homopolymers(sequence) as f64,
-            self.calculate_complexity(sequence),
-            self.count_dinucleotide_repeats(sequence) as f64,
-            self.calculate_purine_content(sequence),
-        ]
-    }
-
-    /// Count homopolymer runs (e.g., AAAA, GGGG)
-    fn count_homopolymers(&self, sequence: &str) -> usize {
-        let mut count = 0;
-        let mut last_char = '\0';
-        let mut run_length = 0;
-
-        for ch in sequence.chars() {
-            if ch == last_char {
-                run_length += 1;
-                if run_length >= 4 {
-                    count += 1;
-                }
-            } else {
-                last_char = ch;
-                run_length = 1;
-            }
-        }
-
-        count
-    }
-
-    /// Calculate sequence complexity (Shannon entropy)
-    fn calculate_complexity(&self, sequence: &str) -> f64 {
-        let mut counts: HashMap<char, usize> = HashMap::new();
-        for ch in sequence.chars() {
-            *counts.entry(ch.to_ascii_uppercase()).or_insert(0) += 1;
-        }
-
-        let len = sequence.len() as f64;
-        let mut entropy = 0.0;
-
-        for count in counts.values() {
-            let freq = *count as f64 / len;
-            entropy -= freq * freq.log2();
-        }
-
-        entropy
-    }
-
-    /// Count dinucleotide repeats
-    fn count_dinucleotide_repeats(&self, sequence: &str) -> usize {
-        let mut count = 0;
-        let chars: Vec<char> = sequence.chars().collect();
-
-        for i in 0..chars.len().saturating_sub(3) {
-            if chars[i] == chars[i + 2] && chars[i + 1] == chars[i + 3] {
-                count += 1;
-            }
-        }
-
-        count
-    }
-
-    /// Calculate purine content (A, G)
-    fn calculate_purine_content(&self, sequence: &str) -> f64 {
-        let purine_count = sequence
-            .chars()
-            .filter(|&c| matches!(c.to_ascii_uppercase(), 'A' | 'G'))
-            .count();
-        (purine_count as f64 / sequence.len() as f64) * 100.0
-    }
-}
-
-impl Default for FeatureExtractor {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use data_models::sequencing::GenomicCoordinate;
-
-    fn create_test_target() -> CrisprTarget {
-        let location = GenomicCoordinate::new(0, 1000, 1023, true).unwrap();
-        CrisprTarget::new(
-            "GUUUUAGAGCUAUGCUGUUUUG".to_string(),
-            "GUUUUAGAGCUAUGCUGUUUUG".to_string(),
-            location,
-        )
-        .unwrap()
-    }
-
-    #[test]
-    fn test_feature_extraction() {
-        let extractor = FeatureExtractor::new();
-        let target = create_test_target();
-        let candidate = "GUUUUAGAGCUAUGCUGUUUUA";
-
-        let features = extractor.extract(&target, candidate).unwrap();
-        assert!(features.len() > 0);
-    }
-
-    #[test]
-    fn test_mismatch_counting() {
-        let extractor = FeatureExtractor::new();
-        let mismatches = extractor.count_mismatches("ACGT", "ACCT");
-        assert_eq!(mismatches, 1);
-    }
-
-    #[test]
-    fn test_gc_content() {
-        let extractor = FeatureExtractor::new();
-        let gc = extractor.calculate_gc_content("GCGCGCGC");
-        assert_eq!(gc, 100.0);
-    }
-}

package/agentic-flow/examples/crispr-cas13-pipeline/crates/offtarget-predictor/src/lib.rs

@@ -1,72 +0,0 @@
-//! # Off-Target Predictor
-//!
-//! ML-based off-target prediction for CRISPR-Cas13.
-//! Uses machine learning models to predict potential off-target cleavage sites.
-
-pub mod error;
-pub mod features;
-pub mod ml_model;
-pub mod scoring;
-
-use async_trait::async_trait;
-use data_models::targets::{CrisprTarget, OffTargetPrediction, OffTargetSite};
-pub use error::{PredictionError, Result};
-
-/// Main predictor interface
-#[async_trait]
-pub trait OffTargetPredictor: Send + Sync {
-    /// Predict off-targets for a given CRISPR target
-    async fn predict(&self, target: &CrisprTarget) -> Result<OffTargetPrediction>;
-
-    /// Batch predict off-targets for multiple targets
-    async fn predict_batch(&self, targets: Vec<CrisprTarget>) -> Result<Vec<OffTargetPrediction>>;
-
-    /// Get predictor name
-    fn name(&self) -> &str;
-
-    /// Get model version
-    fn version(&self) -> &str;
-}
-
-/// Off-target prediction configuration
-#[derive(Debug, Clone)]
-pub struct PredictionConfig {
-    /// Reference genome path
-    pub reference_genome: String,
-    /// Maximum mismatches to search for
-    pub max_mismatches: u8,
-    /// Minimum score threshold for reporting
-    pub min_score: f64,
-    /// Use ML model for scoring
-    pub use_ml_model: bool,
-    /// ML model path
-    pub model_path: Option<String>,
-    /// Number of parallel workers
-    pub num_workers: usize,
-}
-
-impl Default for PredictionConfig {
-    fn default() -> Self {
-        Self {
-            reference_genome: String::new(),
-            max_mismatches: 3,
-            min_score: 0.3,
-            use_ml_model: true,
-            model_path: None,
-            num_workers: 4,
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_prediction_config_default() {
-        let config = PredictionConfig::default();
-        assert_eq!(config.max_mismatches, 3);
-        assert_eq!(config.min_score, 0.3);
-        assert!(config.use_ml_model);
-    }
-}