Skip to main content

clm_rust_core/layer1/
action.rs

1//! Layer 1: Declarative Action Manifest Engine & Baldwin Modularity Manipulators
2//! Canonical Path: kernel/clm_rust_core/src/layer1/action.rs
3
4use std::collections::{BTreeMap, HashMap};
5use std::path::Path;
6use serde::{Deserialize, Serialize};
7use serde_json::{json, Value};
8
9/// Format of data processed by an Action
10#[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/// Baldwin modularity operators (Baldwin & Clark, 2000)
23#[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
166// ── Canonical Hashing Helpers ────────────────────────────────────────────────
167
168pub 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
198// ── Modality Manipulators ───────────────────────────────────────────────────
199
200pub 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        // plain text: strip #, *, `
493        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// ── Rule / Invariant Evaluator ──────────────────────────────────────────────
653
654#[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
991// ── Context Building ────────────────────────────────────────────────────────
992
993pub 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// ── Action Execution & Hoare Sandwich ───────────────────────────────────────
1026
1027#[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            _ => { // json, yaml, etc.
1184                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                // Map to declared action outputs
1224                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        // 1. Build Precondition Context
1285        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        // 2. Evaluate Preconditions (V_pre Gate)
1298        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        // 3. Execute Action
1332        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        // 4. Build Postcondition Context
1352        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        // 5. Evaluate Postconditions (V_post Witness)
1370        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                // Rollback simulates atomic rollback
1384                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        // 6. Generate Deterministic VCardReceipt
1407        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}