Plan, apply and roll back changes to a production ontology, with a blast radius report and a proof an auditor can re-check.
Rust ai-nativedescription-logicsformal-verificationinfrastructure-as-codeisabelle-languageknowledge-graphleanlean4mcpmcp-serverontologyowlowl2reasoningrustshaclsparqltheorem-proving
feat: add lightweight lineage module with compressed event log
FABIOTESSbc560613e26f
diff --git a/src/lib.rs b/src/lib.rsindex 7bddeee4..5e6b72b8 100644--- a/src/lib.rs+++ b/src/lib.rs@@ -1,6 +1,7 @@pub mod config;pub mod graph;pub mod ingest;+pub mod lineage;pub mod mapping;pub mod ontology;pub mod reason;diff --git a/src/lineage.rs b/src/lineage.rsnew file mode 100644index 00000000..4bd4f1e8--- /dev/null+++ b/src/lineage.rs@@ -0,0 +1,71 @@+use crate::state::StateDb;+use chrono::Utc;++/// Append-only lineage log. Compressed format for AI consumption.+pub struct LineageLog {+ db: StateDb,+}++impl LineageLog {+ pub fn new(db: StateDb) -> Self {+ Self { db }+ }++ /// Generate a new session ID (short hex).+ pub fn new_session(&self) -> String {+ format!("{:08x}", rand_id())+ }++ /// Record a lineage event.+ /// Format: session:seq:timestamp:event_type:operation:details+ pub fn record(&self, session_id: &str, event_type: &str, operation: &str, details: &str) {+ let conn = self.db.conn();+ // Get next seq for this session+ let seq: i64 = conn+ .query_row(+ "SELECT COALESCE(MAX(seq), 0) + 1 FROM lineage_events WHERE session_id = ?1",+ rusqlite::params![session_id],+ |r| r.get(0),+ )+ .unwrap_or(1);+ let ts = Utc::now().timestamp();+ let _ = conn.execute(+ "INSERT INTO lineage_events (session_id, seq, timestamp, event_type, operation, details)+ VALUES (?1, ?2, ?3, ?4, ?5, ?6)",+ rusqlite::params![session_id, seq, ts.to_string(), event_type, operation, details],+ );+ }++ /// Get compact lineage for a session.+ /// Returns: "session:seq:timestamp:type:operation:details\n" per event.+ pub fn get_compact(&self, session_id: &str) -> String {+ let conn = self.db.conn();+ let mut stmt = conn+ .prepare(+ "SELECT seq, timestamp, event_type, operation, details+ FROM lineage_events WHERE session_id = ?1 ORDER BY seq ASC",+ )+ .unwrap();+ let rows: Vec<String> = stmt+ .query_map(rusqlite::params![session_id], |row| {+ let seq: i64 = row.get(0)?;+ let ts: String = row.get(1)?;+ let etype: String = row.get(2)?;+ let op: String = row.get(3)?;+ let details: String = row.get::<_, Option<String>>(4)?.unwrap_or_default();+ Ok(format!("{}:{}:{}:{}:{}:{}", session_id, seq, ts, etype, op, details))+ })+ .unwrap()+ .filter_map(|r| r.ok())+ .collect();+ rows.join("\n") + "\n"+ }+}++fn rand_id() -> u32 {+ use std::time::SystemTime;+ let d = SystemTime::now()+ .duration_since(SystemTime::UNIX_EPOCH)+ .unwrap();+ (d.as_nanos() & 0xFFFF_FFFF) as u32+}diff --git a/tests/lineage_test.rs b/tests/lineage_test.rsnew file mode 100644index 00000000..cdba8808--- /dev/null+++ b/tests/lineage_test.rs@@ -0,0 +1,60 @@+use open_ontologies::lineage::LineageLog;+use open_ontologies::state::StateDb;+use tempfile::NamedTempFile;++#[test]+fn test_lineage_record_and_query() {+ let tmp = NamedTempFile::new().unwrap();+ let db = StateDb::open(tmp.path()).unwrap();+ let log = LineageLog::new(db.clone());++ let session = log.new_session();+ log.record(&session, "L", "load", "0→847");+ log.record(&session, "R", "reason", "owl-dl:847→1203");+ log.record(&session, "M", "monitor", "ok");++ let events = log.get_compact(&session);+ let lines: Vec<&str> = events.trim().lines().collect();+ assert_eq!(lines.len(), 3);+ assert!(lines[0].contains(":L:load:0→847"));+ assert!(lines[1].contains(":R:reason:owl-dl:847→1203"));+ assert!(lines[2].contains(":M:monitor:ok"));+}++#[test]+fn test_lineage_session_isolation() {+ let tmp = NamedTempFile::new().unwrap();+ let db = StateDb::open(tmp.path()).unwrap();+ let log = LineageLog::new(db.clone());++ let s1 = log.new_session();+ let s2 = log.new_session();+ log.record(&s1, "L", "load", "100");+ log.record(&s2, "L", "load", "200");++ let e1 = log.get_compact(&s1);+ let e2 = log.get_compact(&s2);+ assert!(e1.contains("100"));+ assert!(!e1.contains("200"));+ assert!(e2.contains("200"));+ assert!(!e2.contains("100"));+}++#[test]+fn test_lineage_sequential_numbering() {+ let tmp = NamedTempFile::new().unwrap();+ let db = StateDb::open(tmp.path()).unwrap();+ let log = LineageLog::new(db.clone());++ let session = log.new_session();+ log.record(&session, "L", "load", "a");+ log.record(&session, "V", "validate", "b");+ log.record(&session, "R", "reason", "c");++ let events = log.get_compact(&session);+ let lines: Vec<&str> = events.trim().lines().collect();+ // seq numbers should be 1, 2, 3+ assert!(lines[0].starts_with(&format!("{}:1:", session)));+ assert!(lines[1].starts_with(&format!("{}:2:", session)));+ assert!(lines[2].starts_with(&format!("{}:3:", session)));+}