1use std::collections::{BTreeMap, HashMap};
5use std::path::Path;
6use serde::{Deserialize, Serialize};
7use serde_json::{json, Value};
8
9#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
11#[serde(rename_all = "lowercase")]
12pub enum ActionFormat {
13 Csv,
14 Json,
15 Yaml,
16 Markdown,
17 Text,
18 Binary,
19 Media,
20}
21
22#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
24#[serde(rename_all = "lowercase")]
25pub enum BaldwinOperator {
26 Split,
27 Substitute,
28 Augment,
29 Exclude,
30 Invert,
31 Port,
32 Custom,
33}
34
35impl std::fmt::Display for BaldwinOperator {
36 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
37 match self {
38 BaldwinOperator::Split => write!(f, "split"),
39 BaldwinOperator::Substitute => write!(f, "substitute"),
40 BaldwinOperator::Augment => write!(f, "augment"),
41 BaldwinOperator::Exclude => write!(f, "exclude"),
42 BaldwinOperator::Invert => write!(f, "invert"),
43 BaldwinOperator::Port => write!(f, "port"),
44 BaldwinOperator::Custom => write!(f, "custom"),
45 }
46 }
47}
48
49#[derive(Debug, Clone, Serialize, Deserialize)]
50pub struct ActionMetadata {
51 #[serde(default = "default_action_type")]
52 pub r#type: String,
53 pub name: String,
54 #[serde(skip_serializing_if = "Option::is_none")]
55 pub description: Option<String>,
56 #[serde(default = "default_face")]
57 pub face: String,
58 pub operator: BaldwinOperator,
59 #[serde(default = "default_author")]
60 pub author: String,
61}
62
63fn default_action_type() -> String { "action".to_string() }
64fn default_face() -> String { "C".to_string() }
65fn default_author() -> String { "did:clm:system".to_string() }
66
67#[derive(Debug, Clone, Serialize, Deserialize)]
68pub struct ActionInput {
69 pub name: String,
70 #[serde(skip_serializing_if = "Option::is_none")]
71 pub uri: Option<String>,
72 #[serde(skip_serializing_if = "Option::is_none")]
73 pub format: Option<String>,
74 #[serde(default = "default_true")]
75 pub required: bool,
76 #[serde(skip_serializing_if = "Option::is_none")]
77 pub description: Option<String>,
78}
79
80fn default_true() -> bool { true }
81
82#[derive(Debug, Clone, Serialize, Deserialize)]
83pub struct ActionPrecondition {
84 pub invariant: String,
85 pub rule: String,
86 #[serde(skip_serializing_if = "Option::is_none")]
87 pub schema_ref: Option<String>,
88 #[serde(skip_serializing_if = "Option::is_none")]
89 pub description: Option<String>,
90}
91
92#[derive(Debug, Clone, Serialize, Deserialize)]
93pub struct ActionOperation {
94 pub operator: BaldwinOperator,
95 #[serde(skip_serializing_if = "Option::is_none")]
96 pub strategy: Option<String>,
97 #[serde(default)]
98 pub parameters: HashMap<String, Value>,
99 #[serde(default = "default_runtime")]
100 pub runtime: String,
101}
102
103fn default_runtime() -> String { "builtin".to_string() }
104
105#[derive(Debug, Clone, Serialize, Deserialize)]
106pub struct ActionPostcondition {
107 pub invariant: String,
108 pub rule: String,
109 #[serde(skip_serializing_if = "Option::is_none")]
110 pub schema_ref: Option<String>,
111 #[serde(skip_serializing_if = "Option::is_none")]
112 pub description: Option<String>,
113}
114
115#[derive(Debug, Clone, Serialize, Deserialize)]
116pub struct ActionOutput {
117 pub name: String,
118 #[serde(skip_serializing_if = "Option::is_none")]
119 pub handle: Option<String>,
120 #[serde(skip_serializing_if = "Option::is_none")]
121 pub format: Option<String>,
122 #[serde(skip_serializing_if = "Option::is_none")]
123 pub description: Option<String>,
124}
125
126#[derive(Debug, Clone, Serialize, Deserialize)]
127pub struct ActionManifest {
128 #[serde(default = "default_version")]
129 pub version: String,
130 pub clm: ActionMetadata,
131 pub inputs: Vec<ActionInput>,
132 #[serde(default)]
133 pub preconditions: Vec<ActionPrecondition>,
134 pub operation: ActionOperation,
135 #[serde(default)]
136 pub postconditions: Vec<ActionPostcondition>,
137 pub outputs: Vec<ActionOutput>,
138}
139
140fn default_version() -> String { "1.0".to_string() }
141
142impl ActionManifest {
143 pub fn from_yaml_str(yaml_str: &str) -> Result<Self, String> {
144 let manifest: ActionManifest = serde_yaml::from_str(yaml_str)
145 .map_err(|e| format!("Failed to parse YAML ActionManifest: {}", e))?;
146 if manifest.clm.operator != manifest.operation.operator {
147 return Err(format!(
148 "Operator mismatch: clm.operator='{}' != operation.operator='{}'",
149 manifest.clm.operator, manifest.operation.operator
150 ));
151 }
152 Ok(manifest)
153 }
154
155 pub fn from_yaml_file<P: AsRef<Path>>(path: P) -> Result<Self, String> {
156 let content = std::fs::read_to_string(path.as_ref())
157 .map_err(|e| format!("Cannot read file {}: {}", path.as_ref().display(), e))?;
158 Self::from_yaml_str(&content)
159 }
160
161 pub fn to_canonical_json_value(&self) -> Value {
162 serde_json::to_value(self).unwrap_or(Value::Null)
163 }
164}
165
166pub fn sort_json_value(v: &Value) -> Value {
169 match v {
170 Value::Object(map) => {
171 let mut sorted = BTreeMap::new();
172 for (k, val) in map {
173 sorted.insert(k.clone(), sort_json_value(val));
174 }
175 serde_json::to_value(sorted).unwrap()
176 }
177 Value::Array(arr) => {
178 Value::Array(arr.iter().map(sort_json_value).collect())
179 }
180 other => other.clone(),
181 }
182}
183
184pub fn compute_canonical_serialized(val: &Value) -> String {
185 let sorted = sort_json_value(val);
186 serde_json::to_string(&sorted).unwrap_or_default()
187}
188
189pub fn compute_canonical_hash(val: &Value) -> String {
190 let s = compute_canonical_serialized(val);
191 blake3::hash(s.as_bytes()).to_hex().to_string()
192}
193
194pub fn clm_hash_string(s: &str) -> String {
195 blake3::hash(s.as_bytes()).to_hex().to_string()
196}
197
198pub struct TabularManipulator;
201
202impl TabularManipulator {
203 pub fn parse_csv(text: &str) -> (Vec<String>, Vec<Vec<String>>) {
204 let mut lines = text.lines().filter(|l| !l.trim().is_empty());
205 let header_line = match lines.next() {
206 Some(h) => h,
207 None => return (vec![], vec![]),
208 };
209 let headers: Vec<String> = header_line.split(',').map(|s| s.trim().to_string()).collect();
210 let mut rows = Vec::new();
211 for line in lines {
212 let row: Vec<String> = line.split(',').map(|s| s.trim().to_string()).collect();
213 rows.push(row);
214 }
215 (headers, rows)
216 }
217
218 pub fn render_csv(headers: &[String], rows: &[Vec<String>]) -> String {
219 let mut out = String::new();
220 if !headers.is_empty() {
221 out.push_str(&headers.join(","));
222 out.push('\n');
223 }
224 for r in rows {
225 out.push_str(&r.join(","));
226 out.push('\n');
227 }
228 out
229 }
230
231 pub fn split(data: &str, params: &HashMap<String, Value>) -> Result<HashMap<String, String>, String> {
232 let (headers, rows) = Self::parse_csv(data);
233 if rows.is_empty() {
234 let mut res = HashMap::new();
235 res.insert("part_1".to_string(), Self::render_csv(&headers, &[]));
236 res.insert("part_2".to_string(), Self::render_csv(&headers, &[]));
237 return Ok(res);
238 }
239
240 if let Some(Value::Object(ratios)) = params.get("ratios") {
241 let total = rows.len();
242 let mut partitions = HashMap::new();
243 let mut current_idx = 0;
244 let ratio_list: Vec<(&String, f64)> = ratios
245 .iter()
246 .map(|(k, v)| (k, v.as_f64().unwrap_or(0.0)))
247 .collect();
248
249 for (i, (name, ratio)) in ratio_list.iter().enumerate() {
250 let part_rows = if i == ratio_list.len() - 1 {
251 &rows[current_idx..]
252 } else {
253 let count = (total as f64 * ratio).round() as usize;
254 let end = (current_idx + count).min(total);
255 let slice = &rows[current_idx..end];
256 current_idx = end;
257 slice
258 };
259 partitions.insert((*name).clone(), Self::render_csv(&headers, part_rows));
260 }
261 return Ok(partitions);
262 }
263
264 let mid = rows.len() / 2;
265 let mut partitions = HashMap::new();
266 partitions.insert("part_1".to_string(), Self::render_csv(&headers, &rows[..mid]));
267 partitions.insert("part_2".to_string(), Self::render_csv(&headers, &rows[mid..]));
268 Ok(partitions)
269 }
270
271 pub fn substitute(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
272 let (mut headers, rows) = Self::parse_csv(data);
273 if let (Some(target), Some(replacement)) = (
274 params.get("target_column").and_then(|v| v.as_str()),
275 params.get("replacement_column").and_then(|v| v.as_str()),
276 ) {
277 for h in &mut headers {
278 if h == target {
279 *h = replacement.to_string();
280 }
281 }
282 } else if let Some(Value::Object(rename)) = params.get("rename_columns") {
283 for h in &mut headers {
284 if let Some(new_name) = rename.get(h).and_then(|v| v.as_str()) {
285 *h = new_name.to_string();
286 }
287 }
288 }
289 Ok(Self::render_csv(&headers, &rows))
290 }
291
292 pub fn augment(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
293 let (mut headers, rows) = Self::parse_csv(data);
294 let col_name = params.get("column_name")
295 .or_else(|| params.get("target_column"))
296 .and_then(|v| v.as_str())
297 .unwrap_or("augmented_col");
298 let default_val = params.get("default_value")
299 .or_else(|| params.get("constant_value"))
300 .map(|v| match v {
301 Value::String(s) => s.clone(),
302 other => other.to_string(),
303 })
304 .unwrap_or_else(|| "active".to_string());
305
306 headers.push(col_name.to_string());
307 let mut new_rows = Vec::new();
308 for r in rows {
309 let mut nr = r;
310 nr.push(default_val.clone());
311 new_rows.push(nr);
312 }
313 Ok(Self::render_csv(&headers, &new_rows))
314 }
315
316 pub fn exclude(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
317 let (headers, rows) = Self::parse_csv(data);
318 let mut drop_cols = Vec::new();
319 if let Some(Value::Array(cols)) = params.get("columns").or_else(|| params.get("target_columns")) {
320 for c in cols {
321 if let Some(s) = c.as_str() {
322 drop_cols.push(s.to_string());
323 }
324 }
325 }
326
327 let keep_indices: Vec<usize> = headers
328 .iter()
329 .enumerate()
330 .filter(|(_, h)| !drop_cols.contains(h))
331 .map(|(i, _)| i)
332 .collect();
333
334 let new_headers: Vec<String> = keep_indices.iter().map(|&i| headers[i].clone()).collect();
335 let mut new_rows = Vec::new();
336 for r in rows {
337 let nr: Vec<String> = keep_indices.iter().filter(|&&i| i < r.len()).map(|&i| r[i].clone()).collect();
338 new_rows.push(nr);
339 }
340 Ok(Self::render_csv(&new_headers, &new_rows))
341 }
342
343 pub fn invert(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
344 let (headers, mut rows) = Self::parse_csv(data);
345 let strategy = params.get("strategy").and_then(|v| v.as_str()).unwrap_or("reverse_rows");
346 if strategy == "transpose" && !headers.is_empty() {
347 let mut matrix = vec![headers];
348 matrix.extend(rows);
349 let cols = matrix[0].len();
350 let mut transposed = Vec::new();
351 for c in 0..cols {
352 let mut row = Vec::new();
353 for r in 0..matrix.len() {
354 if c < matrix[r].len() {
355 row.push(matrix[r][c].clone());
356 }
357 }
358 transposed.push(row);
359 }
360 let new_headers = transposed.first().cloned().unwrap_or_default();
361 let new_rows = if transposed.len() > 1 { transposed[1..].to_vec() } else { vec![] };
362 return Ok(Self::render_csv(&new_headers, &new_rows));
363 }
364 rows.reverse();
365 Ok(Self::render_csv(&headers, &rows))
366 }
367
368 pub fn port(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
369 let (headers, rows) = Self::parse_csv(data);
370 let target_format = params.get("target_format").and_then(|v| v.as_str()).unwrap_or("json").to_lowercase();
371 if target_format == "json" {
372 let mut records = Vec::new();
373 for r in rows {
374 let mut obj = serde_json::Map::new();
375 for (i, h) in headers.iter().enumerate() {
376 let val = if i < r.len() { r[i].clone() } else { String::new() };
377 obj.insert(h.clone(), Value::String(val));
378 }
379 records.push(Value::Object(obj));
380 }
381 return serde_json::to_string_pretty(&records).map_err(|e| e.to_string());
382 }
383 Ok(Self::render_csv(&headers, &rows))
384 }
385}
386
387pub struct DocumentManipulator;
388
389impl DocumentManipulator {
390 pub fn split(data: &str, params: &HashMap<String, Value>) -> Result<HashMap<String, String>, String> {
391 let delimiter = params.get("delimiter").and_then(|v| v.as_str()).unwrap_or("# ");
392 let mut results = HashMap::new();
393 let parts: Vec<&str> = data.split(delimiter).collect();
394 if parts.len() <= 1 {
395 results.insert("document".to_string(), data.to_string());
396 return Ok(results);
397 }
398
399 let mut idx = 1;
400 for part in &parts[1..] {
401 let key = format!("section_{}", idx);
402 let content = format!("{}{}", delimiter, part.trim());
403 results.insert(key, content);
404 idx += 1;
405 }
406 if !parts[0].trim().is_empty() {
407 results.insert("intro".to_string(), parts[0].trim().to_string());
408 }
409 Ok(results)
410 }
411
412 pub fn substitute(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
413 let mut res = data.to_string();
414 if let (Some(target), Some(replacement)) = (
415 params.get("target_header").and_then(|v| v.as_str()),
416 params.get("replacement_header").and_then(|v| v.as_str()),
417 ) {
418 res = res.replace(target, replacement);
419 } else if let Some(Value::Object(replacements)) = params.get("replacements") {
420 for (old, new_val) in replacements {
421 if let Some(new_str) = new_val.as_str() {
422 res = res.replace(old, new_str);
423 }
424 }
425 }
426 Ok(res)
427 }
428
429 pub fn augment(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
430 let mut res = data.to_string();
431 if let Some(content) = params.get("content").and_then(|v| v.as_str()) {
432 if !res.ends_with('\n') {
433 res.push('\n');
434 }
435 res.push_str(content);
436 if !res.ends_with('\n') {
437 res.push('\n');
438 }
439 }
440 Ok(res)
441 }
442
443 pub fn exclude(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
444 let section_title = params.get("section_title").and_then(|v| v.as_str()).unwrap_or("");
445 let mut lines = Vec::new();
446 let mut skipping = false;
447 for line in data.lines() {
448 if line.starts_with('#') && line.contains(section_title) && !section_title.is_empty() {
449 skipping = true;
450 continue;
451 }
452 if skipping && line.starts_with('#') {
453 skipping = false;
454 }
455 if !skipping {
456 lines.push(line);
457 }
458 }
459 let mut res = lines.join("\n");
460 if data.ends_with('\n') {
461 res.push('\n');
462 }
463 Ok(res)
464 }
465
466 pub fn invert(data: &str, _params: &HashMap<String, Value>) -> Result<String, String> {
467 let sections: Vec<&str> = data.split("\n#").collect();
468 if sections.len() <= 1 {
469 return Ok(data.to_string());
470 }
471 let intro = sections[0];
472 let mut rest: Vec<String> = sections[1..].iter().map(|s| format!("#{}", s)).collect();
473 rest.reverse();
474 Ok(format!("{}\n{}", intro.trim(), rest.join("\n")))
475 }
476
477 pub fn port(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
478 let target_fmt = params.get("target_format").and_then(|v| v.as_str()).unwrap_or("text").to_lowercase();
479 if target_fmt == "html" {
480 let mut html = String::new();
481 for line in data.lines() {
482 if let Some(h1) = line.strip_prefix("# ") {
483 html.push_str(&format!("<h1>{}</h1>\n", h1.trim()));
484 } else if let Some(h2) = line.strip_prefix("## ") {
485 html.push_str(&format!("<h2>{}</h2>\n", h2.trim()));
486 } else if !line.trim().is_empty() {
487 html.push_str(&format!("<p>{}</p>\n", line.trim()));
488 }
489 }
490 return Ok(html);
491 }
492 let plain = data.replace('#', "").replace('*', "").replace('`', "");
494 Ok(plain)
495 }
496}
497
498pub struct StructuredManipulator;
499
500impl StructuredManipulator {
501 pub fn split(data: &str, params: &HashMap<String, Value>) -> Result<HashMap<String, String>, String> {
502 let v: Value = serde_json::from_str(data)
503 .or_else(|_| serde_yaml::from_str(data))
504 .map_err(|e| format!("Invalid structured data: {}", e))?;
505
506 let mut partitions = HashMap::new();
507 if let Value::Object(map) = v {
508 if let Some(Value::Object(groups)) = params.get("groups") {
509 for (g_name, g_keys) in groups {
510 if let Value::Array(keys) = g_keys {
511 let mut sub = serde_json::Map::new();
512 for k in keys {
513 if let Some(ks) = k.as_str() {
514 if let Some(val) = map.get(ks) {
515 sub.insert(ks.to_string(), val.clone());
516 }
517 }
518 }
519 partitions.insert(g_name.clone(), serde_json::to_string_pretty(&Value::Object(sub)).unwrap());
520 }
521 }
522 return Ok(partitions);
523 }
524 let keys: Vec<&String> = map.keys().collect();
525 let mid = keys.len() / 2;
526 let mut part1 = serde_json::Map::new();
527 let mut part2 = serde_json::Map::new();
528 for (i, k) in keys.iter().enumerate() {
529 if i < mid {
530 part1.insert((*k).clone(), map[*k].clone());
531 } else {
532 part2.insert((*k).clone(), map[*k].clone());
533 }
534 }
535 partitions.insert("part_1".to_string(), serde_json::to_string_pretty(&Value::Object(part1)).unwrap());
536 partitions.insert("part_2".to_string(), serde_json::to_string_pretty(&Value::Object(part2)).unwrap());
537 return Ok(partitions);
538 }
539 partitions.insert("all".to_string(), data.to_string());
540 Ok(partitions)
541 }
542
543 pub fn substitute(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
544 let mut v: Value = serde_json::from_str(data)
545 .or_else(|_| serde_yaml::from_str(data))
546 .map_err(|e| format!("Invalid structured data: {}", e))?;
547
548 if let (Value::Object(map), Some(Value::Object(replacements))) = (&mut v, params.get("replacements")) {
549 for (k, new_val) in replacements {
550 if map.contains_key(k) {
551 map.insert(k.clone(), new_val.clone());
552 }
553 }
554 }
555 serde_json::to_string_pretty(&v).map_err(|e| e.to_string())
556 }
557
558 pub fn augment(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
559 let mut v: Value = serde_json::from_str(data)
560 .or_else(|_| serde_yaml::from_str(data))
561 .map_err(|e| format!("Invalid structured data: {}", e))?;
562
563 if let (Value::Object(map), Some(Value::Object(fields))) = (&mut v, params.get("fields")) {
564 for (k, val) in fields {
565 map.insert(k.clone(), val.clone());
566 }
567 }
568 serde_json::to_string_pretty(&v).map_err(|e| e.to_string())
569 }
570
571 pub fn exclude(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
572 let mut v: Value = serde_json::from_str(data)
573 .or_else(|_| serde_yaml::from_str(data))
574 .map_err(|e| format!("Invalid structured data: {}", e))?;
575
576 let mut drop_keys = Vec::new();
577 if let Some(Value::Array(keys)) = params.get("keys") {
578 for k in keys {
579 if let Some(s) = k.as_str() {
580 drop_keys.push(s.to_string());
581 }
582 }
583 }
584
585 fn prune(val: &mut Value, drop: &[String]) {
586 match val {
587 Value::Object(map) => {
588 for k in drop {
589 map.remove(k);
590 }
591 for (_, child) in map.iter_mut() {
592 prune(child, drop);
593 }
594 }
595 Value::Array(arr) => {
596 for child in arr.iter_mut() {
597 prune(child, drop);
598 }
599 }
600 _ => {}
601 }
602 }
603 prune(&mut v, &drop_keys);
604 serde_json::to_string_pretty(&v).map_err(|e| e.to_string())
605 }
606
607 pub fn invert(data: &str, _params: &HashMap<String, Value>) -> Result<String, String> {
608 let v: Value = serde_json::from_str(data)
609 .or_else(|_| serde_yaml::from_str(data))
610 .map_err(|e| format!("Invalid structured data: {}", e))?;
611
612 match v {
613 Value::Object(map) => {
614 let mut inverted = serde_json::Map::new();
615 for (k, val) in map {
616 let val_str = match val {
617 Value::String(s) => s,
618 other => other.to_string(),
619 };
620 inverted.insert(val_str, Value::String(k));
621 }
622 serde_json::to_string_pretty(&Value::Object(inverted)).map_err(|e| e.to_string())
623 }
624 Value::Array(mut arr) => {
625 arr.reverse();
626 serde_json::to_string_pretty(&Value::Array(arr)).map_err(|e| e.to_string())
627 }
628 other => serde_json::to_string_pretty(&other).map_err(|e| e.to_string()),
629 }
630 }
631
632 pub fn port(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
633 let mut v: Value = serde_json::from_str(data)
634 .or_else(|_| serde_yaml::from_str(data))
635 .map_err(|e| format!("Invalid structured data: {}", e))?;
636
637 if let Some(target_runtime) = params.get("target_runtime").and_then(|r| r.as_str()) {
638 if let Value::Object(map) = &mut v {
639 map.insert("target_runtime".to_string(), Value::String(target_runtime.to_string()));
640 }
641 }
642
643 let target_fmt = params.get("target_format").and_then(|v| v.as_str()).unwrap_or("json").to_lowercase();
644 if target_fmt == "yaml" || target_fmt == "application/yaml" {
645 serde_yaml::to_string(&v).map_err(|e| e.to_string())
646 } else {
647 serde_json::to_string_pretty(&v).map_err(|e| e.to_string())
648 }
649 }
650}
651
652#[derive(Debug, Clone, PartialEq)]
655enum Token {
656 Ident(String),
657 Num(f64),
658 Str(String),
659 Bool(bool),
660 Plus,
661 Minus,
662 Mul,
663 Div,
664 Eq,
665 Neq,
666 Lt,
667 Lte,
668 Gt,
669 Gte,
670 And,
671 Or,
672 Not,
673 LParen,
674 RParen,
675}
676
677fn tokenize_rule(expr: &str) -> Vec<Token> {
678 let mut tokens = Vec::new();
679 let chars: Vec<char> = expr.chars().collect();
680 let mut i = 0;
681
682 while i < chars.len() {
683 let c = chars[i];
684 if c.is_whitespace() {
685 i += 1;
686 continue;
687 }
688
689 if c == '=' && i + 1 < chars.len() && chars[i + 1] == '=' {
690 tokens.push(Token::Eq);
691 i += 2;
692 continue;
693 }
694 if c == '!' && i + 1 < chars.len() && chars[i + 1] == '=' {
695 tokens.push(Token::Neq);
696 i += 2;
697 continue;
698 }
699 if c == '<' && i + 1 < chars.len() && chars[i + 1] == '=' {
700 tokens.push(Token::Lte);
701 i += 2;
702 continue;
703 }
704 if c == '>' && i + 1 < chars.len() && chars[i + 1] == '=' {
705 tokens.push(Token::Gte);
706 i += 2;
707 continue;
708 }
709 if c == '&' && i + 1 < chars.len() && chars[i + 1] == '&' {
710 tokens.push(Token::And);
711 i += 2;
712 continue;
713 }
714 if c == '|' && i + 1 < chars.len() && chars[i + 1] == '|' {
715 tokens.push(Token::Or);
716 i += 2;
717 continue;
718 }
719
720 match c {
721 '+' => { tokens.push(Token::Plus); i += 1; }
722 '-' => { tokens.push(Token::Minus); i += 1; }
723 '*' => { tokens.push(Token::Mul); i += 1; }
724 '/' => { tokens.push(Token::Div); i += 1; }
725 '<' => { tokens.push(Token::Lt); i += 1; }
726 '>' => { tokens.push(Token::Gt); i += 1; }
727 '!' => { tokens.push(Token::Not); i += 1; }
728 '(' => { tokens.push(Token::LParen); i += 1; }
729 ')' => { tokens.push(Token::RParen); i += 1; }
730 '\'' | '"' => {
731 let quote = c;
732 i += 1;
733 let mut s = String::new();
734 while i < chars.len() && chars[i] != quote {
735 s.push(chars[i]);
736 i += 1;
737 }
738 if i < chars.len() { i += 1; }
739 tokens.push(Token::Str(s));
740 }
741 _ if c.is_digit(10) => {
742 let mut num_str = String::new();
743 while i < chars.len() && (chars[i].is_digit(10) || chars[i] == '.') {
744 num_str.push(chars[i]);
745 i += 1;
746 }
747 let n: f64 = num_str.parse().unwrap_or(0.0);
748 tokens.push(Token::Num(n));
749 }
750 _ if c.is_alphabetic() || c == '_' => {
751 let mut ident = String::new();
752 while i < chars.len() && (chars[i].is_alphanumeric() || chars[i] == '_' || chars[i] == '.') {
753 ident.push(chars[i]);
754 i += 1;
755 }
756 match ident.as_str() {
757 "true" | "True" => tokens.push(Token::Bool(true)),
758 "false" | "False" => tokens.push(Token::Bool(false)),
759 "and" => tokens.push(Token::And),
760 "or" => tokens.push(Token::Or),
761 "not" => tokens.push(Token::Not),
762 _ => tokens.push(Token::Ident(ident)),
763 }
764 }
765 _ => { i += 1; }
766 }
767 }
768 tokens
769}
770
771#[derive(Debug, Clone, PartialEq)]
772enum EvalVal {
773 Num(f64),
774 Str(String),
775 Bool(bool),
776 Null,
777}
778
779impl EvalVal {
780 fn as_bool(&self) -> bool {
781 match self {
782 EvalVal::Bool(b) => *b,
783 EvalVal::Num(n) => *n != 0.0,
784 EvalVal::Str(s) => !s.is_empty(),
785 EvalVal::Null => false,
786 }
787 }
788}
789
790pub struct SafeRuleEvaluator;
791
792impl SafeRuleEvaluator {
793 pub fn evaluate(rule: &str, context: &Value) -> bool {
794 let tokens = tokenize_rule(rule);
795 if tokens.is_empty() {
796 return true;
797 }
798 let mut pos = 0;
799 match Self::parse_or(&tokens, &mut pos, context) {
800 Ok(v) => v.as_bool(),
801 Err(_) => false,
802 }
803 }
804
805 fn resolve_path(path: &str, context: &Value) -> EvalVal {
806 let parts: Vec<&str> = path.split('.').collect();
807 let mut curr = context;
808 for part in parts {
809 match curr {
810 Value::Object(map) => {
811 if let Some(val) = map.get(part) {
812 curr = val;
813 } else {
814 return EvalVal::Null;
815 }
816 }
817 _ => return EvalVal::Null,
818 }
819 }
820 match curr {
821 Value::Number(n) => EvalVal::Num(n.as_f64().unwrap_or(0.0)),
822 Value::String(s) => EvalVal::Str(s.clone()),
823 Value::Bool(b) => EvalVal::Bool(*b),
824 Value::Null => EvalVal::Null,
825 Value::Array(a) => EvalVal::Num(a.len() as f64),
826 Value::Object(o) => EvalVal::Num(o.len() as f64),
827 }
828 }
829
830 fn parse_or(tokens: &[Token], pos: &mut usize, ctx: &Value) -> Result<EvalVal, String> {
831 let mut left = Self::parse_and(tokens, pos, ctx)?;
832 while *pos < tokens.len() && tokens[*pos] == Token::Or {
833 *pos += 1;
834 let right = Self::parse_and(tokens, pos, ctx)?;
835 left = EvalVal::Bool(left.as_bool() || right.as_bool());
836 }
837 Ok(left)
838 }
839
840 fn parse_and(tokens: &[Token], pos: &mut usize, ctx: &Value) -> Result<EvalVal, String> {
841 let mut left = Self::parse_comparison(tokens, pos, ctx)?;
842 while *pos < tokens.len() && tokens[*pos] == Token::And {
843 *pos += 1;
844 let right = Self::parse_comparison(tokens, pos, ctx)?;
845 left = EvalVal::Bool(left.as_bool() && right.as_bool());
846 }
847 Ok(left)
848 }
849
850 fn parse_comparison(tokens: &[Token], pos: &mut usize, ctx: &Value) -> Result<EvalVal, String> {
851 let left = Self::parse_additive(tokens, pos, ctx)?;
852 if *pos < tokens.len() {
853 let op = tokens[*pos].clone();
854 match op {
855 Token::Eq | Token::Neq | Token::Lt | Token::Lte | Token::Gt | Token::Gte => {
856 *pos += 1;
857 let right = Self::parse_additive(tokens, pos, ctx)?;
858 let res = match (left, right) {
859 (EvalVal::Num(l), EvalVal::Num(r)) => match op {
860 Token::Eq => (l - r).abs() < 1e-9,
861 Token::Neq => (l - r).abs() >= 1e-9,
862 Token::Lt => l < r,
863 Token::Lte => l <= r,
864 Token::Gt => l > r,
865 Token::Gte => l >= r,
866 _ => false,
867 },
868 (EvalVal::Str(l), EvalVal::Str(r)) => match op {
869 Token::Eq => l == r,
870 Token::Neq => l != r,
871 Token::Lt => l < r,
872 Token::Lte => l <= r,
873 Token::Gt => l > r,
874 Token::Gte => l >= r,
875 _ => false,
876 },
877 (EvalVal::Bool(l), EvalVal::Bool(r)) => match op {
878 Token::Eq => l == r,
879 Token::Neq => l != r,
880 _ => false,
881 },
882 (EvalVal::Num(l), EvalVal::Null) | (EvalVal::Null, EvalVal::Num(l)) => match op {
883 Token::Eq => l == 0.0,
884 Token::Neq => l != 0.0,
885 Token::Lte => l <= 0.0,
886 Token::Lt => l < 0.0,
887 Token::Gte => l >= 0.0,
888 Token::Gt => l > 0.0,
889 _ => false,
890 },
891 _ => match op {
892 Token::Eq => false,
893 Token::Neq => true,
894 _ => false,
895 },
896 };
897 return Ok(EvalVal::Bool(res));
898 }
899 _ => {}
900 }
901 }
902 Ok(left)
903 }
904
905 fn parse_additive(tokens: &[Token], pos: &mut usize, ctx: &Value) -> Result<EvalVal, String> {
906 let mut left = Self::parse_multiplicative(tokens, pos, ctx)?;
907 while *pos < tokens.len() {
908 let op = tokens[*pos].clone();
909 if op == Token::Plus || op == Token::Minus {
910 *pos += 1;
911 let right = Self::parse_multiplicative(tokens, pos, ctx)?;
912 match (left, right) {
913 (EvalVal::Num(l), EvalVal::Num(r)) => {
914 left = EvalVal::Num(if op == Token::Plus { l + r } else { l - r });
915 }
916 (EvalVal::Str(l), EvalVal::Str(r)) => {
917 left = EvalVal::Str(format!("{}{}", l, r));
918 }
919 _ => return Err("Type mismatch in additive op".to_string()),
920 }
921 } else {
922 break;
923 }
924 }
925 Ok(left)
926 }
927
928 fn parse_multiplicative(tokens: &[Token], pos: &mut usize, ctx: &Value) -> Result<EvalVal, String> {
929 let mut left = Self::parse_unary(tokens, pos, ctx)?;
930 while *pos < tokens.len() {
931 let op = tokens[*pos].clone();
932 if op == Token::Mul || op == Token::Div {
933 *pos += 1;
934 let right = Self::parse_unary(tokens, pos, ctx)?;
935 match (left, right) {
936 (EvalVal::Num(l), EvalVal::Num(r)) => {
937 left = EvalVal::Num(if op == Token::Mul { l * r } else { l / r });
938 }
939 _ => return Err("Type mismatch in multiplicative op".to_string()),
940 }
941 } else {
942 break;
943 }
944 }
945 Ok(left)
946 }
947
948 fn parse_unary(tokens: &[Token], pos: &mut usize, ctx: &Value) -> Result<EvalVal, String> {
949 if *pos < tokens.len() {
950 if tokens[*pos] == Token::Not {
951 *pos += 1;
952 let val = Self::parse_unary(tokens, pos, ctx)?;
953 return Ok(EvalVal::Bool(!val.as_bool()));
954 }
955 if tokens[*pos] == Token::Minus {
956 *pos += 1;
957 let val = Self::parse_unary(tokens, pos, ctx)?;
958 if let EvalVal::Num(n) = val {
959 return Ok(EvalVal::Num(-n));
960 }
961 }
962 }
963 Self::parse_primary(tokens, pos, ctx)
964 }
965
966 fn parse_primary(tokens: &[Token], pos: &mut usize, ctx: &Value) -> Result<EvalVal, String> {
967 if *pos >= tokens.len() {
968 return Err("Unexpected end of expression".to_string());
969 }
970 let tok = &tokens[*pos];
971 *pos += 1;
972 match tok {
973 Token::Num(n) => Ok(EvalVal::Num(*n)),
974 Token::Str(s) => Ok(EvalVal::Str(s.clone())),
975 Token::Bool(b) => Ok(EvalVal::Bool(*b)),
976 Token::Ident(id) => Ok(Self::resolve_path(id, ctx)),
977 Token::LParen => {
978 let val = Self::parse_or(tokens, pos, ctx)?;
979 if *pos < tokens.len() && tokens[*pos] == Token::RParen {
980 *pos += 1;
981 Ok(val)
982 } else {
983 Err("Missing closing parenthesis".to_string())
984 }
985 }
986 _ => Err(format!("Unexpected token: {:?}", tok)),
987 }
988 }
989}
990
991pub fn build_item_context(payload: &str) -> Value {
994 let mut ctx = serde_json::Map::new();
995 ctx.insert("size_bytes".to_string(), json!(payload.as_bytes().len()));
996
997 let non_empty_lines: Vec<&str> = payload.lines().filter(|l| !l.trim().is_empty()).collect();
998 ctx.insert("line_count".to_string(), json!(non_empty_lines.len()));
999
1000 if let Some(first_line) = non_empty_lines.first() {
1001 if first_line.contains(',') {
1002 let cols: Vec<String> = first_line.split(',').map(|s| s.trim().to_string()).collect();
1003 ctx.insert("column_count".to_string(), json!(cols.len()));
1004 ctx.insert("columns".to_string(), json!(cols));
1005 let row_count = if non_empty_lines.len() > 1 { non_empty_lines.len() - 1 } else { 0 };
1006 ctx.insert("row_count".to_string(), json!(row_count));
1007 }
1008 }
1009
1010 if let Ok(Value::Object(obj)) = serde_json::from_str::<Value>(payload) {
1011 ctx.insert("key_count".to_string(), json!(obj.len()));
1012 let keys: Vec<String> = obj.keys().cloned().collect();
1013 ctx.insert("keys".to_string(), json!(keys));
1014 for (k, v) in obj {
1015 ctx.insert(k, v);
1016 }
1017 } else if let Ok(Value::Array(arr)) = serde_json::from_str::<Value>(payload) {
1018 ctx.insert("item_count".to_string(), json!(arr.len()));
1019 ctx.insert("row_count".to_string(), json!(arr.len()));
1020 }
1021
1022 Value::Object(ctx)
1023}
1024
1025#[derive(Debug, Clone, Serialize, Deserialize)]
1028pub struct ExecutionResult {
1029 pub status: String,
1030 pub operator: String,
1031 pub outputs: HashMap<String, String>,
1032 pub input_hashes: HashMap<String, String>,
1033 pub output_hashes: HashMap<String, String>,
1034 pub metrics: HashMap<String, Value>,
1035 pub error: Option<String>,
1036}
1037
1038#[derive(Debug, Clone, Serialize, Deserialize)]
1039pub struct Verdict {
1040 pub invariant: String,
1041 pub rule: String,
1042 pub passed: bool,
1043 pub description: Option<String>,
1044}
1045
1046#[derive(Debug, Clone, Serialize, Deserialize)]
1047pub struct VCardReceipt {
1048 pub uri: String,
1049 pub hash: String,
1050 pub payload: Value,
1051}
1052
1053#[derive(Debug, Clone, Serialize, Deserialize)]
1054pub struct HoareSandwichResult {
1055 pub status: String,
1056 pub action_name: String,
1057 pub outputs: HashMap<String, String>,
1058 pub receipt: Option<VCardReceipt>,
1059 pub precondition_verdicts: Vec<Verdict>,
1060 pub postcondition_verdicts: Vec<Verdict>,
1061 pub rollback_occurred: bool,
1062 pub rollback_time_ms: f64,
1063 pub metrics: HashMap<String, Value>,
1064 pub error: Option<String>,
1065}
1066
1067pub struct ActionDispatcher;
1068
1069impl ActionDispatcher {
1070 pub fn execute(
1071 manifest: &ActionManifest,
1072 input_bindings: &HashMap<String, String>,
1073 ) -> ExecutionResult {
1074 let t_start = std::time::Instant::now();
1075 let operator = &manifest.operation.operator;
1076 let params = &manifest.operation.parameters;
1077
1078 let mut input_hashes = HashMap::new();
1079 let mut resolved_inputs = HashMap::new();
1080
1081 for inp in &manifest.inputs {
1082 let val = input_bindings.get(&inp.name)
1083 .or_else(|| inp.uri.as_ref().and_then(|u| input_bindings.get(u)));
1084
1085 if val.is_none() && inp.required {
1086 return ExecutionResult {
1087 status: "failed".to_string(),
1088 operator: operator.to_string(),
1089 outputs: HashMap::new(),
1090 input_hashes,
1091 output_hashes: HashMap::new(),
1092 metrics: HashMap::new(),
1093 error: Some(format!("Required input '{}' could not be resolved", inp.name)),
1094 };
1095 }
1096
1097 if let Some(v) = val {
1098 let h = clm_hash_string(v);
1099 input_hashes.insert(inp.name.clone(), h);
1100 resolved_inputs.insert(inp.name.clone(), v.clone());
1101 }
1102 }
1103
1104 let primary_input = resolved_inputs.values().next().cloned().unwrap_or_default();
1105 let primary_format = manifest.inputs.first().and_then(|i| i.format.clone()).unwrap_or_else(|| "csv".to_string());
1106
1107 let mut outputs = HashMap::new();
1108 let mut output_hashes = HashMap::new();
1109
1110 let run_res: Result<HashMap<String, String>, String> = match primary_format.as_str() {
1111 "csv" | "tabular" => {
1112 match operator {
1113 BaldwinOperator::Split => TabularManipulator::split(&primary_input, params),
1114 BaldwinOperator::Substitute => TabularManipulator::substitute(&primary_input, params).map(|s| {
1115 let mut m = HashMap::new();
1116 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "output".to_string());
1117 m.insert(out_name, s);
1118 m
1119 }),
1120 BaldwinOperator::Augment => TabularManipulator::augment(&primary_input, params).map(|s| {
1121 let mut m = HashMap::new();
1122 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "augmented".to_string());
1123 m.insert(out_name, s);
1124 m
1125 }),
1126 BaldwinOperator::Exclude => TabularManipulator::exclude(&primary_input, params).map(|s| {
1127 let mut m = HashMap::new();
1128 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "sanitized".to_string());
1129 m.insert(out_name, s);
1130 m
1131 }),
1132 BaldwinOperator::Invert => TabularManipulator::invert(&primary_input, params).map(|s| {
1133 let mut m = HashMap::new();
1134 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "inverted".to_string());
1135 m.insert(out_name, s);
1136 m
1137 }),
1138 BaldwinOperator::Port => TabularManipulator::port(&primary_input, params).map(|s| {
1139 let mut m = HashMap::new();
1140 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "ported".to_string());
1141 m.insert(out_name, s);
1142 m
1143 }),
1144 BaldwinOperator::Custom => Ok(HashMap::new()),
1145 }
1146 }
1147 "markdown" | "text" | "md" => {
1148 match operator {
1149 BaldwinOperator::Split => DocumentManipulator::split(&primary_input, params),
1150 BaldwinOperator::Substitute => DocumentManipulator::substitute(&primary_input, params).map(|s| {
1151 let mut m = HashMap::new();
1152 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "substituted".to_string());
1153 m.insert(out_name, s);
1154 m
1155 }),
1156 BaldwinOperator::Augment => DocumentManipulator::augment(&primary_input, params).map(|s| {
1157 let mut m = HashMap::new();
1158 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "augmented".to_string());
1159 m.insert(out_name, s);
1160 m
1161 }),
1162 BaldwinOperator::Exclude => DocumentManipulator::exclude(&primary_input, params).map(|s| {
1163 let mut m = HashMap::new();
1164 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "pruned".to_string());
1165 m.insert(out_name, s);
1166 m
1167 }),
1168 BaldwinOperator::Invert => DocumentManipulator::invert(&primary_input, params).map(|s| {
1169 let mut m = HashMap::new();
1170 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "inverted".to_string());
1171 m.insert(out_name, s);
1172 m
1173 }),
1174 BaldwinOperator::Port => DocumentManipulator::port(&primary_input, params).map(|s| {
1175 let mut m = HashMap::new();
1176 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "ported".to_string());
1177 m.insert(out_name, s);
1178 m
1179 }),
1180 BaldwinOperator::Custom => Ok(HashMap::new()),
1181 }
1182 }
1183 _ => { match operator {
1185 BaldwinOperator::Split => StructuredManipulator::split(&primary_input, params),
1186 BaldwinOperator::Substitute => StructuredManipulator::substitute(&primary_input, params).map(|s| {
1187 let mut m = HashMap::new();
1188 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "substituted".to_string());
1189 m.insert(out_name, s);
1190 m
1191 }),
1192 BaldwinOperator::Augment => StructuredManipulator::augment(&primary_input, params).map(|s| {
1193 let mut m = HashMap::new();
1194 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "augmented".to_string());
1195 m.insert(out_name, s);
1196 m
1197 }),
1198 BaldwinOperator::Exclude => StructuredManipulator::exclude(&primary_input, params).map(|s| {
1199 let mut m = HashMap::new();
1200 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "pruned".to_string());
1201 m.insert(out_name, s);
1202 m
1203 }),
1204 BaldwinOperator::Invert => StructuredManipulator::invert(&primary_input, params).map(|s| {
1205 let mut m = HashMap::new();
1206 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "inverted".to_string());
1207 m.insert(out_name, s);
1208 m
1209 }),
1210 BaldwinOperator::Port => StructuredManipulator::port(&primary_input, params).map(|s| {
1211 let mut m = HashMap::new();
1212 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "ported".to_string());
1213 m.insert(out_name, s);
1214 m
1215 }),
1216 BaldwinOperator::Custom => Ok(HashMap::new()),
1217 }
1218 }
1219 };
1220
1221 match run_res {
1222 Ok(res_map) => {
1223 if manifest.outputs.len() > 1 && res_map.len() > 1 {
1225 for out_spec in &manifest.outputs {
1226 if let Some(val) = res_map.get(&out_spec.name) {
1227 outputs.insert(out_spec.name.clone(), val.clone());
1228 output_hashes.insert(out_spec.name.clone(), clm_hash_string(val));
1229 }
1230 }
1231 } else if let Some(out_spec) = manifest.outputs.first() {
1232 let val = res_map.get(&out_spec.name)
1233 .cloned()
1234 .unwrap_or_else(|| res_map.values().next().cloned().unwrap_or_default());
1235 outputs.insert(out_spec.name.clone(), val.clone());
1236 output_hashes.insert(out_spec.name.clone(), clm_hash_string(&val));
1237 }
1238
1239 let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
1240 let mut metrics = HashMap::new();
1241 metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
1242 metrics.insert("operator".to_string(), json!(operator.to_string()));
1243 metrics.insert("action_name".to_string(), json!(manifest.clm.name));
1244
1245 ExecutionResult {
1246 status: "success".to_string(),
1247 operator: operator.to_string(),
1248 outputs,
1249 input_hashes,
1250 output_hashes,
1251 metrics,
1252 error: None,
1253 }
1254 }
1255 Err(e) => {
1256 let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
1257 let mut metrics = HashMap::new();
1258 metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
1259 ExecutionResult {
1260 status: "failed".to_string(),
1261 operator: operator.to_string(),
1262 outputs: HashMap::new(),
1263 input_hashes,
1264 output_hashes: HashMap::new(),
1265 metrics,
1266 error: Some(e),
1267 }
1268 }
1269 }
1270 }
1271}
1272
1273pub struct HoareSandwichEngine;
1274
1275impl HoareSandwichEngine {
1276 pub fn execute(
1277 manifest: &ActionManifest,
1278 input_bindings: &HashMap<String, String>,
1279 ) -> HoareSandwichResult {
1280 let t_start = std::time::Instant::now();
1281 let action_manifest_val = manifest.to_canonical_json_value();
1282 let action_hash = compute_canonical_hash(&action_manifest_val);
1283
1284 let mut pre_ctx_map = serde_json::Map::new();
1286 for inp in &manifest.inputs {
1287 if let Some(payload) = input_bindings.get(&inp.name) {
1288 let item_ctx = build_item_context(payload);
1289 pre_ctx_map.insert(inp.name.clone(), item_ctx.clone());
1290 if manifest.inputs.len() == 1 || inp.name == "dataset" {
1291 pre_ctx_map.insert("input".to_string(), item_ctx);
1292 }
1293 }
1294 }
1295 let pre_ctx = Value::Object(pre_ctx_map.clone());
1296
1297 let mut pre_verdicts = Vec::new();
1299 for pre in &manifest.preconditions {
1300 let passed = SafeRuleEvaluator::evaluate(&pre.rule, &pre_ctx);
1301 let verdict = Verdict {
1302 invariant: pre.invariant.clone(),
1303 rule: pre.rule.clone(),
1304 passed,
1305 description: pre.description.clone(),
1306 };
1307 pre_verdicts.push(verdict);
1308
1309 if !passed {
1310 let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
1311 let mut metrics = HashMap::new();
1312 metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
1313 return HoareSandwichResult {
1314 status: "failed".to_string(),
1315 action_name: manifest.clm.name.clone(),
1316 outputs: HashMap::new(),
1317 receipt: None,
1318 precondition_verdicts: pre_verdicts,
1319 postcondition_verdicts: Vec::new(),
1320 rollback_occurred: false,
1321 rollback_time_ms: 0.0,
1322 metrics,
1323 error: Some(format!(
1324 "Precondition '{}' violated: '{}' evaluated to false",
1325 pre.invariant, pre.rule
1326 )),
1327 };
1328 }
1329 }
1330
1331 let exec_result = ActionDispatcher::execute(manifest, input_bindings);
1333 if exec_result.status != "success" {
1334 let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
1335 let mut metrics = HashMap::new();
1336 metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
1337 return HoareSandwichResult {
1338 status: "failed".to_string(),
1339 action_name: manifest.clm.name.clone(),
1340 outputs: HashMap::new(),
1341 receipt: None,
1342 precondition_verdicts: pre_verdicts,
1343 postcondition_verdicts: Vec::new(),
1344 rollback_occurred: false,
1345 rollback_time_ms: 0.0,
1346 metrics,
1347 error: exec_result.error,
1348 };
1349 }
1350
1351 let mut post_ctx_map = pre_ctx_map.clone();
1353 let mut out_map = serde_json::Map::new();
1354 for (name, payload) in &exec_result.outputs {
1355 let item_ctx = build_item_context(payload);
1356 out_map.insert(name.clone(), item_ctx);
1357 }
1358 if exec_result.outputs.len() == 1 {
1359 let first_val = out_map.values().next().cloned().unwrap_or(Value::Null);
1360 if let Value::Object(obj) = first_val {
1361 for (k, v) in obj {
1362 out_map.insert(k, v);
1363 }
1364 }
1365 }
1366 post_ctx_map.insert("output".to_string(), Value::Object(out_map));
1367 let post_ctx = Value::Object(post_ctx_map);
1368
1369 let mut post_verdicts = Vec::new();
1371 for post in &manifest.postconditions {
1372 let passed = SafeRuleEvaluator::evaluate(&post.rule, &post_ctx);
1373 let verdict = Verdict {
1374 invariant: post.invariant.clone(),
1375 rule: post.rule.clone(),
1376 passed,
1377 description: post.description.clone(),
1378 };
1379 post_verdicts.push(verdict);
1380
1381 if !passed {
1382 let rb_start = std::time::Instant::now();
1383 let rollback_time_ms = (rb_start.elapsed().as_secs_f64() * 1000.0).max(0.01);
1385 let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
1386 let mut metrics = HashMap::new();
1387 metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
1388 return HoareSandwichResult {
1389 status: "failed".to_string(),
1390 action_name: manifest.clm.name.clone(),
1391 outputs: HashMap::new(),
1392 receipt: None,
1393 precondition_verdicts: pre_verdicts,
1394 postcondition_verdicts: post_verdicts,
1395 rollback_occurred: true,
1396 rollback_time_ms,
1397 metrics,
1398 error: Some(format!(
1399 "Postcondition '{}' violated: '{}' evaluated to false",
1400 post.invariant, post.rule
1401 )),
1402 };
1403 }
1404 }
1405
1406 let pre_verdicts_val = serde_json::to_value(&pre_verdicts).unwrap_or(Value::Null);
1408 let post_verdicts_val = serde_json::to_value(&post_verdicts).unwrap_or(Value::Null);
1409
1410 let pre_digest = compute_canonical_hash(&pre_verdicts_val);
1411 let post_digest = compute_canonical_hash(&post_verdicts_val);
1412 let witness_preimage = format!("{}:{}:{}", pre_digest, action_hash, post_digest);
1413 let witness_hash = clm_hash_string(&witness_preimage);
1414
1415 let receipt_canonical_payload = json!({
1416 "archetype": "VCardReceipt",
1417 "action": {
1418 "name": manifest.clm.name,
1419 "hash": action_hash,
1420 },
1421 "inputs": exec_result.input_hashes,
1422 "outputs": exec_result.output_hashes,
1423 "verification": {
1424 "preconditions": pre_verdicts,
1425 "postconditions": post_verdicts,
1426 "all_passed": true,
1427 },
1428 "witness": witness_hash,
1429 });
1430
1431 let receipt_hash = compute_canonical_hash(&receipt_canonical_payload);
1432 let receipt_uri = format!("mcard://receipts/{}", &receipt_hash[..16]);
1433
1434 let receipt = VCardReceipt {
1435 uri: receipt_uri,
1436 hash: receipt_hash,
1437 payload: receipt_canonical_payload,
1438 };
1439
1440 let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
1441 let mut final_metrics = exec_result.metrics.clone();
1442 final_metrics.insert("hoare_total_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
1443
1444 HoareSandwichResult {
1445 status: "success".to_string(),
1446 action_name: manifest.clm.name.clone(),
1447 outputs: exec_result.outputs,
1448 receipt: Some(receipt),
1449 precondition_verdicts: pre_verdicts,
1450 postcondition_verdicts: post_verdicts,
1451 rollback_occurred: false,
1452 rollback_time_ms: 0.0,
1453 metrics: final_metrics,
1454 error: None,
1455 }
1456 }
1457}