reputation-core 0.1.0

Core calculation engine for the KnowThat Reputation System with advanced scoring algorithms
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

//! Example demonstrating the enhanced builder pattern for Calculator construction

use reputation_core::{Calculator, CalculatorPreset, BonusConfig};
use reputation_types::AgentDataBuilder;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Calculator Builder Pattern Examples ===\n");
    
    // Example 1: Using defaults
    println!("1. Default Calculator:");
    let default_calc = Calculator::builder().build()?;
    println!("   Confidence K: {}", default_calc.confidence_k());
    println!("   Prior Base: {}", default_calc.prior_base());
    println!("   Prior Max: {}\n", default_calc.prior_max());
    
    // Example 2: Custom configuration
    println!("2. Custom Calculator:");
    let custom_calc = Calculator::builder()
        .confidence_k(20.0)  // Slower confidence growth
        .prior_base(60.0)    // Higher starting score
        .prior_max(90.0)     // Higher ceiling
        .build()?;
    println!("   Confidence K: {}", custom_calc.confidence_k());
    println!("   Prior Base: {}", custom_calc.prior_base());
    println!("   Prior Max: {}\n", custom_calc.prior_max());
    
    // Example 3: Using presets
    println!("3. Preset Calculators:");
    
    let testing_calc = Calculator::builder()
        .preset(CalculatorPreset::Testing)
        .build()?;
    println!("   Testing Preset - Confidence K: {} (fast growth)", 
             testing_calc.confidence_k());
    
    let conservative_calc = Calculator::builder()
        .preset(CalculatorPreset::Conservative)
        .build()?;
    println!("   Conservative Preset - Confidence K: {} (slow growth)", 
             conservative_calc.confidence_k());
    
    let aggressive_calc = Calculator::builder()
        .preset(CalculatorPreset::Aggressive)
        .build()?;
    println!("   Aggressive Preset - Confidence K: {} (medium growth)\n", 
             aggressive_calc.confidence_k());
    
    // Example 4: Preset with overrides
    println!("4. Preset with Override:");
    let mixed_calc = Calculator::builder()
        .preset(CalculatorPreset::Conservative)
        .prior_max(95.0)  // Override the preset's prior_max
        .build()?;
    println!("   Confidence K: {} (from preset)", mixed_calc.confidence_k());
    println!("   Prior Base: {} (from preset)", mixed_calc.prior_base());
    println!("   Prior Max: {} (overridden)\n", mixed_calc.prior_max());
    
    // Example 5: With custom bonus configuration
    println!("5. Custom Bonus Configuration:");
    let bonuses = BonusConfig {
        mcp_bonus_per_level: 7.0,
        identity_bonus: 10.0,
        security_audit_bonus: 12.0,
        open_source_bonus: 5.0,
        age_bonus: 8.0,
    };
    
    let _bonus_calc = Calculator::builder()
        .prior_bonuses(bonuses)
        .build()?;
    println!("   Calculator configured with custom bonuses");
    println!("   (Note: Current implementation uses default bonuses)\n");
    
    // Example 6: Demonstrating calculations with different configurations
    println!("6. Comparing Calculations:");
    
    // Create a test agent
    let agent = AgentDataBuilder::new("did:example:test")
        .with_reviews(50, 4.2)
        .total_interactions(100)
        .mcp_level(2)
        .identity_verified(true)
        .build()?;
    
    // Calculate with different configurations
    let default_score = default_calc.calculate(&agent)?;
    let conservative_score = conservative_calc.calculate(&agent)?;
    let aggressive_score = aggressive_calc.calculate(&agent)?;
    
    println!("   Same agent scored with different calculators:");
    println!("   - Default:      {:.2} (confidence: {:.3})", 
             default_score.score, default_score.confidence);
    println!("   - Conservative: {:.2} (confidence: {:.3})", 
             conservative_score.score, conservative_score.confidence);
    println!("   - Aggressive:   {:.2} (confidence: {:.3})", 
             aggressive_score.score, aggressive_score.confidence);
    println!("\n   Note: Conservative has lower confidence due to higher K value");
    
    // Example 7: Builder cloning
    println!("\n7. Builder Cloning:");
    let base_builder = Calculator::builder()
        .confidence_k(25.0)
        .prior_base(55.0);
    
    let calc1 = base_builder.clone()
        .prior_max(85.0)
        .build()?;
    
    let calc2 = base_builder
        .prior_max(90.0)
        .build()?;
    
    println!("   Two calculators from cloned builder:");
    println!("   - Calc1: prior_max = {}", calc1.prior_max());
    println!("   - Calc2: prior_max = {}", calc2.prior_max());
    
    Ok(())
}