use std::collections::{BTreeMap, HashMap};
use std::path::Path;
use serde::{Deserialize, Serialize};
use serde_json::{json, Value};
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum ActionFormat {
Csv,
Json,
Yaml,
Markdown,
Text,
Binary,
Media,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum BaldwinOperator {
Split,
Substitute,
Augment,
Exclude,
Invert,
Port,
Custom,
}
impl std::fmt::Display for BaldwinOperator {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
BaldwinOperator::Split => write!(f, "split"),
BaldwinOperator::Substitute => write!(f, "substitute"),
BaldwinOperator::Augment => write!(f, "augment"),
BaldwinOperator::Exclude => write!(f, "exclude"),
BaldwinOperator::Invert => write!(f, "invert"),
BaldwinOperator::Port => write!(f, "port"),
BaldwinOperator::Custom => write!(f, "custom"),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ActionMetadata {
#[serde(default = "default_action_type")]
pub r#type: String,
pub name: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(default = "default_face")]
pub face: String,
pub operator: BaldwinOperator,
#[serde(default = "default_author")]
pub author: String,
}
fn default_action_type() -> String { "action".to_string() }
fn default_face() -> String { "C".to_string() }
fn default_author() -> String { "did:clm:system".to_string() }
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ActionInput {
pub name: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub uri: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub format: Option<String>,
#[serde(default = "default_true")]
pub required: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
}
fn default_true() -> bool { true }
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ActionPrecondition {
pub invariant: String,
pub rule: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_ref: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ActionOperation {
pub operator: BaldwinOperator,
#[serde(skip_serializing_if = "Option::is_none")]
pub strategy: Option<String>,
#[serde(default)]
pub parameters: HashMap<String, Value>,
#[serde(default = "default_runtime")]
pub runtime: String,
}
fn default_runtime() -> String { "builtin".to_string() }
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ActionPostcondition {
pub invariant: String,
pub rule: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_ref: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ActionOutput {
pub name: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub handle: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub format: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ActionManifest {
#[serde(default = "default_version")]
pub version: String,
pub clm: ActionMetadata,
pub inputs: Vec<ActionInput>,
#[serde(default)]
pub preconditions: Vec<ActionPrecondition>,
pub operation: ActionOperation,
#[serde(default)]
pub postconditions: Vec<ActionPostcondition>,
pub outputs: Vec<ActionOutput>,
}
fn default_version() -> String { "1.0".to_string() }
impl ActionManifest {
pub fn from_yaml_str(yaml_str: &str) -> Result<Self, String> {
let manifest: ActionManifest = serde_yaml::from_str(yaml_str)
.map_err(|e| format!("Failed to parse YAML ActionManifest: {}", e))?;
if manifest.clm.operator != manifest.operation.operator {
return Err(format!(
"Operator mismatch: clm.operator='{}' != operation.operator='{}'",
manifest.clm.operator, manifest.operation.operator
));
}
Ok(manifest)
}
pub fn from_yaml_file<P: AsRef<Path>>(path: P) -> Result<Self, String> {
let content = std::fs::read_to_string(path.as_ref())
.map_err(|e| format!("Cannot read file {}: {}", path.as_ref().display(), e))?;
Self::from_yaml_str(&content)
}
pub fn to_canonical_json_value(&self) -> Value {
serde_json::to_value(self).unwrap_or(Value::Null)
}
}
pub fn sort_json_value(v: &Value) -> Value {
match v {
Value::Object(map) => {
let mut sorted = BTreeMap::new();
for (k, val) in map {
sorted.insert(k.clone(), sort_json_value(val));
}
serde_json::to_value(sorted).unwrap()
}
Value::Array(arr) => {
Value::Array(arr.iter().map(sort_json_value).collect())
}
other => other.clone(),
}
}
pub fn compute_canonical_serialized(val: &Value) -> String {
let sorted = sort_json_value(val);
serde_json::to_string(&sorted).unwrap_or_default()
}
pub fn compute_canonical_hash(val: &Value) -> String {
let s = compute_canonical_serialized(val);
blake3::hash(s.as_bytes()).to_hex().to_string()
}
pub fn clm_hash_string(s: &str) -> String {
blake3::hash(s.as_bytes()).to_hex().to_string()
}
pub struct TabularManipulator;
impl TabularManipulator {
pub fn parse_csv(text: &str) -> (Vec<String>, Vec<Vec<String>>) {
let mut lines = text.lines().filter(|l| !l.trim().is_empty());
let header_line = match lines.next() {
Some(h) => h,
None => return (vec![], vec![]),
};
let headers: Vec<String> = header_line.split(',').map(|s| s.trim().to_string()).collect();
let mut rows = Vec::new();
for line in lines {
let row: Vec<String> = line.split(',').map(|s| s.trim().to_string()).collect();
rows.push(row);
}
(headers, rows)
}
pub fn render_csv(headers: &[String], rows: &[Vec<String>]) -> String {
let mut out = String::new();
if !headers.is_empty() {
out.push_str(&headers.join(","));
out.push('\n');
}
for r in rows {
out.push_str(&r.join(","));
out.push('\n');
}
out
}
pub fn split(data: &str, params: &HashMap<String, Value>) -> Result<HashMap<String, String>, String> {
let (headers, rows) = Self::parse_csv(data);
if rows.is_empty() {
let mut res = HashMap::new();
res.insert("part_1".to_string(), Self::render_csv(&headers, &[]));
res.insert("part_2".to_string(), Self::render_csv(&headers, &[]));
return Ok(res);
}
if let Some(Value::Object(ratios)) = params.get("ratios") {
let total = rows.len();
let mut partitions = HashMap::new();
let mut current_idx = 0;
let ratio_list: Vec<(&String, f64)> = ratios
.iter()
.map(|(k, v)| (k, v.as_f64().unwrap_or(0.0)))
.collect();
for (i, (name, ratio)) in ratio_list.iter().enumerate() {
let part_rows = if i == ratio_list.len() - 1 {
&rows[current_idx..]
} else {
let count = (total as f64 * ratio).round() as usize;
let end = (current_idx + count).min(total);
let slice = &rows[current_idx..end];
current_idx = end;
slice
};
partitions.insert((*name).clone(), Self::render_csv(&headers, part_rows));
}
return Ok(partitions);
}
let mid = rows.len() / 2;
let mut partitions = HashMap::new();
partitions.insert("part_1".to_string(), Self::render_csv(&headers, &rows[..mid]));
partitions.insert("part_2".to_string(), Self::render_csv(&headers, &rows[mid..]));
Ok(partitions)
}
pub fn substitute(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
let (mut headers, rows) = Self::parse_csv(data);
if let (Some(target), Some(replacement)) = (
params.get("target_column").and_then(|v| v.as_str()),
params.get("replacement_column").and_then(|v| v.as_str()),
) {
for h in &mut headers {
if h == target {
*h = replacement.to_string();
}
}
} else if let Some(Value::Object(rename)) = params.get("rename_columns") {
for h in &mut headers {
if let Some(new_name) = rename.get(h).and_then(|v| v.as_str()) {
*h = new_name.to_string();
}
}
}
Ok(Self::render_csv(&headers, &rows))
}
pub fn augment(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
let (mut headers, rows) = Self::parse_csv(data);
let col_name = params.get("column_name")
.or_else(|| params.get("target_column"))
.and_then(|v| v.as_str())
.unwrap_or("augmented_col");
let default_val = params.get("default_value")
.or_else(|| params.get("constant_value"))
.map(|v| match v {
Value::String(s) => s.clone(),
other => other.to_string(),
})
.unwrap_or_else(|| "active".to_string());
headers.push(col_name.to_string());
let mut new_rows = Vec::new();
for r in rows {
let mut nr = r;
nr.push(default_val.clone());
new_rows.push(nr);
}
Ok(Self::render_csv(&headers, &new_rows))
}
pub fn exclude(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
let (headers, rows) = Self::parse_csv(data);
let mut drop_cols = Vec::new();
if let Some(Value::Array(cols)) = params.get("columns").or_else(|| params.get("target_columns")) {
for c in cols {
if let Some(s) = c.as_str() {
drop_cols.push(s.to_string());
}
}
}
let keep_indices: Vec<usize> = headers
.iter()
.enumerate()
.filter(|(_, h)| !drop_cols.contains(h))
.map(|(i, _)| i)
.collect();
let new_headers: Vec<String> = keep_indices.iter().map(|&i| headers[i].clone()).collect();
let mut new_rows = Vec::new();
for r in rows {
let nr: Vec<String> = keep_indices.iter().filter(|&&i| i < r.len()).map(|&i| r[i].clone()).collect();
new_rows.push(nr);
}
Ok(Self::render_csv(&new_headers, &new_rows))
}
pub fn invert(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
let (headers, mut rows) = Self::parse_csv(data);
let strategy = params.get("strategy").and_then(|v| v.as_str()).unwrap_or("reverse_rows");
if strategy == "transpose" && !headers.is_empty() {
let mut matrix = vec![headers];
matrix.extend(rows);
let cols = matrix[0].len();
let mut transposed = Vec::new();
for c in 0..cols {
let mut row = Vec::new();
for r in 0..matrix.len() {
if c < matrix[r].len() {
row.push(matrix[r][c].clone());
}
}
transposed.push(row);
}
let new_headers = transposed.first().cloned().unwrap_or_default();
let new_rows = if transposed.len() > 1 { transposed[1..].to_vec() } else { vec![] };
return Ok(Self::render_csv(&new_headers, &new_rows));
}
rows.reverse();
Ok(Self::render_csv(&headers, &rows))
}
pub fn port(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
let (headers, rows) = Self::parse_csv(data);
let target_format = params.get("target_format").and_then(|v| v.as_str()).unwrap_or("json").to_lowercase();
if target_format == "json" {
let mut records = Vec::new();
for r in rows {
let mut obj = serde_json::Map::new();
for (i, h) in headers.iter().enumerate() {
let val = if i < r.len() { r[i].clone() } else { String::new() };
obj.insert(h.clone(), Value::String(val));
}
records.push(Value::Object(obj));
}
return serde_json::to_string_pretty(&records).map_err(|e| e.to_string());
}
Ok(Self::render_csv(&headers, &rows))
}
}
pub struct DocumentManipulator;
impl DocumentManipulator {
pub fn split(data: &str, params: &HashMap<String, Value>) -> Result<HashMap<String, String>, String> {
let delimiter = params.get("delimiter").and_then(|v| v.as_str()).unwrap_or("# ");
let mut results = HashMap::new();
let parts: Vec<&str> = data.split(delimiter).collect();
if parts.len() <= 1 {
results.insert("document".to_string(), data.to_string());
return Ok(results);
}
let mut idx = 1;
for part in &parts[1..] {
let key = format!("section_{}", idx);
let content = format!("{}{}", delimiter, part.trim());
results.insert(key, content);
idx += 1;
}
if !parts[0].trim().is_empty() {
results.insert("intro".to_string(), parts[0].trim().to_string());
}
Ok(results)
}
pub fn substitute(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
let mut res = data.to_string();
if let (Some(target), Some(replacement)) = (
params.get("target_header").and_then(|v| v.as_str()),
params.get("replacement_header").and_then(|v| v.as_str()),
) {
res = res.replace(target, replacement);
} else if let Some(Value::Object(replacements)) = params.get("replacements") {
for (old, new_val) in replacements {
if let Some(new_str) = new_val.as_str() {
res = res.replace(old, new_str);
}
}
}
Ok(res)
}
pub fn augment(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
let mut res = data.to_string();
if let Some(content) = params.get("content").and_then(|v| v.as_str()) {
if !res.ends_with('\n') {
res.push('\n');
}
res.push_str(content);
if !res.ends_with('\n') {
res.push('\n');
}
}
Ok(res)
}
pub fn exclude(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
let section_title = params.get("section_title").and_then(|v| v.as_str()).unwrap_or("");
let mut lines = Vec::new();
let mut skipping = false;
for line in data.lines() {
if line.starts_with('#') && line.contains(section_title) && !section_title.is_empty() {
skipping = true;
continue;
}
if skipping && line.starts_with('#') {
skipping = false;
}
if !skipping {
lines.push(line);
}
}
let mut res = lines.join("\n");
if data.ends_with('\n') {
res.push('\n');
}
Ok(res)
}
pub fn invert(data: &str, _params: &HashMap<String, Value>) -> Result<String, String> {
let sections: Vec<&str> = data.split("\n#").collect();
if sections.len() <= 1 {
return Ok(data.to_string());
}
let intro = sections[0];
let mut rest: Vec<String> = sections[1..].iter().map(|s| format!("#{}", s)).collect();
rest.reverse();
Ok(format!("{}\n{}", intro.trim(), rest.join("\n")))
}
pub fn port(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
let target_fmt = params.get("target_format").and_then(|v| v.as_str()).unwrap_or("text").to_lowercase();
if target_fmt == "html" {
let mut html = String::new();
for line in data.lines() {
if let Some(h1) = line.strip_prefix("# ") {
html.push_str(&format!("<h1>{}</h1>\n", h1.trim()));
} else if let Some(h2) = line.strip_prefix("## ") {
html.push_str(&format!("<h2>{}</h2>\n", h2.trim()));
} else if !line.trim().is_empty() {
html.push_str(&format!("<p>{}</p>\n", line.trim()));
}
}
return Ok(html);
}
let plain = data.replace('#', "").replace('*', "").replace('`', "");
Ok(plain)
}
}
pub struct StructuredManipulator;
impl StructuredManipulator {
pub fn split(data: &str, params: &HashMap<String, Value>) -> Result<HashMap<String, String>, String> {
let v: Value = serde_json::from_str(data)
.or_else(|_| serde_yaml::from_str(data))
.map_err(|e| format!("Invalid structured data: {}", e))?;
let mut partitions = HashMap::new();
if let Value::Object(map) = v {
if let Some(Value::Object(groups)) = params.get("groups") {
for (g_name, g_keys) in groups {
if let Value::Array(keys) = g_keys {
let mut sub = serde_json::Map::new();
for k in keys {
if let Some(ks) = k.as_str() {
if let Some(val) = map.get(ks) {
sub.insert(ks.to_string(), val.clone());
}
}
}
partitions.insert(g_name.clone(), serde_json::to_string_pretty(&Value::Object(sub)).unwrap());
}
}
return Ok(partitions);
}
let keys: Vec<&String> = map.keys().collect();
let mid = keys.len() / 2;
let mut part1 = serde_json::Map::new();
let mut part2 = serde_json::Map::new();
for (i, k) in keys.iter().enumerate() {
if i < mid {
part1.insert((*k).clone(), map[*k].clone());
} else {
part2.insert((*k).clone(), map[*k].clone());
}
}
partitions.insert("part_1".to_string(), serde_json::to_string_pretty(&Value::Object(part1)).unwrap());
partitions.insert("part_2".to_string(), serde_json::to_string_pretty(&Value::Object(part2)).unwrap());
return Ok(partitions);
}
partitions.insert("all".to_string(), data.to_string());
Ok(partitions)
}
pub fn substitute(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
let mut v: Value = serde_json::from_str(data)
.or_else(|_| serde_yaml::from_str(data))
.map_err(|e| format!("Invalid structured data: {}", e))?;
if let (Value::Object(map), Some(Value::Object(replacements))) = (&mut v, params.get("replacements")) {
for (k, new_val) in replacements {
if map.contains_key(k) {
map.insert(k.clone(), new_val.clone());
}
}
}
serde_json::to_string_pretty(&v).map_err(|e| e.to_string())
}
pub fn augment(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
let mut v: Value = serde_json::from_str(data)
.or_else(|_| serde_yaml::from_str(data))
.map_err(|e| format!("Invalid structured data: {}", e))?;
if let (Value::Object(map), Some(Value::Object(fields))) = (&mut v, params.get("fields")) {
for (k, val) in fields {
map.insert(k.clone(), val.clone());
}
}
serde_json::to_string_pretty(&v).map_err(|e| e.to_string())
}
pub fn exclude(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
let mut v: Value = serde_json::from_str(data)
.or_else(|_| serde_yaml::from_str(data))
.map_err(|e| format!("Invalid structured data: {}", e))?;
let mut drop_keys = Vec::new();
if let Some(Value::Array(keys)) = params.get("keys") {
for k in keys {
if let Some(s) = k.as_str() {
drop_keys.push(s.to_string());
}
}
}
fn prune(val: &mut Value, drop: &[String]) {
match val {
Value::Object(map) => {
for k in drop {
map.remove(k);
}
for (_, child) in map.iter_mut() {
prune(child, drop);
}
}
Value::Array(arr) => {
for child in arr.iter_mut() {
prune(child, drop);
}
}
_ => {}
}
}
prune(&mut v, &drop_keys);
serde_json::to_string_pretty(&v).map_err(|e| e.to_string())
}
pub fn invert(data: &str, _params: &HashMap<String, Value>) -> Result<String, String> {
let v: Value = serde_json::from_str(data)
.or_else(|_| serde_yaml::from_str(data))
.map_err(|e| format!("Invalid structured data: {}", e))?;
match v {
Value::Object(map) => {
let mut inverted = serde_json::Map::new();
for (k, val) in map {
let val_str = match val {
Value::String(s) => s,
other => other.to_string(),
};
inverted.insert(val_str, Value::String(k));
}
serde_json::to_string_pretty(&Value::Object(inverted)).map_err(|e| e.to_string())
}
Value::Array(mut arr) => {
arr.reverse();
serde_json::to_string_pretty(&Value::Array(arr)).map_err(|e| e.to_string())
}
other => serde_json::to_string_pretty(&other).map_err(|e| e.to_string()),
}
}
pub fn port(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
let mut v: Value = serde_json::from_str(data)
.or_else(|_| serde_yaml::from_str(data))
.map_err(|e| format!("Invalid structured data: {}", e))?;
if let Some(target_runtime) = params.get("target_runtime").and_then(|r| r.as_str()) {
if let Value::Object(map) = &mut v {
map.insert("target_runtime".to_string(), Value::String(target_runtime.to_string()));
}
}
let target_fmt = params.get("target_format").and_then(|v| v.as_str()).unwrap_or("json").to_lowercase();
if target_fmt == "yaml" || target_fmt == "application/yaml" {
serde_yaml::to_string(&v).map_err(|e| e.to_string())
} else {
serde_json::to_string_pretty(&v).map_err(|e| e.to_string())
}
}
}
#[derive(Debug, Clone, PartialEq)]
enum Token {
Ident(String),
Num(f64),
Str(String),
Bool(bool),
Plus,
Minus,
Mul,
Div,
Eq,
Neq,
Lt,
Lte,
Gt,
Gte,
And,
Or,
Not,
LParen,
RParen,
}
fn tokenize_rule(expr: &str) -> Vec<Token> {
let mut tokens = Vec::new();
let chars: Vec<char> = expr.chars().collect();
let mut i = 0;
while i < chars.len() {
let c = chars[i];
if c.is_whitespace() {
i += 1;
continue;
}
if c == '=' && i + 1 < chars.len() && chars[i + 1] == '=' {
tokens.push(Token::Eq);
i += 2;
continue;
}
if c == '!' && i + 1 < chars.len() && chars[i + 1] == '=' {
tokens.push(Token::Neq);
i += 2;
continue;
}
if c == '<' && i + 1 < chars.len() && chars[i + 1] == '=' {
tokens.push(Token::Lte);
i += 2;
continue;
}
if c == '>' && i + 1 < chars.len() && chars[i + 1] == '=' {
tokens.push(Token::Gte);
i += 2;
continue;
}
if c == '&' && i + 1 < chars.len() && chars[i + 1] == '&' {
tokens.push(Token::And);
i += 2;
continue;
}
if c == '|' && i + 1 < chars.len() && chars[i + 1] == '|' {
tokens.push(Token::Or);
i += 2;
continue;
}
match c {
'+' => { tokens.push(Token::Plus); i += 1; }
'-' => { tokens.push(Token::Minus); i += 1; }
'*' => { tokens.push(Token::Mul); i += 1; }
'/' => { tokens.push(Token::Div); i += 1; }
'<' => { tokens.push(Token::Lt); i += 1; }
'>' => { tokens.push(Token::Gt); i += 1; }
'!' => { tokens.push(Token::Not); i += 1; }
'(' => { tokens.push(Token::LParen); i += 1; }
')' => { tokens.push(Token::RParen); i += 1; }
'\'' | '"' => {
let quote = c;
i += 1;
let mut s = String::new();
while i < chars.len() && chars[i] != quote {
s.push(chars[i]);
i += 1;
}
if i < chars.len() { i += 1; }
tokens.push(Token::Str(s));
}
_ if c.is_digit(10) => {
let mut num_str = String::new();
while i < chars.len() && (chars[i].is_digit(10) || chars[i] == '.') {
num_str.push(chars[i]);
i += 1;
}
let n: f64 = num_str.parse().unwrap_or(0.0);
tokens.push(Token::Num(n));
}
_ if c.is_alphabetic() || c == '_' => {
let mut ident = String::new();
while i < chars.len() && (chars[i].is_alphanumeric() || chars[i] == '_' || chars[i] == '.') {
ident.push(chars[i]);
i += 1;
}
match ident.as_str() {
"true" | "True" => tokens.push(Token::Bool(true)),
"false" | "False" => tokens.push(Token::Bool(false)),
"and" => tokens.push(Token::And),
"or" => tokens.push(Token::Or),
"not" => tokens.push(Token::Not),
_ => tokens.push(Token::Ident(ident)),
}
}
_ => { i += 1; }
}
}
tokens
}
#[derive(Debug, Clone, PartialEq)]
enum EvalVal {
Num(f64),
Str(String),
Bool(bool),
Null,
}
impl EvalVal {
fn as_bool(&self) -> bool {
match self {
EvalVal::Bool(b) => *b,
EvalVal::Num(n) => *n != 0.0,
EvalVal::Str(s) => !s.is_empty(),
EvalVal::Null => false,
}
}
}
pub struct SafeRuleEvaluator;
impl SafeRuleEvaluator {
pub fn evaluate(rule: &str, context: &Value) -> bool {
let tokens = tokenize_rule(rule);
if tokens.is_empty() {
return true;
}
let mut pos = 0;
match Self::parse_or(&tokens, &mut pos, context) {
Ok(v) => v.as_bool(),
Err(_) => false,
}
}
fn resolve_path(path: &str, context: &Value) -> EvalVal {
let parts: Vec<&str> = path.split('.').collect();
let mut curr = context;
for part in parts {
match curr {
Value::Object(map) => {
if let Some(val) = map.get(part) {
curr = val;
} else {
return EvalVal::Null;
}
}
_ => return EvalVal::Null,
}
}
match curr {
Value::Number(n) => EvalVal::Num(n.as_f64().unwrap_or(0.0)),
Value::String(s) => EvalVal::Str(s.clone()),
Value::Bool(b) => EvalVal::Bool(*b),
Value::Null => EvalVal::Null,
Value::Array(a) => EvalVal::Num(a.len() as f64),
Value::Object(o) => EvalVal::Num(o.len() as f64),
}
}
fn parse_or(tokens: &[Token], pos: &mut usize, ctx: &Value) -> Result<EvalVal, String> {
let mut left = Self::parse_and(tokens, pos, ctx)?;
while *pos < tokens.len() && tokens[*pos] == Token::Or {
*pos += 1;
let right = Self::parse_and(tokens, pos, ctx)?;
left = EvalVal::Bool(left.as_bool() || right.as_bool());
}
Ok(left)
}
fn parse_and(tokens: &[Token], pos: &mut usize, ctx: &Value) -> Result<EvalVal, String> {
let mut left = Self::parse_comparison(tokens, pos, ctx)?;
while *pos < tokens.len() && tokens[*pos] == Token::And {
*pos += 1;
let right = Self::parse_comparison(tokens, pos, ctx)?;
left = EvalVal::Bool(left.as_bool() && right.as_bool());
}
Ok(left)
}
fn parse_comparison(tokens: &[Token], pos: &mut usize, ctx: &Value) -> Result<EvalVal, String> {
let left = Self::parse_additive(tokens, pos, ctx)?;
if *pos < tokens.len() {
let op = tokens[*pos].clone();
match op {
Token::Eq | Token::Neq | Token::Lt | Token::Lte | Token::Gt | Token::Gte => {
*pos += 1;
let right = Self::parse_additive(tokens, pos, ctx)?;
let res = match (left, right) {
(EvalVal::Num(l), EvalVal::Num(r)) => match op {
Token::Eq => (l - r).abs() < 1e-9,
Token::Neq => (l - r).abs() >= 1e-9,
Token::Lt => l < r,
Token::Lte => l <= r,
Token::Gt => l > r,
Token::Gte => l >= r,
_ => false,
},
(EvalVal::Str(l), EvalVal::Str(r)) => match op {
Token::Eq => l == r,
Token::Neq => l != r,
Token::Lt => l < r,
Token::Lte => l <= r,
Token::Gt => l > r,
Token::Gte => l >= r,
_ => false,
},
(EvalVal::Bool(l), EvalVal::Bool(r)) => match op {
Token::Eq => l == r,
Token::Neq => l != r,
_ => false,
},
(EvalVal::Num(l), EvalVal::Null) | (EvalVal::Null, EvalVal::Num(l)) => match op {
Token::Eq => l == 0.0,
Token::Neq => l != 0.0,
Token::Lte => l <= 0.0,
Token::Lt => l < 0.0,
Token::Gte => l >= 0.0,
Token::Gt => l > 0.0,
_ => false,
},
_ => match op {
Token::Eq => false,
Token::Neq => true,
_ => false,
},
};
return Ok(EvalVal::Bool(res));
}
_ => {}
}
}
Ok(left)
}
fn parse_additive(tokens: &[Token], pos: &mut usize, ctx: &Value) -> Result<EvalVal, String> {
let mut left = Self::parse_multiplicative(tokens, pos, ctx)?;
while *pos < tokens.len() {
let op = tokens[*pos].clone();
if op == Token::Plus || op == Token::Minus {
*pos += 1;
let right = Self::parse_multiplicative(tokens, pos, ctx)?;
match (left, right) {
(EvalVal::Num(l), EvalVal::Num(r)) => {
left = EvalVal::Num(if op == Token::Plus { l + r } else { l - r });
}
(EvalVal::Str(l), EvalVal::Str(r)) => {
left = EvalVal::Str(format!("{}{}", l, r));
}
_ => return Err("Type mismatch in additive op".to_string()),
}
} else {
break;
}
}
Ok(left)
}
fn parse_multiplicative(tokens: &[Token], pos: &mut usize, ctx: &Value) -> Result<EvalVal, String> {
let mut left = Self::parse_unary(tokens, pos, ctx)?;
while *pos < tokens.len() {
let op = tokens[*pos].clone();
if op == Token::Mul || op == Token::Div {
*pos += 1;
let right = Self::parse_unary(tokens, pos, ctx)?;
match (left, right) {
(EvalVal::Num(l), EvalVal::Num(r)) => {
left = EvalVal::Num(if op == Token::Mul { l * r } else { l / r });
}
_ => return Err("Type mismatch in multiplicative op".to_string()),
}
} else {
break;
}
}
Ok(left)
}
fn parse_unary(tokens: &[Token], pos: &mut usize, ctx: &Value) -> Result<EvalVal, String> {
if *pos < tokens.len() {
if tokens[*pos] == Token::Not {
*pos += 1;
let val = Self::parse_unary(tokens, pos, ctx)?;
return Ok(EvalVal::Bool(!val.as_bool()));
}
if tokens[*pos] == Token::Minus {
*pos += 1;
let val = Self::parse_unary(tokens, pos, ctx)?;
if let EvalVal::Num(n) = val {
return Ok(EvalVal::Num(-n));
}
}
}
Self::parse_primary(tokens, pos, ctx)
}
fn parse_primary(tokens: &[Token], pos: &mut usize, ctx: &Value) -> Result<EvalVal, String> {
if *pos >= tokens.len() {
return Err("Unexpected end of expression".to_string());
}
let tok = &tokens[*pos];
*pos += 1;
match tok {
Token::Num(n) => Ok(EvalVal::Num(*n)),
Token::Str(s) => Ok(EvalVal::Str(s.clone())),
Token::Bool(b) => Ok(EvalVal::Bool(*b)),
Token::Ident(id) => Ok(Self::resolve_path(id, ctx)),
Token::LParen => {
let val = Self::parse_or(tokens, pos, ctx)?;
if *pos < tokens.len() && tokens[*pos] == Token::RParen {
*pos += 1;
Ok(val)
} else {
Err("Missing closing parenthesis".to_string())
}
}
_ => Err(format!("Unexpected token: {:?}", tok)),
}
}
}
pub fn build_item_context(payload: &str) -> Value {
let mut ctx = serde_json::Map::new();
ctx.insert("size_bytes".to_string(), json!(payload.as_bytes().len()));
let non_empty_lines: Vec<&str> = payload.lines().filter(|l| !l.trim().is_empty()).collect();
ctx.insert("line_count".to_string(), json!(non_empty_lines.len()));
if let Some(first_line) = non_empty_lines.first() {
if first_line.contains(',') {
let cols: Vec<String> = first_line.split(',').map(|s| s.trim().to_string()).collect();
ctx.insert("column_count".to_string(), json!(cols.len()));
ctx.insert("columns".to_string(), json!(cols));
let row_count = if non_empty_lines.len() > 1 { non_empty_lines.len() - 1 } else { 0 };
ctx.insert("row_count".to_string(), json!(row_count));
}
}
if let Ok(Value::Object(obj)) = serde_json::from_str::<Value>(payload) {
ctx.insert("key_count".to_string(), json!(obj.len()));
let keys: Vec<String> = obj.keys().cloned().collect();
ctx.insert("keys".to_string(), json!(keys));
for (k, v) in obj {
ctx.insert(k, v);
}
} else if let Ok(Value::Array(arr)) = serde_json::from_str::<Value>(payload) {
ctx.insert("item_count".to_string(), json!(arr.len()));
ctx.insert("row_count".to_string(), json!(arr.len()));
}
Value::Object(ctx)
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ExecutionResult {
pub status: String,
pub operator: String,
pub outputs: HashMap<String, String>,
pub input_hashes: HashMap<String, String>,
pub output_hashes: HashMap<String, String>,
pub metrics: HashMap<String, Value>,
pub error: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Verdict {
pub invariant: String,
pub rule: String,
pub passed: bool,
pub description: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VCardReceipt {
pub uri: String,
pub hash: String,
pub payload: Value,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HoareSandwichResult {
pub status: String,
pub action_name: String,
pub outputs: HashMap<String, String>,
pub receipt: Option<VCardReceipt>,
pub precondition_verdicts: Vec<Verdict>,
pub postcondition_verdicts: Vec<Verdict>,
pub rollback_occurred: bool,
pub rollback_time_ms: f64,
pub metrics: HashMap<String, Value>,
pub error: Option<String>,
}
pub struct ActionDispatcher;
impl ActionDispatcher {
pub fn execute(
manifest: &ActionManifest,
input_bindings: &HashMap<String, String>,
) -> ExecutionResult {
let t_start = std::time::Instant::now();
let operator = &manifest.operation.operator;
let params = &manifest.operation.parameters;
let mut input_hashes = HashMap::new();
let mut resolved_inputs = HashMap::new();
for inp in &manifest.inputs {
let val = input_bindings.get(&inp.name)
.or_else(|| inp.uri.as_ref().and_then(|u| input_bindings.get(u)));
if val.is_none() && inp.required {
return ExecutionResult {
status: "failed".to_string(),
operator: operator.to_string(),
outputs: HashMap::new(),
input_hashes,
output_hashes: HashMap::new(),
metrics: HashMap::new(),
error: Some(format!("Required input '{}' could not be resolved", inp.name)),
};
}
if let Some(v) = val {
let h = clm_hash_string(v);
input_hashes.insert(inp.name.clone(), h);
resolved_inputs.insert(inp.name.clone(), v.clone());
}
}
let primary_input = resolved_inputs.values().next().cloned().unwrap_or_default();
let primary_format = manifest.inputs.first().and_then(|i| i.format.clone()).unwrap_or_else(|| "csv".to_string());
let mut outputs = HashMap::new();
let mut output_hashes = HashMap::new();
let run_res: Result<HashMap<String, String>, String> = match primary_format.as_str() {
"csv" | "tabular" => {
match operator {
BaldwinOperator::Split => TabularManipulator::split(&primary_input, params),
BaldwinOperator::Substitute => TabularManipulator::substitute(&primary_input, params).map(|s| {
let mut m = HashMap::new();
let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "output".to_string());
m.insert(out_name, s);
m
}),
BaldwinOperator::Augment => TabularManipulator::augment(&primary_input, params).map(|s| {
let mut m = HashMap::new();
let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "augmented".to_string());
m.insert(out_name, s);
m
}),
BaldwinOperator::Exclude => TabularManipulator::exclude(&primary_input, params).map(|s| {
let mut m = HashMap::new();
let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "sanitized".to_string());
m.insert(out_name, s);
m
}),
BaldwinOperator::Invert => TabularManipulator::invert(&primary_input, params).map(|s| {
let mut m = HashMap::new();
let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "inverted".to_string());
m.insert(out_name, s);
m
}),
BaldwinOperator::Port => TabularManipulator::port(&primary_input, params).map(|s| {
let mut m = HashMap::new();
let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "ported".to_string());
m.insert(out_name, s);
m
}),
BaldwinOperator::Custom => Ok(HashMap::new()),
}
}
"markdown" | "text" | "md" => {
match operator {
BaldwinOperator::Split => DocumentManipulator::split(&primary_input, params),
BaldwinOperator::Substitute => DocumentManipulator::substitute(&primary_input, params).map(|s| {
let mut m = HashMap::new();
let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "substituted".to_string());
m.insert(out_name, s);
m
}),
BaldwinOperator::Augment => DocumentManipulator::augment(&primary_input, params).map(|s| {
let mut m = HashMap::new();
let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "augmented".to_string());
m.insert(out_name, s);
m
}),
BaldwinOperator::Exclude => DocumentManipulator::exclude(&primary_input, params).map(|s| {
let mut m = HashMap::new();
let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "pruned".to_string());
m.insert(out_name, s);
m
}),
BaldwinOperator::Invert => DocumentManipulator::invert(&primary_input, params).map(|s| {
let mut m = HashMap::new();
let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "inverted".to_string());
m.insert(out_name, s);
m
}),
BaldwinOperator::Port => DocumentManipulator::port(&primary_input, params).map(|s| {
let mut m = HashMap::new();
let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "ported".to_string());
m.insert(out_name, s);
m
}),
BaldwinOperator::Custom => Ok(HashMap::new()),
}
}
_ => { match operator {
BaldwinOperator::Split => StructuredManipulator::split(&primary_input, params),
BaldwinOperator::Substitute => StructuredManipulator::substitute(&primary_input, params).map(|s| {
let mut m = HashMap::new();
let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "substituted".to_string());
m.insert(out_name, s);
m
}),
BaldwinOperator::Augment => StructuredManipulator::augment(&primary_input, params).map(|s| {
let mut m = HashMap::new();
let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "augmented".to_string());
m.insert(out_name, s);
m
}),
BaldwinOperator::Exclude => StructuredManipulator::exclude(&primary_input, params).map(|s| {
let mut m = HashMap::new();
let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "pruned".to_string());
m.insert(out_name, s);
m
}),
BaldwinOperator::Invert => StructuredManipulator::invert(&primary_input, params).map(|s| {
let mut m = HashMap::new();
let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "inverted".to_string());
m.insert(out_name, s);
m
}),
BaldwinOperator::Port => StructuredManipulator::port(&primary_input, params).map(|s| {
let mut m = HashMap::new();
let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "ported".to_string());
m.insert(out_name, s);
m
}),
BaldwinOperator::Custom => Ok(HashMap::new()),
}
}
};
match run_res {
Ok(res_map) => {
if manifest.outputs.len() > 1 && res_map.len() > 1 {
for out_spec in &manifest.outputs {
if let Some(val) = res_map.get(&out_spec.name) {
outputs.insert(out_spec.name.clone(), val.clone());
output_hashes.insert(out_spec.name.clone(), clm_hash_string(val));
}
}
} else if let Some(out_spec) = manifest.outputs.first() {
let val = res_map.get(&out_spec.name)
.cloned()
.unwrap_or_else(|| res_map.values().next().cloned().unwrap_or_default());
outputs.insert(out_spec.name.clone(), val.clone());
output_hashes.insert(out_spec.name.clone(), clm_hash_string(&val));
}
let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
let mut metrics = HashMap::new();
metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
metrics.insert("operator".to_string(), json!(operator.to_string()));
metrics.insert("action_name".to_string(), json!(manifest.clm.name));
ExecutionResult {
status: "success".to_string(),
operator: operator.to_string(),
outputs,
input_hashes,
output_hashes,
metrics,
error: None,
}
}
Err(e) => {
let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
let mut metrics = HashMap::new();
metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
ExecutionResult {
status: "failed".to_string(),
operator: operator.to_string(),
outputs: HashMap::new(),
input_hashes,
output_hashes: HashMap::new(),
metrics,
error: Some(e),
}
}
}
}
}
pub struct HoareSandwichEngine;
impl HoareSandwichEngine {
pub fn execute(
manifest: &ActionManifest,
input_bindings: &HashMap<String, String>,
) -> HoareSandwichResult {
let t_start = std::time::Instant::now();
let action_manifest_val = manifest.to_canonical_json_value();
let action_hash = compute_canonical_hash(&action_manifest_val);
let mut pre_ctx_map = serde_json::Map::new();
for inp in &manifest.inputs {
if let Some(payload) = input_bindings.get(&inp.name) {
let item_ctx = build_item_context(payload);
pre_ctx_map.insert(inp.name.clone(), item_ctx.clone());
if manifest.inputs.len() == 1 || inp.name == "dataset" {
pre_ctx_map.insert("input".to_string(), item_ctx);
}
}
}
let pre_ctx = Value::Object(pre_ctx_map.clone());
let mut pre_verdicts = Vec::new();
for pre in &manifest.preconditions {
let passed = SafeRuleEvaluator::evaluate(&pre.rule, &pre_ctx);
let verdict = Verdict {
invariant: pre.invariant.clone(),
rule: pre.rule.clone(),
passed,
description: pre.description.clone(),
};
pre_verdicts.push(verdict);
if !passed {
let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
let mut metrics = HashMap::new();
metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
return HoareSandwichResult {
status: "failed".to_string(),
action_name: manifest.clm.name.clone(),
outputs: HashMap::new(),
receipt: None,
precondition_verdicts: pre_verdicts,
postcondition_verdicts: Vec::new(),
rollback_occurred: false,
rollback_time_ms: 0.0,
metrics,
error: Some(format!(
"Precondition '{}' violated: '{}' evaluated to false",
pre.invariant, pre.rule
)),
};
}
}
let exec_result = ActionDispatcher::execute(manifest, input_bindings);
if exec_result.status != "success" {
let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
let mut metrics = HashMap::new();
metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
return HoareSandwichResult {
status: "failed".to_string(),
action_name: manifest.clm.name.clone(),
outputs: HashMap::new(),
receipt: None,
precondition_verdicts: pre_verdicts,
postcondition_verdicts: Vec::new(),
rollback_occurred: false,
rollback_time_ms: 0.0,
metrics,
error: exec_result.error,
};
}
let mut post_ctx_map = pre_ctx_map.clone();
let mut out_map = serde_json::Map::new();
for (name, payload) in &exec_result.outputs {
let item_ctx = build_item_context(payload);
out_map.insert(name.clone(), item_ctx);
}
if exec_result.outputs.len() == 1 {
let first_val = out_map.values().next().cloned().unwrap_or(Value::Null);
if let Value::Object(obj) = first_val {
for (k, v) in obj {
out_map.insert(k, v);
}
}
}
post_ctx_map.insert("output".to_string(), Value::Object(out_map));
let post_ctx = Value::Object(post_ctx_map);
let mut post_verdicts = Vec::new();
for post in &manifest.postconditions {
let passed = SafeRuleEvaluator::evaluate(&post.rule, &post_ctx);
let verdict = Verdict {
invariant: post.invariant.clone(),
rule: post.rule.clone(),
passed,
description: post.description.clone(),
};
post_verdicts.push(verdict);
if !passed {
let rb_start = std::time::Instant::now();
let rollback_time_ms = (rb_start.elapsed().as_secs_f64() * 1000.0).max(0.01);
let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
let mut metrics = HashMap::new();
metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
return HoareSandwichResult {
status: "failed".to_string(),
action_name: manifest.clm.name.clone(),
outputs: HashMap::new(),
receipt: None,
precondition_verdicts: pre_verdicts,
postcondition_verdicts: post_verdicts,
rollback_occurred: true,
rollback_time_ms,
metrics,
error: Some(format!(
"Postcondition '{}' violated: '{}' evaluated to false",
post.invariant, post.rule
)),
};
}
}
let pre_verdicts_val = serde_json::to_value(&pre_verdicts).unwrap_or(Value::Null);
let post_verdicts_val = serde_json::to_value(&post_verdicts).unwrap_or(Value::Null);
let pre_digest = compute_canonical_hash(&pre_verdicts_val);
let post_digest = compute_canonical_hash(&post_verdicts_val);
let witness_preimage = format!("{}:{}:{}", pre_digest, action_hash, post_digest);
let witness_hash = clm_hash_string(&witness_preimage);
let receipt_canonical_payload = json!({
"archetype": "VCardReceipt",
"action": {
"name": manifest.clm.name,
"hash": action_hash,
},
"inputs": exec_result.input_hashes,
"outputs": exec_result.output_hashes,
"verification": {
"preconditions": pre_verdicts,
"postconditions": post_verdicts,
"all_passed": true,
},
"witness": witness_hash,
});
let receipt_hash = compute_canonical_hash(&receipt_canonical_payload);
let receipt_uri = format!("mcard://receipts/{}", &receipt_hash[..16]);
let receipt = VCardReceipt {
uri: receipt_uri,
hash: receipt_hash,
payload: receipt_canonical_payload,
};
let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
let mut final_metrics = exec_result.metrics.clone();
final_metrics.insert("hoare_total_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
HoareSandwichResult {
status: "success".to_string(),
action_name: manifest.clm.name.clone(),
outputs: exec_result.outputs,
receipt: Some(receipt),
precondition_verdicts: pre_verdicts,
postcondition_verdicts: post_verdicts,
rollback_occurred: false,
rollback_time_ms: 0.0,
metrics: final_metrics,
error: None,
}
}
}