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: unix socket adapter for Tardygrada wire protocol
FABIOTESSf4ecdf0ca295
diff --git a/src/lib.rs b/src/lib.rsindex d6e1ec35..938e8ff0 100644--- a/src/lib.rs+++ b/src/lib.rs@@ -20,6 +20,7 @@ pub mod server;pub mod shacl;pub mod state;pub mod schema;+pub mod socket;pub mod tableaux;#[cfg(feature = "embeddings")]pub mod poincare;diff --git a/src/main.rs b/src/main.rsindex 66138981..997fafa8 100644--- a/src/main.rs+++ b/src/main.rs@@ -59,6 +59,16 @@ enum Commands {governance_webhook: Option<String>,},+ /// Start unix socket server for Tardygrada fact grounding+ ServeUnix {+ /// Path to the unix socket+ #[arg(long, default_value = "/tmp/tardygrada-ontology-complete.sock")]+ socket: String,+ /// Ontology files to load on startup+ #[arg(long = "file", num_args = 1..)]+ files: Vec<String>,+ },+// ─── Core ontology ────────────────────────────────────────────/// Validate RDF/OWL syntax (file or stdin with -)Validate { input: String },@@ -598,6 +608,22 @@ async fn main() -> anyhow::Result<()> {.await?;}+ Commands::ServeUnix { socket, files } => {+ let graph = Arc::new(GraphStore::new());+ for f in &files {+ let path = open_ontologies::config::expand_tilde(f);+ match graph.load_file(&path) {+ Ok(n) => eprintln!("Loaded {path}: {n} triples"),+ Err(e) => {+ eprintln!("Failed to load {path}: {e}");+ std::process::exit(1);+ }+ }+ }+ eprintln!("Graph has {} triples total", graph.triple_count());+ open_ontologies::socket::serve(&socket, graph).await?;+ }+// ─── Core ontology ─────────────────────────────────────────Commands::Validate { input } => {let result = if input == "-" {diff --git a/src/socket.rs b/src/socket.rsnew file mode 100644index 00000000..be87c4ae--- /dev/null+++ b/src/socket.rs@@ -0,0 +1,317 @@+//! Unix domain socket adapter for the Tardygrada language.+//!+//! Speaks newline-delimited JSON over `SOCK_STREAM`.+//! Supported actions:+//! - `ground` — check if triples exist in the graph store+//! - `check_consistency` — add triples temporarily and look for contradictions++use std::sync::Arc;++use serde::{Deserialize, Serialize};+use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};+use tokio::net::UnixListener;+use tracing::{error, info, warn};++use crate::graph::GraphStore;+use crate::reason::Reasoner;++// ── Wire types ───────────────────────────────────────────────────────++#[derive(Debug, Deserialize)]+struct Request {+ action: String,+ triples: Vec<Triple>,+}++#[derive(Debug, Deserialize)]+struct Triple {+ s: String,+ p: String,+ o: String,+}++#[derive(Debug, Serialize)]+struct GroundResult {+ status: &'static str,+ confidence: u32,+ evidence_count: u64,+}++#[derive(Debug, Serialize)]+struct GroundResponse {+ results: Vec<GroundResult>,+}++#[derive(Debug, Serialize)]+struct ConsistencyResponse {+ consistent: bool,+ contradiction_count: u64,+ explanation: String,+}++// ── Public entry point ───────────────────────────────────────────────++/// Start listening on the given unix socket path.+///+/// Each accepted connection is handled in a spawned task. The listener+/// runs until the process is killed or the socket is removed.+pub async fn serve(socket_path: &str, graph: Arc<GraphStore>) -> anyhow::Result<()> {+ // Clean up stale socket file if it exists.+ let _ = std::fs::remove_file(socket_path);++ let listener = UnixListener::bind(socket_path)?;+ info!("Unix socket listening on {socket_path}");++ loop {+ match listener.accept().await {+ Ok((stream, _addr)) => {+ let g = graph.clone();+ tokio::spawn(async move {+ if let Err(e) = handle_connection(stream, &g).await {+ warn!("Connection error: {e}");+ }+ });+ }+ Err(e) => {+ error!("Accept error: {e}");+ }+ }+ }+}++// ── Per-connection handler ───────────────────────────────────────────++async fn handle_connection(+ stream: tokio::net::UnixStream,+ graph: &Arc<GraphStore>,+) -> anyhow::Result<()> {+ let (reader, mut writer) = stream.into_split();+ let mut lines = BufReader::new(reader).lines();++ while let Some(line) = lines.next_line().await? {+ let line = line.trim().to_string();+ if line.is_empty() {+ continue;+ }++ let response = match serde_json::from_str::<Request>(&line) {+ Ok(req) => dispatch(graph, &req),+ Err(e) => serde_json::json!({"error": format!("bad request: {e}")}),+ };++ let mut out = serde_json::to_string(&response)?;+ out.push('\n');+ writer.write_all(out.as_bytes()).await?;+ }++ Ok(())+}++// ── Dispatch ─────────────────────────────────────────────────────────++fn dispatch(graph: &Arc<GraphStore>, req: &Request) -> serde_json::Value {+ match req.action.as_str() {+ "ground" => handle_ground(graph, &req.triples),+ "check_consistency" => handle_check_consistency(graph, &req.triples),+ other => serde_json::json!({"error": format!("unknown action: {other}")}),+ }+}++// ── Ground ───────────────────────────────────────────────────────────++fn handle_ground(graph: &Arc<GraphStore>, triples: &[Triple]) -> serde_json::Value {+ let mut results = Vec::new();++ for t in triples {+ let obj_is_iri = t.o.starts_with("http://")+ || t.o.starts_with("https://")+ || t.o.starts_with("urn:");++ // Count evidence: try IRI form (if valid) and literal form+ let count_query = if obj_is_iri {+ format!(+ "SELECT (COUNT(*) AS ?c) WHERE {{ \+ {{ <{s}> <{p}> <{o}> }} \+ UNION \+ {{ <{s}> <{p}> \"{o}\" }} \+ }}",+ s = t.s, p = t.p, o = t.o,+ )+ } else {+ format!(+ "SELECT (COUNT(*) AS ?c) WHERE {{ <{s}> <{p}> \"{o}\" }}",+ s = t.s, p = t.p, o = t.o,+ )+ };++ let evidence_count = run_count_query(graph, &count_query);++ // Check for contradictions: different value for the same s+p+ let contra_query = if obj_is_iri {+ format!(+ "SELECT (COUNT(*) AS ?c) WHERE {{ \+ <{s}> <{p}> ?val . \+ FILTER(?val != <{o}> && ?val != \"{o}\") \+ }}",+ s = t.s, p = t.p, o = t.o,+ )+ } else {+ format!(+ "SELECT (COUNT(*) AS ?c) WHERE {{ \+ <{s}> <{p}> ?val . \+ FILTER(?val != \"{o}\") \+ }}",+ s = t.s, p = t.p, o = t.o,+ )+ };++ let contra_count = run_count_query(graph, &contra_query);++ let (status, confidence) = if evidence_count > 0 && contra_count == 0 {+ ("grounded", std::cmp::min(50 + (evidence_count as u32) * 15, 100))+ } else if evidence_count > 0 && contra_count > 0 {+ // Evidence exists but so do contradictions — partial+ ("grounded", std::cmp::min(30 + (evidence_count as u32) * 10, 70))+ } else if contra_count > 0 {+ ("contradicted", 0)+ } else {+ ("unknown", 0)+ };++ results.push(GroundResult {+ status,+ confidence,+ evidence_count,+ });+ }++ serde_json::to_value(GroundResponse { results }).unwrap_or_default()+}++// ── Consistency check ────────────────────────────────────────────────++fn handle_check_consistency(+ graph: &Arc<GraphStore>,+ triples: &[Triple],+) -> serde_json::Value {+ // Build INSERT DATA body+ let mut insert_body = String::new();+ for t in triples {+ insert_body.push_str(&format!("<{}> <{}> ", t.s, t.p));+ // Heuristic: if object looks like a URI, use <>, otherwise literal+ if t.o.starts_with("http://") || t.o.starts_with("https://") || t.o.starts_with("urn:") {+ insert_body.push_str(&format!("<{}> .\n", t.o));+ } else {+ insert_body.push_str(&format!("\"{}\" .\n", t.o));+ }+ }++ let insert_sparql = format!("INSERT DATA {{ {} }}", insert_body);++ // Insert the triples temporarily+ if let Err(e) = graph.sparql_update(&insert_sparql) {+ return serde_json::json!({+ "consistent": false,+ "contradiction_count": 0,+ "explanation": format!("failed to insert triples: {e}")+ });+ }++ // Run OWL-RL reasoning (non-materialising probe)+ let reason_result = Reasoner::run(graph, "owl-rl", false);++ // Count contradictions: owl:sameAs loops, disjointWith violations, etc.+ let contra_query = "SELECT (COUNT(*) AS ?c) WHERE { \+ ?a <http://www.w3.org/2002/07/owl#differentFrom> ?b . \+ ?a <http://www.w3.org/2002/07/owl#sameAs> ?b . \+ }";+ let contradictions = run_count_query(graph, contra_query);++ // Also check for disjointWith violations+ let disjoint_query = "SELECT (COUNT(*) AS ?c) WHERE { \+ ?cls1 <http://www.w3.org/2002/07/owl#disjointWith> ?cls2 . \+ ?x a ?cls1 . \+ ?x a ?cls2 . \+ }";+ let disjoint_violations = run_count_query(graph, disjoint_query);++ let total_contradictions = contradictions + disjoint_violations;++ let explanation = if total_contradictions > 0 {+ let mut parts = Vec::new();+ if contradictions > 0 {+ parts.push(format!("{contradictions} sameAs/differentFrom conflict(s)"));+ }+ if disjoint_violations > 0 {+ parts.push(format!("{disjoint_violations} disjointWith violation(s)"));+ }+ parts.join("; ")+ } else {+ match reason_result {+ Ok(_) => String::new(),+ Err(e) => format!("reasoning error: {e}"),+ }+ };++ // Remove the temporarily inserted triples+ let delete_sparql = format!("DELETE DATA {{ {} }}", insert_body);+ if let Err(e) = graph.sparql_update(&delete_sparql) {+ warn!("Failed to clean up temporary triples: {e}");+ }++ serde_json::to_value(ConsistencyResponse {+ consistent: total_contradictions == 0,+ contradiction_count: total_contradictions,+ explanation,+ })+ .unwrap_or_default()+}++// ── Helpers ──────────────────────────────────────────────────────────++/// Run a SPARQL SELECT that returns a single `?c` count value.+fn run_count_query(graph: &Arc<GraphStore>, query: &str) -> u64 {+ match graph.sparql_select(query) {+ Ok(json_str) => {+ // sparql_select returns {"variables":["c"],"results":[{"c":"\"3\"^^…"}]}+ if let Ok(v) = serde_json::from_str::<serde_json::Value>(&json_str) {+ if let Some(row) = v["results"].as_array().and_then(|a| a.first()) {+ if let Some(val) = row["c"].as_str() {+ // Oxigraph wraps the value like "\"3\"^^<…integer>"+ return parse_sparql_integer(val);+ }+ }+ }+ 0+ }+ Err(e) => {+ warn!("Count query failed: {e}");+ 0+ }+ }+}++/// Parse a SPARQL integer result. Oxigraph returns values like+/// `"3"^^<http://www.w3.org/2001/XMLSchema#integer>`.+fn parse_sparql_integer(raw: &str) -> u64 {+ // Strip surrounding quotes and datatype suffix+ let s = raw+ .trim_start_matches('"')+ .split('"')+ .next()+ .unwrap_or("0");+ s.parse::<u64>().unwrap_or(0)+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn parse_sparql_integer_variants() {+ assert_eq!(parse_sparql_integer("\"3\"^^<http://www.w3.org/2001/XMLSchema#integer>"), 3);+ assert_eq!(parse_sparql_integer("\"0\"^^<http://www.w3.org/2001/XMLSchema#integer>"), 0);+ assert_eq!(parse_sparql_integer("\"42\""), 42);+ assert_eq!(parse_sparql_integer("bad"), 0);+ }+}diff --git a/tests/socket_test.rs b/tests/socket_test.rsnew file mode 100644index 00000000..646e47e1--- /dev/null+++ b/tests/socket_test.rs@@ -0,0 +1,160 @@+use std::sync::Arc;+use std::sync::atomic::{AtomicU32, Ordering};++use open_ontologies::graph::GraphStore;+use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};+use tokio::net::UnixStream;++const TEST_ONTOLOGY: &str = r#"+@prefix : <http://example.org/> .+@prefix schema: <http://schema.org/> .++:DoctorWho a schema:TVSeries ;+ schema:locationCreated :BBCTelevisionCentre ;+ schema:dateCreated "1963" ;+ schema:creator :SydneyNewman .++:BBCTelevisionCentre a schema:Place ;+ schema:address "London" .+"#;++static COUNTER: AtomicU32 = AtomicU32::new(0);++/// Helper: start the socket server in the background and return the path.+async fn start_server(graph: Arc<GraphStore>) -> String {+ let id = COUNTER.fetch_add(1, Ordering::SeqCst);+ let sock_path = format!(+ "/tmp/oo-test-{}-{}.sock",+ std::process::id(),+ id+ );+ let _ = std::fs::remove_file(&sock_path);+ let path_clone = sock_path.clone();+ tokio::spawn(async move {+ open_ontologies::socket::serve(&path_clone, graph)+ .await+ .ok();+ });+ // Wait until the socket file actually exists+ for _ in 0..50 {+ if std::path::Path::new(&sock_path).exists() {+ break;+ }+ tokio::time::sleep(std::time::Duration::from_millis(20)).await;+ }+ sock_path+}++/// Send a single request and read back the newline-delimited response.+async fn roundtrip(sock_path: &str, request: &str) -> serde_json::Value {+ let stream = UnixStream::connect(sock_path).await.unwrap();+ let (reader, mut writer) = stream.into_split();+ let mut line = format!("{}\n", request);+ writer.write_all(line.as_bytes()).await.unwrap();+ writer.shutdown().await.unwrap();++ let mut buf_reader = BufReader::new(reader);+ line.clear();+ buf_reader.read_line(&mut line).await.unwrap();+ serde_json::from_str(line.trim()).unwrap()+}++#[tokio::test]+async fn ground_existing_iri_triple() {+ let graph = Arc::new(GraphStore::new());+ graph.load_turtle(TEST_ONTOLOGY, None).unwrap();+ let sock = start_server(graph).await;++ let resp = roundtrip(+ &sock,+ r#"{"action":"ground","triples":[{"s":"http://example.org/DoctorWho","p":"http://schema.org/locationCreated","o":"http://example.org/BBCTelevisionCentre"}]}"#,+ )+ .await;++ let status = resp["results"][0]["status"].as_str().unwrap();+ assert_eq!(status, "grounded");+ assert!(resp["results"][0]["confidence"].as_u64().unwrap() > 0);++ std::fs::remove_file(&sock).ok();+}++#[tokio::test]+async fn ground_existing_literal_triple() {+ let graph = Arc::new(GraphStore::new());+ graph.load_turtle(TEST_ONTOLOGY, None).unwrap();+ let sock = start_server(graph).await;++ let resp = roundtrip(+ &sock,+ r#"{"action":"ground","triples":[{"s":"http://example.org/DoctorWho","p":"http://schema.org/dateCreated","o":"1963"}]}"#,+ )+ .await;++ let status = resp["results"][0]["status"].as_str().unwrap();+ assert_eq!(status, "grounded");++ std::fs::remove_file(&sock).ok();+}++#[tokio::test]+async fn ground_unknown_triple() {+ let graph = Arc::new(GraphStore::new());+ graph.load_turtle(TEST_ONTOLOGY, None).unwrap();+ let sock = start_server(graph).await;++ let resp = roundtrip(+ &sock,+ r#"{"action":"ground","triples":[{"s":"http://example.org/Unknown","p":"http://schema.org/name","o":"Foo"}]}"#,+ )+ .await;++ let status = resp["results"][0]["status"].as_str().unwrap();+ assert_eq!(status, "unknown");++ std::fs::remove_file(&sock).ok();+}++#[tokio::test]+async fn check_consistency_clean() {+ let graph = Arc::new(GraphStore::new());+ graph.load_turtle(TEST_ONTOLOGY, None).unwrap();+ let sock = start_server(graph).await;++ let resp = roundtrip(+ &sock,+ r#"{"action":"check_consistency","triples":[{"s":"http://example.org/DoctorWho","p":"http://schema.org/dateCreated","o":"1963"}]}"#,+ )+ .await;++ assert_eq!(resp["consistent"].as_bool().unwrap(), true);+ assert_eq!(resp["contradiction_count"].as_u64().unwrap(), 0);++ std::fs::remove_file(&sock).ok();+}++#[tokio::test]+async fn unknown_action_returns_error() {+ let graph = Arc::new(GraphStore::new());+ let sock = start_server(graph).await;++ let resp = roundtrip(+ &sock,+ r#"{"action":"bogus","triples":[]}"#,+ )+ .await;++ assert!(resp["error"].as_str().unwrap().contains("unknown action"));++ std::fs::remove_file(&sock).ok();+}++#[tokio::test]+async fn bad_json_returns_error() {+ let graph = Arc::new(GraphStore::new());+ let sock = start_server(graph).await;++ let resp = roundtrip(&sock, "not json at all").await;+ assert!(resp["error"].as_str().unwrap().contains("bad request"));++ std::fs::remove_file(&sock).ok();+}diff --git a/tests/test_ontology.ttl b/tests/test_ontology.ttlnew file mode 100644index 00000000..74c5072e--- /dev/null+++ b/tests/test_ontology.ttl@@ -0,0 +1,10 @@+@prefix : <http://example.org/> .+@prefix schema: <http://schema.org/> .++:DoctorWho a schema:TVSeries ;+ schema:locationCreated :BBCTelevisionCentre ;+ schema:dateCreated "1963" ;+ schema:creator :SydneyNewman .++:BBCTelevisionCentre a schema:Place ;+ schema:address "London" .