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(['#', '*', '`'], "");
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 && let Some(val) = map.get(ks) {
515 sub.insert(ks.to_string(), val.clone());
516 }
517 }
518 partitions.insert(g_name.clone(), serde_json::to_string_pretty(&Value::Object(sub)).unwrap());
519 }
520 }
521 return Ok(partitions);
522 }
523 let keys: Vec<&String> = map.keys().collect();
524 let mid = keys.len() / 2;
525 let mut part1 = serde_json::Map::new();
526 let mut part2 = serde_json::Map::new();
527 for (i, k) in keys.iter().enumerate() {
528 if i < mid {
529 part1.insert((*k).clone(), map[*k].clone());
530 } else {
531 part2.insert((*k).clone(), map[*k].clone());
532 }
533 }
534 partitions.insert("part_1".to_string(), serde_json::to_string_pretty(&Value::Object(part1)).unwrap());
535 partitions.insert("part_2".to_string(), serde_json::to_string_pretty(&Value::Object(part2)).unwrap());
536 return Ok(partitions);
537 }
538 partitions.insert("all".to_string(), data.to_string());
539 Ok(partitions)
540 }
541
542 pub fn substitute(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
543 let mut v: Value = serde_json::from_str(data)
544 .or_else(|_| serde_yaml::from_str(data))
545 .map_err(|e| format!("Invalid structured data: {}", e))?;
546
547 if let (Value::Object(map), Some(Value::Object(replacements))) = (&mut v, params.get("replacements")) {
548 for (k, new_val) in replacements {
549 if map.contains_key(k) {
550 map.insert(k.clone(), new_val.clone());
551 }
552 }
553 }
554 serde_json::to_string_pretty(&v).map_err(|e| e.to_string())
555 }
556
557 pub fn augment(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
558 let mut v: Value = serde_json::from_str(data)
559 .or_else(|_| serde_yaml::from_str(data))
560 .map_err(|e| format!("Invalid structured data: {}", e))?;
561
562 if let (Value::Object(map), Some(Value::Object(fields))) = (&mut v, params.get("fields")) {
563 for (k, val) in fields {
564 map.insert(k.clone(), val.clone());
565 }
566 }
567 serde_json::to_string_pretty(&v).map_err(|e| e.to_string())
568 }
569
570 pub fn exclude(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
571 let mut v: Value = serde_json::from_str(data)
572 .or_else(|_| serde_yaml::from_str(data))
573 .map_err(|e| format!("Invalid structured data: {}", e))?;
574
575 let mut drop_keys = Vec::new();
576 if let Some(Value::Array(keys)) = params.get("keys") {
577 for k in keys {
578 if let Some(s) = k.as_str() {
579 drop_keys.push(s.to_string());
580 }
581 }
582 }
583
584 fn prune(val: &mut Value, drop: &[String]) {
585 match val {
586 Value::Object(map) => {
587 for k in drop {
588 map.remove(k);
589 }
590 for (_, child) in map.iter_mut() {
591 prune(child, drop);
592 }
593 }
594 Value::Array(arr) => {
595 for child in arr.iter_mut() {
596 prune(child, drop);
597 }
598 }
599 _ => {}
600 }
601 }
602 prune(&mut v, &drop_keys);
603 serde_json::to_string_pretty(&v).map_err(|e| e.to_string())
604 }
605
606 pub fn invert(data: &str, _params: &HashMap<String, Value>) -> Result<String, String> {
607 let v: Value = serde_json::from_str(data)
608 .or_else(|_| serde_yaml::from_str(data))
609 .map_err(|e| format!("Invalid structured data: {}", e))?;
610
611 match v {
612 Value::Object(map) => {
613 let mut inverted = serde_json::Map::new();
614 for (k, val) in map {
615 let val_str = match val {
616 Value::String(s) => s,
617 other => other.to_string(),
618 };
619 inverted.insert(val_str, Value::String(k));
620 }
621 serde_json::to_string_pretty(&Value::Object(inverted)).map_err(|e| e.to_string())
622 }
623 Value::Array(mut arr) => {
624 arr.reverse();
625 serde_json::to_string_pretty(&Value::Array(arr)).map_err(|e| e.to_string())
626 }
627 other => serde_json::to_string_pretty(&other).map_err(|e| e.to_string()),
628 }
629 }
630
631 pub fn port(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
632 let mut v: Value = serde_json::from_str(data)
633 .or_else(|_| serde_yaml::from_str(data))
634 .map_err(|e| format!("Invalid structured data: {}", e))?;
635
636 if let Some(target_runtime) = params.get("target_runtime").and_then(|r| r.as_str())
637 && let Value::Object(map) = &mut v {
638 map.insert("target_runtime".to_string(), Value::String(target_runtime.to_string()));
639 }
640
641 let target_fmt = params.get("target_format").and_then(|v| v.as_str()).unwrap_or("json").to_lowercase();
642 if target_fmt == "yaml" || target_fmt == "application/yaml" {
643 serde_yaml::to_string(&v).map_err(|e| e.to_string())
644 } else {
645 serde_json::to_string_pretty(&v).map_err(|e| e.to_string())
646 }
647 }
648}
649
650#[derive(Debug, Clone, PartialEq)]
653enum Token {
654 Ident(String),
655 Num(f64),
656 Str(String),
657 Bool(bool),
658 Plus,
659 Minus,
660 Mul,
661 Div,
662 Eq,
663 Neq,
664 Lt,
665 Lte,
666 Gt,
667 Gte,
668 And,
669 Or,
670 Not,
671 LParen,
672 RParen,
673}
674
675fn tokenize_rule(expr: &str) -> Vec<Token> {
676 let mut tokens = Vec::new();
677 let chars: Vec<char> = expr.chars().collect();
678 let mut i = 0;
679
680 while i < chars.len() {
681 let c = chars[i];
682 if c.is_whitespace() {
683 i += 1;
684 continue;
685 }
686
687 if c == '=' && i + 1 < chars.len() && chars[i + 1] == '=' {
688 tokens.push(Token::Eq);
689 i += 2;
690 continue;
691 }
692 if c == '!' && i + 1 < chars.len() && chars[i + 1] == '=' {
693 tokens.push(Token::Neq);
694 i += 2;
695 continue;
696 }
697 if c == '<' && i + 1 < chars.len() && chars[i + 1] == '=' {
698 tokens.push(Token::Lte);
699 i += 2;
700 continue;
701 }
702 if c == '>' && i + 1 < chars.len() && chars[i + 1] == '=' {
703 tokens.push(Token::Gte);
704 i += 2;
705 continue;
706 }
707 if c == '&' && i + 1 < chars.len() && chars[i + 1] == '&' {
708 tokens.push(Token::And);
709 i += 2;
710 continue;
711 }
712 if c == '|' && i + 1 < chars.len() && chars[i + 1] == '|' {
713 tokens.push(Token::Or);
714 i += 2;
715 continue;
716 }
717
718 match c {
719 '+' => { tokens.push(Token::Plus); i += 1; }
720 '-' => { tokens.push(Token::Minus); i += 1; }
721 '*' => { tokens.push(Token::Mul); i += 1; }
722 '/' => { tokens.push(Token::Div); i += 1; }
723 '<' => { tokens.push(Token::Lt); i += 1; }
724 '>' => { tokens.push(Token::Gt); i += 1; }
725 '!' => { tokens.push(Token::Not); i += 1; }
726 '(' => { tokens.push(Token::LParen); i += 1; }
727 ')' => { tokens.push(Token::RParen); i += 1; }
728 '\'' | '"' => {
729 let quote = c;
730 i += 1;
731 let mut s = String::new();
732 while i < chars.len() && chars[i] != quote {
733 s.push(chars[i]);
734 i += 1;
735 }
736 if i < chars.len() { i += 1; }
737 tokens.push(Token::Str(s));
738 }
739 _ if c.is_ascii_digit() => {
740 let mut num_str = String::new();
741 while i < chars.len() && (chars[i].is_ascii_digit() || chars[i] == '.') {
742 num_str.push(chars[i]);
743 i += 1;
744 }
745 let n: f64 = num_str.parse().unwrap_or(0.0);
746 tokens.push(Token::Num(n));
747 }
748 _ if c.is_alphabetic() || c == '_' => {
749 let mut ident = String::new();
750 while i < chars.len() && (chars[i].is_alphanumeric() || chars[i] == '_' || chars[i] == '.') {
751 ident.push(chars[i]);
752 i += 1;
753 }
754 match ident.as_str() {
755 "true" | "True" => tokens.push(Token::Bool(true)),
756 "false" | "False" => tokens.push(Token::Bool(false)),
757 "and" => tokens.push(Token::And),
758 "or" => tokens.push(Token::Or),
759 "not" => tokens.push(Token::Not),
760 _ => tokens.push(Token::Ident(ident)),
761 }
762 }
763 _ => { i += 1; }
764 }
765 }
766 tokens
767}
768
769#[derive(Debug, Clone, PartialEq)]
770enum EvalVal {
771 Num(f64),
772 Str(String),
773 Bool(bool),
774 Null,
775}
776
777impl EvalVal {
778 fn as_bool(&self) -> bool {
779 match self {
780 EvalVal::Bool(b) => *b,
781 EvalVal::Num(n) => *n != 0.0,
782 EvalVal::Str(s) => !s.is_empty(),
783 EvalVal::Null => false,
784 }
785 }
786}
787
788pub struct SafeRuleEvaluator;
789
790impl SafeRuleEvaluator {
791 pub fn evaluate(rule: &str, context: &Value) -> bool {
792 let tokens = tokenize_rule(rule);
793 if tokens.is_empty() {
794 return true;
795 }
796 let mut pos = 0;
797 match Self::parse_or(&tokens, &mut pos, context) {
798 Ok(v) => v.as_bool(),
799 Err(_) => false,
800 }
801 }
802
803 fn resolve_path(path: &str, context: &Value) -> EvalVal {
804 let parts: Vec<&str> = path.split('.').collect();
805 let mut curr = context;
806 for part in parts {
807 match curr {
808 Value::Object(map) => {
809 if let Some(val) = map.get(part) {
810 curr = val;
811 } else {
812 return EvalVal::Null;
813 }
814 }
815 _ => return EvalVal::Null,
816 }
817 }
818 match curr {
819 Value::Number(n) => EvalVal::Num(n.as_f64().unwrap_or(0.0)),
820 Value::String(s) => EvalVal::Str(s.clone()),
821 Value::Bool(b) => EvalVal::Bool(*b),
822 Value::Null => EvalVal::Null,
823 Value::Array(a) => EvalVal::Num(a.len() as f64),
824 Value::Object(o) => EvalVal::Num(o.len() as f64),
825 }
826 }
827
828 fn parse_or(tokens: &[Token], pos: &mut usize, ctx: &Value) -> Result<EvalVal, String> {
829 let mut left = Self::parse_and(tokens, pos, ctx)?;
830 while *pos < tokens.len() && tokens[*pos] == Token::Or {
831 *pos += 1;
832 let right = Self::parse_and(tokens, pos, ctx)?;
833 left = EvalVal::Bool(left.as_bool() || right.as_bool());
834 }
835 Ok(left)
836 }
837
838 fn parse_and(tokens: &[Token], pos: &mut usize, ctx: &Value) -> Result<EvalVal, String> {
839 let mut left = Self::parse_comparison(tokens, pos, ctx)?;
840 while *pos < tokens.len() && tokens[*pos] == Token::And {
841 *pos += 1;
842 let right = Self::parse_comparison(tokens, pos, ctx)?;
843 left = EvalVal::Bool(left.as_bool() && right.as_bool());
844 }
845 Ok(left)
846 }
847
848 fn parse_comparison(tokens: &[Token], pos: &mut usize, ctx: &Value) -> Result<EvalVal, String> {
849 let left = Self::parse_additive(tokens, pos, ctx)?;
850 if *pos < tokens.len() {
851 let op = tokens[*pos].clone();
852 match op {
853 Token::Eq | Token::Neq | Token::Lt | Token::Lte | Token::Gt | Token::Gte => {
854 *pos += 1;
855 let right = Self::parse_additive(tokens, pos, ctx)?;
856 let res = match (left, right) {
857 (EvalVal::Num(l), EvalVal::Num(r)) => match op {
858 Token::Eq => (l - r).abs() < 1e-9,
859 Token::Neq => (l - r).abs() >= 1e-9,
860 Token::Lt => l < r,
861 Token::Lte => l <= r,
862 Token::Gt => l > r,
863 Token::Gte => l >= r,
864 _ => false,
865 },
866 (EvalVal::Str(l), EvalVal::Str(r)) => match op {
867 Token::Eq => l == r,
868 Token::Neq => l != r,
869 Token::Lt => l < r,
870 Token::Lte => l <= r,
871 Token::Gt => l > r,
872 Token::Gte => l >= r,
873 _ => false,
874 },
875 (EvalVal::Bool(l), EvalVal::Bool(r)) => match op {
876 Token::Eq => l == r,
877 Token::Neq => l != r,
878 _ => false,
879 },
880 (EvalVal::Num(l), EvalVal::Null) | (EvalVal::Null, EvalVal::Num(l)) => match op {
881 Token::Eq => l == 0.0,
882 Token::Neq => l != 0.0,
883 Token::Lte => l <= 0.0,
884 Token::Lt => l < 0.0,
885 Token::Gte => l >= 0.0,
886 Token::Gt => l > 0.0,
887 _ => false,
888 },
889 _ => match op {
890 Token::Eq => false,
891 Token::Neq => true,
892 _ => false,
893 },
894 };
895 return Ok(EvalVal::Bool(res));
896 }
897 _ => {}
898 }
899 }
900 Ok(left)
901 }
902
903 fn parse_additive(tokens: &[Token], pos: &mut usize, ctx: &Value) -> Result<EvalVal, String> {
904 let mut left = Self::parse_multiplicative(tokens, pos, ctx)?;
905 while *pos < tokens.len() {
906 let op = tokens[*pos].clone();
907 if op == Token::Plus || op == Token::Minus {
908 *pos += 1;
909 let right = Self::parse_multiplicative(tokens, pos, ctx)?;
910 match (left, right) {
911 (EvalVal::Num(l), EvalVal::Num(r)) => {
912 left = EvalVal::Num(if op == Token::Plus { l + r } else { l - r });
913 }
914 (EvalVal::Str(l), EvalVal::Str(r)) => {
915 left = EvalVal::Str(format!("{}{}", l, r));
916 }
917 _ => return Err("Type mismatch in additive op".to_string()),
918 }
919 } else {
920 break;
921 }
922 }
923 Ok(left)
924 }
925
926 fn parse_multiplicative(tokens: &[Token], pos: &mut usize, ctx: &Value) -> Result<EvalVal, String> {
927 let mut left = Self::parse_unary(tokens, pos, ctx)?;
928 while *pos < tokens.len() {
929 let op = tokens[*pos].clone();
930 if op == Token::Mul || op == Token::Div {
931 *pos += 1;
932 let right = Self::parse_unary(tokens, pos, ctx)?;
933 match (left, right) {
934 (EvalVal::Num(l), EvalVal::Num(r)) => {
935 left = EvalVal::Num(if op == Token::Mul { l * r } else { l / r });
936 }
937 _ => return Err("Type mismatch in multiplicative op".to_string()),
938 }
939 } else {
940 break;
941 }
942 }
943 Ok(left)
944 }
945
946 fn parse_unary(tokens: &[Token], pos: &mut usize, ctx: &Value) -> Result<EvalVal, String> {
947 if *pos < tokens.len() {
948 if tokens[*pos] == Token::Not {
949 *pos += 1;
950 let val = Self::parse_unary(tokens, pos, ctx)?;
951 return Ok(EvalVal::Bool(!val.as_bool()));
952 }
953 if tokens[*pos] == Token::Minus {
954 *pos += 1;
955 let val = Self::parse_unary(tokens, pos, ctx)?;
956 if let EvalVal::Num(n) = val {
957 return Ok(EvalVal::Num(-n));
958 }
959 }
960 }
961 Self::parse_primary(tokens, pos, ctx)
962 }
963
964 fn parse_primary(tokens: &[Token], pos: &mut usize, ctx: &Value) -> Result<EvalVal, String> {
965 if *pos >= tokens.len() {
966 return Err("Unexpected end of expression".to_string());
967 }
968 let tok = &tokens[*pos];
969 *pos += 1;
970 match tok {
971 Token::Num(n) => Ok(EvalVal::Num(*n)),
972 Token::Str(s) => Ok(EvalVal::Str(s.clone())),
973 Token::Bool(b) => Ok(EvalVal::Bool(*b)),
974 Token::Ident(id) => Ok(Self::resolve_path(id, ctx)),
975 Token::LParen => {
976 let val = Self::parse_or(tokens, pos, ctx)?;
977 if *pos < tokens.len() && tokens[*pos] == Token::RParen {
978 *pos += 1;
979 Ok(val)
980 } else {
981 Err("Missing closing parenthesis".to_string())
982 }
983 }
984 _ => Err(format!("Unexpected token: {:?}", tok)),
985 }
986 }
987}
988
989pub fn build_item_context(payload: &str) -> Value {
992 let mut ctx = serde_json::Map::new();
993 ctx.insert("size_bytes".to_string(), json!(payload.len()));
994
995 let non_empty_lines: Vec<&str> = payload.lines().filter(|l| !l.trim().is_empty()).collect();
996 ctx.insert("line_count".to_string(), json!(non_empty_lines.len()));
997
998 if let Some(first_line) = non_empty_lines.first()
999 && first_line.contains(',') {
1000 let cols: Vec<String> = first_line.split(',').map(|s| s.trim().to_string()).collect();
1001 ctx.insert("column_count".to_string(), json!(cols.len()));
1002 ctx.insert("columns".to_string(), json!(cols));
1003 let row_count = if non_empty_lines.len() > 1 { non_empty_lines.len() - 1 } else { 0 };
1004 ctx.insert("row_count".to_string(), json!(row_count));
1005 }
1006
1007 if let Ok(Value::Object(obj)) = serde_json::from_str::<Value>(payload) {
1008 ctx.insert("key_count".to_string(), json!(obj.len()));
1009 let keys: Vec<String> = obj.keys().cloned().collect();
1010 ctx.insert("keys".to_string(), json!(keys));
1011 for (k, v) in obj {
1012 ctx.insert(k, v);
1013 }
1014 } else if let Ok(Value::Array(arr)) = serde_json::from_str::<Value>(payload) {
1015 ctx.insert("item_count".to_string(), json!(arr.len()));
1016 ctx.insert("row_count".to_string(), json!(arr.len()));
1017 }
1018
1019 Value::Object(ctx)
1020}
1021
1022#[derive(Debug, Clone, Serialize, Deserialize)]
1025pub struct ExecutionResult {
1026 pub status: String,
1027 pub operator: String,
1028 pub outputs: HashMap<String, String>,
1029 pub input_hashes: HashMap<String, String>,
1030 pub output_hashes: HashMap<String, String>,
1031 pub metrics: HashMap<String, Value>,
1032 pub error: Option<String>,
1033}
1034
1035#[derive(Debug, Clone, Serialize, Deserialize)]
1036pub struct Verdict {
1037 pub invariant: String,
1038 pub rule: String,
1039 pub passed: bool,
1040 pub description: Option<String>,
1041}
1042
1043#[derive(Debug, Clone, Serialize, Deserialize)]
1044pub struct VCardReceipt {
1045 pub uri: String,
1046 pub hash: String,
1047 pub payload: Value,
1048}
1049
1050#[derive(Debug, Clone, Serialize, Deserialize)]
1051pub struct HoareSandwichResult {
1052 pub status: String,
1053 pub action_name: String,
1054 pub outputs: HashMap<String, String>,
1055 pub receipt: Option<VCardReceipt>,
1056 pub precondition_verdicts: Vec<Verdict>,
1057 pub postcondition_verdicts: Vec<Verdict>,
1058 pub rollback_occurred: bool,
1059 pub rollback_time_ms: f64,
1060 pub metrics: HashMap<String, Value>,
1061 pub error: Option<String>,
1062}
1063
1064pub struct ActionDispatcher;
1065
1066impl ActionDispatcher {
1067 pub fn execute(
1068 manifest: &ActionManifest,
1069 input_bindings: &HashMap<String, String>,
1070 ) -> ExecutionResult {
1071 let t_start = std::time::Instant::now();
1072 let operator = &manifest.operation.operator;
1073 let params = &manifest.operation.parameters;
1074
1075 let mut input_hashes = HashMap::new();
1076 let mut resolved_inputs = HashMap::new();
1077
1078 for inp in &manifest.inputs {
1079 let val = input_bindings.get(&inp.name)
1080 .or_else(|| inp.uri.as_ref().and_then(|u| input_bindings.get(u)));
1081
1082 if val.is_none() && inp.required {
1083 return ExecutionResult {
1084 status: "failed".to_string(),
1085 operator: operator.to_string(),
1086 outputs: HashMap::new(),
1087 input_hashes,
1088 output_hashes: HashMap::new(),
1089 metrics: HashMap::new(),
1090 error: Some(format!("Required input '{}' could not be resolved", inp.name)),
1091 };
1092 }
1093
1094 if let Some(v) = val {
1095 let h = clm_hash_string(v);
1096 input_hashes.insert(inp.name.clone(), h);
1097 resolved_inputs.insert(inp.name.clone(), v.clone());
1098 }
1099 }
1100
1101 let primary_input = resolved_inputs.values().next().cloned().unwrap_or_default();
1102 let primary_format = manifest.inputs.first().and_then(|i| i.format.clone()).unwrap_or_else(|| "csv".to_string());
1103
1104 let mut outputs = HashMap::new();
1105 let mut output_hashes = HashMap::new();
1106
1107 let run_res: Result<HashMap<String, String>, String> = match primary_format.as_str() {
1108 "csv" | "tabular" => {
1109 match operator {
1110 BaldwinOperator::Split => TabularManipulator::split(&primary_input, params),
1111 BaldwinOperator::Substitute => TabularManipulator::substitute(&primary_input, params).map(|s| {
1112 let mut m = HashMap::new();
1113 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "output".to_string());
1114 m.insert(out_name, s);
1115 m
1116 }),
1117 BaldwinOperator::Augment => TabularManipulator::augment(&primary_input, params).map(|s| {
1118 let mut m = HashMap::new();
1119 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "augmented".to_string());
1120 m.insert(out_name, s);
1121 m
1122 }),
1123 BaldwinOperator::Exclude => TabularManipulator::exclude(&primary_input, params).map(|s| {
1124 let mut m = HashMap::new();
1125 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "sanitized".to_string());
1126 m.insert(out_name, s);
1127 m
1128 }),
1129 BaldwinOperator::Invert => TabularManipulator::invert(&primary_input, params).map(|s| {
1130 let mut m = HashMap::new();
1131 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "inverted".to_string());
1132 m.insert(out_name, s);
1133 m
1134 }),
1135 BaldwinOperator::Port => TabularManipulator::port(&primary_input, params).map(|s| {
1136 let mut m = HashMap::new();
1137 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "ported".to_string());
1138 m.insert(out_name, s);
1139 m
1140 }),
1141 BaldwinOperator::Custom => Ok(HashMap::new()),
1142 }
1143 }
1144 "markdown" | "text" | "md" => {
1145 match operator {
1146 BaldwinOperator::Split => DocumentManipulator::split(&primary_input, params),
1147 BaldwinOperator::Substitute => DocumentManipulator::substitute(&primary_input, params).map(|s| {
1148 let mut m = HashMap::new();
1149 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "substituted".to_string());
1150 m.insert(out_name, s);
1151 m
1152 }),
1153 BaldwinOperator::Augment => DocumentManipulator::augment(&primary_input, params).map(|s| {
1154 let mut m = HashMap::new();
1155 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "augmented".to_string());
1156 m.insert(out_name, s);
1157 m
1158 }),
1159 BaldwinOperator::Exclude => DocumentManipulator::exclude(&primary_input, params).map(|s| {
1160 let mut m = HashMap::new();
1161 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "pruned".to_string());
1162 m.insert(out_name, s);
1163 m
1164 }),
1165 BaldwinOperator::Invert => DocumentManipulator::invert(&primary_input, params).map(|s| {
1166 let mut m = HashMap::new();
1167 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "inverted".to_string());
1168 m.insert(out_name, s);
1169 m
1170 }),
1171 BaldwinOperator::Port => DocumentManipulator::port(&primary_input, params).map(|s| {
1172 let mut m = HashMap::new();
1173 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "ported".to_string());
1174 m.insert(out_name, s);
1175 m
1176 }),
1177 BaldwinOperator::Custom => Ok(HashMap::new()),
1178 }
1179 }
1180 _ => { match operator {
1182 BaldwinOperator::Split => StructuredManipulator::split(&primary_input, params),
1183 BaldwinOperator::Substitute => StructuredManipulator::substitute(&primary_input, params).map(|s| {
1184 let mut m = HashMap::new();
1185 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "substituted".to_string());
1186 m.insert(out_name, s);
1187 m
1188 }),
1189 BaldwinOperator::Augment => StructuredManipulator::augment(&primary_input, params).map(|s| {
1190 let mut m = HashMap::new();
1191 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "augmented".to_string());
1192 m.insert(out_name, s);
1193 m
1194 }),
1195 BaldwinOperator::Exclude => StructuredManipulator::exclude(&primary_input, params).map(|s| {
1196 let mut m = HashMap::new();
1197 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "pruned".to_string());
1198 m.insert(out_name, s);
1199 m
1200 }),
1201 BaldwinOperator::Invert => StructuredManipulator::invert(&primary_input, params).map(|s| {
1202 let mut m = HashMap::new();
1203 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "inverted".to_string());
1204 m.insert(out_name, s);
1205 m
1206 }),
1207 BaldwinOperator::Port => StructuredManipulator::port(&primary_input, params).map(|s| {
1208 let mut m = HashMap::new();
1209 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "ported".to_string());
1210 m.insert(out_name, s);
1211 m
1212 }),
1213 BaldwinOperator::Custom => Ok(HashMap::new()),
1214 }
1215 }
1216 };
1217
1218 match run_res {
1219 Ok(res_map) => {
1220 if manifest.outputs.len() > 1 && res_map.len() > 1 {
1222 for out_spec in &manifest.outputs {
1223 if let Some(val) = res_map.get(&out_spec.name) {
1224 outputs.insert(out_spec.name.clone(), val.clone());
1225 output_hashes.insert(out_spec.name.clone(), clm_hash_string(val));
1226 }
1227 }
1228 } else if let Some(out_spec) = manifest.outputs.first() {
1229 let val = res_map.get(&out_spec.name)
1230 .cloned()
1231 .unwrap_or_else(|| res_map.values().next().cloned().unwrap_or_default());
1232 outputs.insert(out_spec.name.clone(), val.clone());
1233 output_hashes.insert(out_spec.name.clone(), clm_hash_string(&val));
1234 }
1235
1236 let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
1237 let mut metrics = HashMap::new();
1238 metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
1239 metrics.insert("operator".to_string(), json!(operator.to_string()));
1240 metrics.insert("action_name".to_string(), json!(manifest.clm.name));
1241
1242 ExecutionResult {
1243 status: "success".to_string(),
1244 operator: operator.to_string(),
1245 outputs,
1246 input_hashes,
1247 output_hashes,
1248 metrics,
1249 error: None,
1250 }
1251 }
1252 Err(e) => {
1253 let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
1254 let mut metrics = HashMap::new();
1255 metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
1256 ExecutionResult {
1257 status: "failed".to_string(),
1258 operator: operator.to_string(),
1259 outputs: HashMap::new(),
1260 input_hashes,
1261 output_hashes: HashMap::new(),
1262 metrics,
1263 error: Some(e),
1264 }
1265 }
1266 }
1267 }
1268}
1269
1270pub struct HoareSandwichEngine;
1271
1272impl HoareSandwichEngine {
1273 pub fn execute(
1274 manifest: &ActionManifest,
1275 input_bindings: &HashMap<String, String>,
1276 ) -> HoareSandwichResult {
1277 let t_start = std::time::Instant::now();
1278 let action_manifest_val = manifest.to_canonical_json_value();
1279 let action_hash = compute_canonical_hash(&action_manifest_val);
1280
1281 let mut pre_ctx_map = serde_json::Map::new();
1283 for inp in &manifest.inputs {
1284 if let Some(payload) = input_bindings.get(&inp.name) {
1285 let item_ctx = build_item_context(payload);
1286 pre_ctx_map.insert(inp.name.clone(), item_ctx.clone());
1287 if manifest.inputs.len() == 1 || inp.name == "dataset" {
1288 pre_ctx_map.insert("input".to_string(), item_ctx);
1289 }
1290 }
1291 }
1292 let pre_ctx = Value::Object(pre_ctx_map.clone());
1293
1294 let mut pre_verdicts = Vec::new();
1296 for pre in &manifest.preconditions {
1297 let passed = SafeRuleEvaluator::evaluate(&pre.rule, &pre_ctx);
1298 let verdict = Verdict {
1299 invariant: pre.invariant.clone(),
1300 rule: pre.rule.clone(),
1301 passed,
1302 description: pre.description.clone(),
1303 };
1304 pre_verdicts.push(verdict);
1305
1306 if !passed {
1307 let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
1308 let mut metrics = HashMap::new();
1309 metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
1310 return HoareSandwichResult {
1311 status: "failed".to_string(),
1312 action_name: manifest.clm.name.clone(),
1313 outputs: HashMap::new(),
1314 receipt: None,
1315 precondition_verdicts: pre_verdicts,
1316 postcondition_verdicts: Vec::new(),
1317 rollback_occurred: false,
1318 rollback_time_ms: 0.0,
1319 metrics,
1320 error: Some(format!(
1321 "Precondition '{}' violated: '{}' evaluated to false",
1322 pre.invariant, pre.rule
1323 )),
1324 };
1325 }
1326 }
1327
1328 let exec_result = ActionDispatcher::execute(manifest, input_bindings);
1330 if exec_result.status != "success" {
1331 let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
1332 let mut metrics = HashMap::new();
1333 metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
1334 return HoareSandwichResult {
1335 status: "failed".to_string(),
1336 action_name: manifest.clm.name.clone(),
1337 outputs: HashMap::new(),
1338 receipt: None,
1339 precondition_verdicts: pre_verdicts,
1340 postcondition_verdicts: Vec::new(),
1341 rollback_occurred: false,
1342 rollback_time_ms: 0.0,
1343 metrics,
1344 error: exec_result.error,
1345 };
1346 }
1347
1348 let mut post_ctx_map = pre_ctx_map.clone();
1350 let mut out_map = serde_json::Map::new();
1351 for (name, payload) in &exec_result.outputs {
1352 let item_ctx = build_item_context(payload);
1353 out_map.insert(name.clone(), item_ctx);
1354 }
1355 if exec_result.outputs.len() == 1 {
1356 let first_val = out_map.values().next().cloned().unwrap_or(Value::Null);
1357 if let Value::Object(obj) = first_val {
1358 for (k, v) in obj {
1359 out_map.insert(k, v);
1360 }
1361 }
1362 }
1363 post_ctx_map.insert("output".to_string(), Value::Object(out_map));
1364 let post_ctx = Value::Object(post_ctx_map);
1365
1366 let mut post_verdicts = Vec::new();
1368 for post in &manifest.postconditions {
1369 let passed = SafeRuleEvaluator::evaluate(&post.rule, &post_ctx);
1370 let verdict = Verdict {
1371 invariant: post.invariant.clone(),
1372 rule: post.rule.clone(),
1373 passed,
1374 description: post.description.clone(),
1375 };
1376 post_verdicts.push(verdict);
1377
1378 if !passed {
1379 let rb_start = std::time::Instant::now();
1380 let rollback_time_ms = (rb_start.elapsed().as_secs_f64() * 1000.0).max(0.01);
1382 let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
1383 let mut metrics = HashMap::new();
1384 metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
1385 return HoareSandwichResult {
1386 status: "failed".to_string(),
1387 action_name: manifest.clm.name.clone(),
1388 outputs: HashMap::new(),
1389 receipt: None,
1390 precondition_verdicts: pre_verdicts,
1391 postcondition_verdicts: post_verdicts,
1392 rollback_occurred: true,
1393 rollback_time_ms,
1394 metrics,
1395 error: Some(format!(
1396 "Postcondition '{}' violated: '{}' evaluated to false",
1397 post.invariant, post.rule
1398 )),
1399 };
1400 }
1401 }
1402
1403 let pre_verdicts_val = serde_json::to_value(&pre_verdicts).unwrap_or(Value::Null);
1405 let post_verdicts_val = serde_json::to_value(&post_verdicts).unwrap_or(Value::Null);
1406
1407 let pre_digest = compute_canonical_hash(&pre_verdicts_val);
1408 let post_digest = compute_canonical_hash(&post_verdicts_val);
1409 let witness_preimage = format!("{}:{}:{}", pre_digest, action_hash, post_digest);
1410 let witness_hash = clm_hash_string(&witness_preimage);
1411
1412 let receipt_canonical_payload = json!({
1413 "archetype": "VCardReceipt",
1414 "action": {
1415 "name": manifest.clm.name,
1416 "hash": action_hash,
1417 },
1418 "inputs": exec_result.input_hashes,
1419 "outputs": exec_result.output_hashes,
1420 "verification": {
1421 "preconditions": pre_verdicts,
1422 "postconditions": post_verdicts,
1423 "all_passed": true,
1424 },
1425 "witness": witness_hash,
1426 });
1427
1428 let receipt_hash = compute_canonical_hash(&receipt_canonical_payload);
1429 let receipt_uri = format!("mcard://receipts/{}", &receipt_hash[..16]);
1430
1431 let receipt = VCardReceipt {
1432 uri: receipt_uri,
1433 hash: receipt_hash,
1434 payload: receipt_canonical_payload,
1435 };
1436
1437 let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
1438 let mut final_metrics = exec_result.metrics.clone();
1439 final_metrics.insert("hoare_total_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
1440
1441 HoareSandwichResult {
1442 status: "success".to_string(),
1443 action_name: manifest.clm.name.clone(),
1444 outputs: exec_result.outputs,
1445 receipt: Some(receipt),
1446 precondition_verdicts: pre_verdicts,
1447 postcondition_verdicts: post_verdicts,
1448 rollback_occurred: false,
1449 rollback_time_ms: 0.0,
1450 metrics: final_metrics,
1451 error: None,
1452 }
1453 }
1454}