Skip to content

Plan, apply and roll back changes to a production ontology, with a blast radius report and a proof an auditor can re-check.

feat: unix socket adapter for Tardygrada wire protocol

FABIOTESSf4ecdf0ca295
diff --git a/src/lib.rs b/src/lib.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.ttl
new file mode 100644
index 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" .