aimds-core 0.2.0

Core types and abstractions for AI Manipulation Defense System (AIMDS)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! Configuration management for AIMDS

use serde::{Deserialize, Serialize};
use std::time::Duration;

/// Main AIMDS configuration
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct AimdsConfig {
    #[serde(default)]
    pub detection: DetectionConfig,
    #[serde(default)]
    pub analysis: AnalysisConfig,
    #[serde(default)]
    pub response: ResponseConfig,
    #[serde(default)]
    pub system: SystemConfig,
}

/// Detection layer configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DetectionConfig {
    pub pattern_matching_enabled: bool,
    pub sanitization_enabled: bool,
    pub confidence_threshold: f64,
    pub max_pattern_complexity: usize,
    pub cache_size: usize,
}

impl Default for DetectionConfig {
    fn default() -> Self {
        Self {
            pattern_matching_enabled: true,
            sanitization_enabled: true,
            confidence_threshold: 0.75,
            max_pattern_complexity: 1000,
            cache_size: 10000,
        }
    }
}

/// Analysis layer configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AnalysisConfig {
    pub behavioral_analysis_enabled: bool,
    pub policy_verification_enabled: bool,
    pub ltl_checking_enabled: bool,
    pub threat_score_threshold: f64,
    pub max_temporal_window: Duration,
}

impl Default for AnalysisConfig {
    fn default() -> Self {
        Self {
            behavioral_analysis_enabled: true,
            policy_verification_enabled: true,
            ltl_checking_enabled: true,
            threat_score_threshold: 0.8,
            max_temporal_window: Duration::from_secs(3600),
        }
    }
}

/// Response layer configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResponseConfig {
    pub meta_learning_enabled: bool,
    pub adaptive_responses_enabled: bool,
    pub auto_mitigation_enabled: bool,
    pub learning_rate: f64,
    pub response_timeout: Duration,
}

impl Default for ResponseConfig {
    fn default() -> Self {
        Self {
            meta_learning_enabled: true,
            adaptive_responses_enabled: true,
            auto_mitigation_enabled: true,
            learning_rate: 0.01,
            response_timeout: Duration::from_secs(5),
        }
    }
}

/// System-wide configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SystemConfig {
    pub max_concurrent_requests: usize,
    pub request_timeout: Duration,
    pub enable_metrics: bool,
    pub enable_tracing: bool,
    pub log_level: String,
}

impl Default for SystemConfig {
    fn default() -> Self {
        Self {
            max_concurrent_requests: 1000,
            request_timeout: Duration::from_secs(30),
            enable_metrics: true,
            enable_tracing: true,
            log_level: "info".to_string(),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_default_config() {
        let config = AimdsConfig::default();
        assert!(config.detection.pattern_matching_enabled);
        assert!(config.analysis.behavioral_analysis_enabled);
        assert!(config.response.meta_learning_enabled);
    }

    #[test]
    fn test_config_serialization() {
        let config = AimdsConfig::default();
        let json = serde_json::to_string(&config).unwrap();
        let deserialized: AimdsConfig = serde_json::from_str(&json).unwrap();

        assert_eq!(
            config.detection.confidence_threshold,
            deserialized.detection.confidence_threshold
        );
    }
}