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(['#', '*', '`'], "");
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// ── Rule / Invariant Evaluator ──────────────────────────────────────────────
651
652#[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
989// ── Context Building ────────────────────────────────────────────────────────
990
991pub 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// ── Action Execution & Hoare Sandwich ───────────────────────────────────────
1023
1024#[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            _ => { // json, yaml, etc.
1181                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                // Map to declared action outputs
1221                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        // 1. Build Precondition Context
1282        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        // 2. Evaluate Preconditions (V_pre Gate)
1295        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        // 3. Execute Action
1329        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        // 4. Build Postcondition Context
1349        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        // 5. Evaluate Postconditions (V_post Witness)
1367        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                // Rollback simulates atomic rollback
1381                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        // 6. Generate Deterministic VCardReceipt
1404        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}