agentic-flow 1.9.0 → 1.9.2

package/agentic-flow/examples/crispr-cas13-pipeline/src/governance/policy.rs

@@ -1,339 +0,0 @@
-//! Policy Enforcement Engine
-//!
-//! Integrates with Open Policy Agent (OPA) for fine-grained access control and governance.
-
-use serde::{Deserialize, Serialize};
-use std::sync::Arc;
-use thiserror::Error;
-use tokio::sync::RwLock;
-use tracing::{debug, info, warn};
-
-#[derive(Error, Debug)]
-pub enum PolicyError {
-    #[error("Policy evaluation failed: {0}")]
-    EvaluationError(String),
-    #[error("Policy not found: {0}")]
-    PolicyNotFound(String),
-    #[error("Invalid policy: {0}")]
-    InvalidPolicy(String),
-    #[error("OPA communication error: {0}")]
-    OpaError(String),
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct Policy {
-    pub id: String,
-    pub name: String,
-    pub description: String,
-    pub rules: Vec<PolicyRule>,
-    pub created_at: chrono::DateTime<chrono::Utc>,
-    pub updated_at: chrono::DateTime<chrono::Utc>,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct PolicyRule {
-    pub id: String,
-    pub resource_type: String,
-    pub action: String,
-    pub conditions: Vec<Condition>,
-    pub effect: Effect,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub enum Effect {
-    Allow,
-    Deny,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct Condition {
-    pub field: String,
-    pub operator: Operator,
-    pub value: serde_json::Value,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub enum Operator {
-    Equals,
-    NotEquals,
-    GreaterThan,
-    LessThan,
-    In,
-    NotIn,
-    Contains,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct PolicyDecision {
-    pub allowed: bool,
-    pub reason: Option<String>,
-    pub matched_rules: Vec<String>,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct PolicyConfig {
-    pub opa_url: String,
-    pub opa_timeout_secs: u64,
-    pub cache_enabled: bool,
-}
-
-impl Default for PolicyConfig {
-    fn default() -> Self {
-        Self {
-            opa_url: "http://localhost:8181".to_string(),
-            opa_timeout_secs: 5,
-            cache_enabled: true,
-        }
-    }
-}
-
-pub struct PolicyEnforcer {
-    config: PolicyConfig,
-    policies: Arc<RwLock<std::collections::HashMap<String, Policy>>>,
-    decision_cache: Arc<RwLock<std::collections::HashMap<String, PolicyDecision>>>,
-}
-
-impl PolicyEnforcer {
-    pub fn new(config: PolicyConfig) -> Self {
-        Self {
-            config,
-            policies: Arc::new(RwLock::new(std::collections::HashMap::new())),
-            decision_cache: Arc::new(RwLock::new(std::collections::HashMap::new())),
-        }
-    }
-
-    /// Add a new policy
-    pub async fn add_policy(&self, policy: Policy) -> anyhow::Result<()> {
-        info!("Adding policy: {} ({})", policy.name, policy.id);
-        self.policies.write().await.insert(policy.id.clone(), policy);
-        Ok(())
-    }
-
-    /// Remove a policy
-    pub async fn remove_policy(&self, policy_id: &str) -> anyhow::Result<()> {
-        info!("Removing policy: {}", policy_id);
-        self.policies.write().await.remove(policy_id);
-        // Clear cache entries for this policy
-        self.decision_cache.write().await.clear();
-        Ok(())
-    }
-
-    /// Evaluate policy for a request
-    pub async fn evaluate(
-        &self,
-        subject: &str,
-        action: &str,
-        resource: &str,
-    ) -> Result<PolicyDecision, PolicyError> {
-        debug!("Evaluating policy: subject={}, action={}, resource={}", subject, action, resource);
-
-        // Check cache first
-        let cache_key = format!("{}:{}:{}", subject, action, resource);
-        if self.config.cache_enabled {
-            if let Some(cached) = self.decision_cache.read().await.get(&cache_key) {
-                debug!("Returning cached policy decision");
-                return Ok(cached.clone());
-            }
-        }
-
-        // Evaluate against local policies
-        let decision = self.evaluate_local(subject, action, resource).await?;
-
-        // Cache the decision
-        if self.config.cache_enabled {
-            self.decision_cache
-                .write()
-                .await
-                .insert(cache_key, decision.clone());
-        }
-
-        Ok(decision)
-    }
-
-    /// Evaluate against local policies
-    async fn evaluate_local(
-        &self,
-        subject: &str,
-        action: &str,
-        resource: &str,
-    ) -> Result<PolicyDecision, PolicyError> {
-        let policies = self.policies.read().await;
-        let mut matched_rules = Vec::new();
-        let mut final_effect = Effect::Deny;
-
-        for policy in policies.values() {
-            for rule in &policy.rules {
-                if self.rule_matches(rule, subject, action, resource).await {
-                    matched_rules.push(rule.id.clone());
-
-                    match rule.effect {
-                        Effect::Allow => final_effect = Effect::Allow,
-                        Effect::Deny => {
-                            // Deny takes precedence
-                            return Ok(PolicyDecision {
-                                allowed: false,
-                                reason: Some(format!("Denied by rule: {}", rule.id)),
-                                matched_rules,
-                            });
-                        }
-                    }
-                }
-            }
-        }
-
-        let allowed = matches!(final_effect, Effect::Allow);
-
-        Ok(PolicyDecision {
-            allowed,
-            reason: if allowed {
-                Some("Allowed by policy".to_string())
-            } else {
-                Some("No matching allow rule".to_string())
-            },
-            matched_rules,
-        })
-    }
-
-    /// Check if a rule matches the request
-    async fn rule_matches(&self, rule: &PolicyRule, subject: &str, action: &str, resource: &str) -> bool {
-        // Check action match
-        if rule.action != "*" && rule.action != action {
-            return false;
-        }
-
-        // Check resource type match
-        if !resource.starts_with(&rule.resource_type) && rule.resource_type != "*" {
-            return false;
-        }
-
-        // Evaluate conditions
-        for condition in &rule.conditions {
-            if !self.evaluate_condition(condition, subject, resource).await {
-                return false;
-            }
-        }
-
-        true
-    }
-
-    /// Evaluate a single condition
-    async fn evaluate_condition(&self, condition: &Condition, subject: &str, resource: &str) -> bool {
-        // Simplified condition evaluation
-        // In production, this would extract actual field values from context
-        match condition.operator {
-            Operator::Equals => {
-                if condition.field == "subject" {
-                    return condition.value == serde_json::json!(subject);
-                }
-                true
-            }
-            Operator::In => {
-                if let Some(arr) = condition.value.as_array() {
-                    return arr.iter().any(|v| *v == serde_json::json!(subject));
-                }
-                false
-            }
-            _ => true, // Simplified for other operators
-        }
-    }
-
-    /// Call external OPA service
-    async fn call_opa(
-        &self,
-        input: serde_json::Value,
-    ) -> Result<PolicyDecision, PolicyError> {
-        debug!("Calling OPA at: {}", self.config.opa_url);
-
-        // This would make actual HTTP request to OPA
-        // Simplified implementation for demonstration
-        Ok(PolicyDecision {
-            allowed: true,
-            reason: Some("OPA evaluation (mock)".to_string()),
-            matched_rules: vec![],
-        })
-    }
-
-    /// Validate policy syntax
-    pub fn validate_policy(&self, policy: &Policy) -> Result<(), PolicyError> {
-        if policy.id.is_empty() {
-            return Err(PolicyError::InvalidPolicy("Policy ID cannot be empty".into()));
-        }
-
-        if policy.rules.is_empty() {
-            return Err(PolicyError::InvalidPolicy("Policy must have at least one rule".into()));
-        }
-
-        for rule in &policy.rules {
-            if rule.resource_type.is_empty() {
-                return Err(PolicyError::InvalidPolicy(
-                    format!("Rule {} has empty resource type", rule.id),
-                ));
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Create a default CRISPR data access policy
-    pub fn create_default_policy() -> Policy {
-        Policy {
-            id: "crispr-data-access".to_string(),
-            name: "CRISPR Data Access Policy".to_string(),
-            description: "Default policy for CRISPR genomic data access".to_string(),
-            rules: vec![
-                PolicyRule {
-                    id: "allow-researcher-read".to_string(),
-                    resource_type: "crispr:data".to_string(),
-                    action: "read".to_string(),
-                    conditions: vec![Condition {
-                        field: "role".to_string(),
-                        operator: Operator::In,
-                        value: serde_json::json!(["researcher", "admin"]),
-                    }],
-                    effect: Effect::Allow,
-                },
-                PolicyRule {
-                    id: "deny-export-pii".to_string(),
-                    resource_type: "crispr:patient".to_string(),
-                    action: "export".to_string(),
-                    conditions: vec![Condition {
-                        field: "contains_pii".to_string(),
-                        operator: Operator::Equals,
-                        value: serde_json::json!(true),
-                    }],
-                    effect: Effect::Deny,
-                },
-            ],
-            created_at: chrono::Utc::now(),
-            updated_at: chrono::Utc::now(),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[tokio::test]
-    async fn test_policy_evaluation() {
-        let enforcer = PolicyEnforcer::new(PolicyConfig::default());
-        let policy = PolicyEnforcer::create_default_policy();
-
-        enforcer.add_policy(policy).await.unwrap();
-
-        let decision = enforcer
-            .evaluate("researcher", "read", "crispr:data:sample1")
-            .await
-            .unwrap();
-
-        assert!(decision.allowed);
-    }
-
-    #[test]
-    fn test_policy_validation() {
-        let enforcer = PolicyEnforcer::new(PolicyConfig::default());
-        let policy = PolicyEnforcer::create_default_policy();
-
-        assert!(enforcer.validate_policy(&policy).is_ok());
-    }
-}

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

@@ -1,227 +0,0 @@
-//! # CRISPR-Cas13 Rights-Preserving Bioinformatics Platform
-//!
-//! High-performance Rust pipeline for CRISPR-Cas13 off-target analysis & immune response profiling
-//! with integrated privacy protection, policy enforcement, and immutable audit trails.
-//!
-//! ## Features
-//!
-//! - **Off-Target Prediction**: ML-enhanced CFD scoring with position-weighted mismatch analysis
-//! - **Immune Response Profiling**: DESeq2-style differential expression analysis
-//! - **Privacy Protection**: Differential privacy with budget tracking and data anonymization
-//! - **Policy Enforcement**: OPA-based access control and governance
-//! - **Audit Logging**: Cryptographically signed, tamper-proof audit trails
-//! - **Multi-Variant Support**: All 4 Cas13 variants (a, b, c, d)
-//! - **Production-Ready**: Kubernetes deployments, auto-scaling, monitoring
-//!
-//! ## Quick Start
-//!
-//! ```rust,no_run
-//! use crispr_cas13_pipeline::prelude::*;
-//!
-//! # async fn example() -> Result<(), Box<dyn std::error::Error>> {
-//! // Create CRISPR target
-//! let location = data_models::sequencing::GenomicCoordinate::new(0, 1000, 1023, true)?;
-//! let target = data_models::targets::CrisprTarget::new(
-//!     "GUUUUAGAGCUAUGCUGUUUUG".to_string(),
-//!     "GUUUUAGAGCUAUGCUGUUUUG".to_string(),
-//!     location,
-//! )?;
-//!
-//! // Run off-target prediction
-//! let config = offtarget_predictor::PredictionConfig::default();
-//! let predictor = offtarget_predictor::scoring::DefaultPredictor::new(config)?;
-//! let prediction = predictor.predict(&target).await?;
-//!
-//! println!("Found {} off-target sites", prediction.off_targets.len());
-//! # Ok(())
-//! # }
-//! ```
-
-// Rights-Preserving Platform Modules
-pub mod api;
-pub mod audit;
-pub mod governance;
-pub mod privacy;
-pub mod services;
-
-use std::sync::Arc;
-use thiserror::Error;
-
-#[derive(Error, Debug)]
-pub enum PlatformError {
-    #[error("Configuration error: {0}")]
-    ConfigError(String),
-    #[error("Initialization error: {0}")]
-    InitError(String),
-    #[error("Runtime error: {0}")]
-    RuntimeError(String),
-}
-
-/// Platform configuration
-#[derive(Clone, Debug)]
-pub struct PlatformConfig {
-    pub api_host: String,
-    pub api_port: u16,
-    pub grpc_host: String,
-    pub grpc_port: u16,
-    pub privacy_config: privacy::differential::PrivacyConfig,
-    pub audit_signing_key: String,
-    pub enable_policy_enforcement: bool,
-}
-
-impl Default for PlatformConfig {
-    fn default() -> Self {
-        Self {
-            api_host: "0.0.0.0".to_string(),
-            api_port: 8080,
-            grpc_host: "0.0.0.0".to_string(),
-            grpc_port: 50051,
-            privacy_config: privacy::differential::PrivacyConfig::default(),
-            audit_signing_key: "default-signing-key".to_string(),
-            enable_policy_enforcement: true,
-        }
-    }
-}
-
-/// Main platform instance
-pub struct Platform {
-    config: PlatformConfig,
-    gateway_state: api::gateway::GatewayState,
-    service_registry: Arc<services::grpc::ServiceRegistry>,
-    analysis_service: Arc<services::grpc::AnalysisService>,
-}
-
-impl Platform {
-    /// Initialize the platform
-    pub async fn new(config: PlatformConfig) -> Result<Self, PlatformError> {
-        tracing::info!("🧬 Initializing CRISPR-Cas13 Rights-Preserving Platform");
-
-        // Initialize core components
-        let privacy_engine = Arc::new(privacy::differential::PrivacyEngine::new(config.privacy_config.clone()));
-        let policy_enforcer = Arc::new(governance::policy::PolicyEnforcer::new(
-            governance::policy::PolicyConfig::default(),
-        ));
-        let audit_logger = Arc::new(audit::logger::AuditLogger::new(config.audit_signing_key.clone()));
-
-        // Add default policy if enabled
-        if config.enable_policy_enforcement {
-            let default_policy = governance::policy::PolicyEnforcer::create_default_policy();
-            policy_enforcer
-                .add_policy(default_policy)
-                .await
-                .map_err(|e| PlatformError::InitError(e.to_string()))?;
-        }
-
-        // Create gateway state
-        let gateway_state = api::gateway::GatewayState {
-            auth_tokens: Arc::new(tokio::sync::RwLock::new(std::collections::HashMap::new())),
-            privacy_engine: privacy_engine.clone(),
-            policy_enforcer: policy_enforcer.clone(),
-            audit_logger: audit_logger.clone(),
-        };
-
-        // Initialize service registry
-        let service_registry = Arc::new(services::grpc::ServiceRegistry::new());
-        let analysis_service = Arc::new(services::grpc::AnalysisService::new(service_registry.clone()));
-
-        // Register core services
-        service_registry
-            .register_service(services::grpc::ServiceConfig {
-                service_name: "analysis-service".to_string(),
-                host: config.grpc_host.clone(),
-                port: config.grpc_port,
-                health_check_interval_secs: 30,
-                timeout_secs: 10,
-            })
-            .await
-            .map_err(|e| PlatformError::InitError(e.to_string()))?;
-
-        tracing::info!("✅ Platform initialized successfully");
-
-        Ok(Self {
-            config,
-            gateway_state,
-            service_registry,
-            analysis_service,
-        })
-    }
-
-    /// Get platform status
-    pub async fn status(&self) -> PlatformStatus {
-        let services = self.service_registry.list_healthy_services().await;
-
-        PlatformStatus {
-            api_endpoint: format!("{}:{}", self.config.api_host, self.config.api_port),
-            grpc_endpoint: format!("{}:{}", self.config.grpc_host, self.config.grpc_port),
-            registered_services: services.len(),
-            privacy_enabled: true,
-            policy_enforcement_enabled: self.config.enable_policy_enforcement,
-            audit_enabled: true,
-        }
-    }
-
-    /// Shutdown platform gracefully
-    pub async fn shutdown(&self) -> Result<(), PlatformError> {
-        tracing::info!("🛑 Shutting down platform...");
-
-        // Verify audit chain before shutdown
-        self.gateway_state
-            .audit_logger
-            .verify_chain()
-            .await
-            .map_err(|e| PlatformError::RuntimeError(e.to_string()))?;
-
-        // Export audit chain
-        let audit_export = self
-            .gateway_state
-            .audit_logger
-            .export_chain()
-            .await
-            .map_err(|e| PlatformError::RuntimeError(e.to_string()))?;
-
-        tracing::info!("📝 Audit chain exported ({} bytes)", audit_export.len());
-        tracing::info!("✅ Platform shutdown complete");
-
-        Ok(())
-    }
-}
-
-#[derive(Debug, serde::Serialize)]
-pub struct PlatformStatus {
-    pub api_endpoint: String,
-    pub grpc_endpoint: String,
-    pub registered_services: usize,
-    pub privacy_enabled: bool,
-    pub policy_enforcement_enabled: bool,
-    pub audit_enabled: bool,
-}
-
-// Re-export commonly used types
-pub use api::gateway::{GatewayState, start_server as start_api_server};
-pub use audit::logger::{AuditLogger, AuditEntry, AuditReport};
-pub use governance::policy::{PolicyEnforcer, Policy, PolicyDecision};
-pub use privacy::differential::{PrivacyEngine, PrivacyConfig, PrivateData};
-pub use services::grpc::{
-    AnalysisService, ServiceRegistry, AnalysisRequest, AnalysisResponse,
-};
-
-/// Prelude module for convenient imports
-pub mod prelude {
-    pub use data_models::expression::*;
-    pub use data_models::metadata::*;
-    pub use data_models::sequencing::*;
-    pub use data_models::targets::*;
-    pub use immune_analyzer::*;
-    pub use offtarget_predictor::*;
-
-    // Rights-preserving platform
-    pub use crate::{
-        Platform, PlatformConfig, PlatformStatus,
-        AuditLogger, PolicyEnforcer, PrivacyEngine,
-    };
-}
-
-// Re-export workspace crates
-pub use data_models;
-pub use immune_analyzer;
-pub use offtarget_predictor;

package/agentic-flow/examples/crispr-cas13-pipeline/src/main.rs

@@ -1,114 +0,0 @@
-//! CRISPR-Cas13 Pipeline Main Entry Point
-
-use anyhow::Result;
-use tracing_subscriber;
-
-#[tokio::main]
-async fn main() -> Result<()> {
-    // Initialize tracing
-    tracing_subscriber::fmt::init();
-
-    println!("🧬 CRISPR-Cas13 Bioinformatics Pipeline");
-    println!("========================================");
-    println!();
-    println!("✅ Pipeline initialized successfully");
-    println!();
-    println!("📊 System Status:");
-    println!("  - Data Models: Loaded");
-    println!("  - Alignment Engine: Ready");
-    println!("  - Off-Target Predictor: Ready");
-    println!("  - Immune Analyzer: Ready");
-    println!("  - API Service: Ready");
-    println!("  - Processing Orchestrator: Ready");
-    println!();
-    println!("🧪 Running demonstration workflow...");
-    println!();
-
-    // Demo: Create a CRISPR target
-    use data_models::sequencing::GenomicCoordinate;
-    use data_models::targets::CrisprTarget;
-
-    let location = GenomicCoordinate::new(0, 1000, 1023, true)?;
-    let target = CrisprTarget::new(
-        "GUUUUAGAGCUAUGCUGUUUUG".to_string(),
-        "GUUUUAGAGCUAUGCUGUUUUG".to_string(),
-        location,
-    )?;
-
-    println!("  ✓ Created CRISPR target: {}", target.id);
-    println!("    - Guide RNA: {}", target.guide_rna);
-    println!("    - Length: {} nt", target.guide_rna.len());
-    println!();
-
-    // Demo: Run off-target prediction
-    use offtarget_predictor::{DefaultPredictor, OffTargetPredictor, PredictionConfig};
-
-    let config = PredictionConfig::default();
-    let predictor = DefaultPredictor::new(config)?;
-
-    println!("  ✓ Running off-target prediction...");
-    let prediction = predictor.predict(&target).await?;
-
-    println!(
-        "    - Found {} potential off-target sites",
-        prediction.off_targets.len()
-    );
-    println!(
-        "    - Processing time: {:.2}s",
-        prediction.metadata.processing_time
-    );
-
-    for (i, site) in prediction.off_targets.iter().take(3).enumerate() {
-        println!(
-            "    - Site #{}: score={:.3}, mismatches={}",
-            i + 1,
-            site.score,
-            site.mismatches
-        );
-    }
-    println!();
-
-    // Demo: Run immune analysis
-    use data_models::expression::ExpressionSample;
-    use immune_analyzer::{AnalysisParameters, DeseqAnalyzer};
-
-    println!("  ✓ Running immune response analysis...");
-
-    let params = AnalysisParameters::default();
-    let analyzer = DeseqAnalyzer::new(params);
-
-    // Create mock samples
-    let mut control1 = ExpressionSample::new("Control_1".to_string(), "control".to_string(), 1);
-    control1.add_count("IRF3".to_string(), 100);
-    control1.add_count("STAT1".to_string(), 150);
-
-    let mut treatment1 = ExpressionSample::new("Treatment_1".to_string(), "treated".to_string(), 1);
-    treatment1.add_count("IRF3".to_string(), 300);
-    treatment1.add_count("STAT1".to_string(), 450);
-
-    let analysis = analyzer.analyze(vec![control1], vec![treatment1])?;
-
-    println!("    - Analyzed {} genes", analysis.results.len());
-    println!("    - Control: {}", analysis.control_condition);
-    println!("    - Treatment: {}", analysis.treatment_condition);
-
-    for result in &analysis.results {
-        println!(
-            "    - {}: log2FC={:.2}, p={:.2e}",
-            result.gene_id, result.log2_fold_change, result.pvalue
-        );
-    }
-    println!();
-
-    println!("✅ All systems operational!");
-    println!();
-    println!("📚 Documentation:");
-    println!("  - See docs/ for comprehensive documentation");
-    println!("  - API spec: docs/api-spec.openapi.yaml");
-    println!("  - Architecture: docs/ARCHITECTURE.md");
-    println!("  - Benchmarks: docs/BENCHMARKS.md");
-    println!();
-    println!("🚀 Ready for production deployment!");
-
-    Ok(())
-}