Skip to main content

fetchium_core/intelligence/pie/
stm.rs

1//! Source Trust Memory (STM) — Bayesian Beta-distribution trust tracking per domain.
2//!
3//! Schema: `domain_trust(domain, trust_score, alpha, beta, fetch_count, success_count,
4//!          avg_relevance, last_updated)`
5//!
6//! Trust score = E[Beta(alpha, beta)] = alpha / (alpha + beta).
7//! Prior: Beta(1, 1) — uninformed, 0.5 trust for unknown domains.
8
9use 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    /// Open or create the STM database at `db_path`.
21    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    /// Bayesian trust update.
42    ///
43    /// - Success: Beta(α+1, β) → trust_score = (α+1)/(α+β+1)
44    /// - Failure: Beta(α, β+1) → trust_score = α/(α+β+1)
45    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        // Insert-or-ignore to seed the row.
54        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    /// Get trust score for a domain. Returns `0.5` (uninformed prior) if unknown.
92    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    /// Top `limit` trusted domains (requiring at least 5 fetches).
105    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    /// Count of tracked domains.
123    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    /// Reset all trust data (VACUUM for privacy).
130    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}