fetchium_core/intelligence/pie/
stm.rs1use rusqlite::Connection;
10use std::sync::Mutex;
11
12use crate::error::FetchiumError;
13use crate::intelligence::enable_wal;
14
15pub struct SourceTrustMemory {
16 conn: Mutex<Connection>,
17}
18
19impl SourceTrustMemory {
20 pub fn new(db_path: &std::path::Path) -> Result<Self, FetchiumError> {
22 let conn = Connection::open(db_path)?;
23 enable_wal(&conn)?;
24 conn.execute_batch(
25 "CREATE TABLE IF NOT EXISTS domain_trust (
26 domain TEXT PRIMARY KEY,
27 trust_score REAL NOT NULL DEFAULT 0.5,
28 alpha REAL NOT NULL DEFAULT 1.0,
29 beta REAL NOT NULL DEFAULT 1.0,
30 fetch_count INTEGER NOT NULL DEFAULT 0,
31 success_count INTEGER NOT NULL DEFAULT 0,
32 avg_relevance REAL NOT NULL DEFAULT 0.0,
33 last_updated TEXT NOT NULL DEFAULT (datetime('now'))
34 );",
35 )?;
36 Ok(Self {
37 conn: Mutex::new(conn),
38 })
39 }
40
41 pub fn update_trust(
46 &self,
47 domain: &str,
48 success: bool,
49 relevance: f64,
50 ) -> Result<f64, FetchiumError> {
51 let conn = self.conn.lock().unwrap();
52
53 conn.execute(
55 "INSERT OR IGNORE INTO domain_trust (domain) VALUES (?1)",
56 [domain],
57 )?;
58
59 if success {
60 conn.execute(
61 "UPDATE domain_trust SET
62 alpha = alpha + 1.0,
63 fetch_count = fetch_count + 1,
64 success_count = success_count + 1,
65 avg_relevance = (avg_relevance * fetch_count + ?2) / (fetch_count + 1.0),
66 trust_score = (alpha + 1.0) / (alpha + 1.0 + beta),
67 last_updated = datetime('now')
68 WHERE domain = ?1",
69 rusqlite::params![domain, relevance],
70 )?;
71 } else {
72 conn.execute(
73 "UPDATE domain_trust SET
74 beta = beta + 1.0,
75 fetch_count = fetch_count + 1,
76 trust_score = alpha / (alpha + beta + 1.0),
77 last_updated = datetime('now')
78 WHERE domain = ?1",
79 [domain],
80 )?;
81 }
82
83 let score: f64 = conn.query_row(
84 "SELECT trust_score FROM domain_trust WHERE domain = ?1",
85 [domain],
86 |row| row.get(0),
87 )?;
88 Ok(score)
89 }
90
91 pub fn get_trust(&self, domain: &str) -> Result<f64, FetchiumError> {
93 let conn = self.conn.lock().unwrap();
94 let score = conn
95 .query_row(
96 "SELECT trust_score FROM domain_trust WHERE domain = ?1",
97 [domain],
98 |row| row.get::<_, f64>(0),
99 )
100 .unwrap_or(0.5);
101 Ok(score)
102 }
103
104 pub fn top_trusted(&self, limit: usize) -> Result<Vec<(String, f64)>, FetchiumError> {
106 let conn = self.conn.lock().unwrap();
107 let mut stmt = conn.prepare(
108 "SELECT domain, trust_score FROM domain_trust
109 WHERE fetch_count >= 5
110 ORDER BY trust_score DESC
111 LIMIT ?1",
112 )?;
113 let results = stmt
114 .query_map([limit as i64], |row| {
115 Ok((row.get::<_, String>(0)?, row.get::<_, f64>(1)?))
116 })?
117 .filter_map(|r| r.ok())
118 .collect();
119 Ok(results)
120 }
121
122 pub fn domain_count(&self) -> Result<u64, FetchiumError> {
124 let conn = self.conn.lock().unwrap();
125 let n: i64 = conn.query_row("SELECT COUNT(*) FROM domain_trust", [], |row| row.get(0))?;
126 Ok(n as u64)
127 }
128
129 pub fn reset(&self) -> Result<(), FetchiumError> {
131 let conn = self.conn.lock().unwrap();
132 conn.execute_batch("DELETE FROM domain_trust; VACUUM;")?;
133 Ok(())
134 }
135}
136
137#[cfg(test)]
138mod tests {
139 use super::*;
140 use tempfile::NamedTempFile;
141
142 #[test]
143 fn bayesian_update_success_increases_trust() {
144 let tmp = NamedTempFile::new().unwrap();
145 let stm = SourceTrustMemory::new(tmp.path()).unwrap();
146 for _ in 0..10 {
147 stm.update_trust("example.com", true, 0.9).unwrap();
148 }
149 let trust = stm.get_trust("example.com").unwrap();
150 assert!(trust > 0.7, "trust={trust:.3}");
151 }
152
153 #[test]
154 fn bayesian_update_failure_decreases_trust() {
155 let tmp = NamedTempFile::new().unwrap();
156 let stm = SourceTrustMemory::new(tmp.path()).unwrap();
157 for _ in 0..10 {
158 stm.update_trust("bad.com", false, 0.0).unwrap();
159 }
160 let trust = stm.get_trust("bad.com").unwrap();
161 assert!(trust < 0.3, "trust={trust:.3}");
162 }
163
164 #[test]
165 fn unknown_domain_returns_prior() {
166 let tmp = NamedTempFile::new().unwrap();
167 let stm = SourceTrustMemory::new(tmp.path()).unwrap();
168 let trust = stm.get_trust("unknown.io").unwrap();
169 assert!((trust - 0.5).abs() < 1e-9);
170 }
171}