Skip to main content

clm_rust_core/layer1/
action_sandwich.rs

1#![allow(unused_imports)]
2use crate::layer0::vocabulary::{HANDLE_MCARD_RECEIPTS};
3use super::*;
4
5#[derive(Debug, Clone, Serialize, Deserialize)]
6pub struct ExecutionResult {
7    pub status: String,
8    pub operator: String,
9    pub outputs: HashMap<String, String>,
10    pub input_hashes: HashMap<String, String>,
11    pub output_hashes: HashMap<String, String>,
12    pub metrics: HashMap<String, Value>,
13    pub error: Option<String>,
14}
15
16#[derive(Debug, Clone, Serialize, Deserialize)]
17pub struct Verdict {
18    pub invariant: String,
19    pub rule: String,
20    pub passed: bool,
21    pub description: Option<String>,
22}
23
24#[derive(Debug, Clone, Serialize, Deserialize)]
25pub struct VCardReceipt {
26    pub uri: String,
27    pub hash: String,
28    pub payload: Value,
29}
30
31#[derive(Debug, Clone, Serialize, Deserialize)]
32pub struct HoareSandwichResult {
33    pub status: String,
34    pub action_name: String,
35    pub outputs: HashMap<String, String>,
36    pub receipt: Option<VCardReceipt>,
37    pub precondition_verdicts: Vec<Verdict>,
38    pub postcondition_verdicts: Vec<Verdict>,
39    pub rollback_occurred: bool,
40    pub rollback_time_ms: f64,
41    pub metrics: HashMap<String, Value>,
42    pub error: Option<String>,
43}
44
45pub struct ActionDispatcher;
46
47impl ActionDispatcher {
48    pub fn execute(
49        manifest: &ActionManifest,
50        input_bindings: &HashMap<String, String>,
51    ) -> ExecutionResult {
52        let t_start = std::time::Instant::now();
53        let operator = &manifest.operation.operator;
54        let params = &manifest.operation.parameters;
55
56        let mut input_hashes = HashMap::new();
57        let mut resolved_inputs = HashMap::new();
58
59        for inp in &manifest.inputs {
60            let val = input_bindings.get(&inp.name)
61                .or_else(|| inp.uri.as_ref().and_then(|u| input_bindings.get(u)));
62
63            if val.is_none() && inp.required {
64                return ExecutionResult {
65                    status: "failed".to_string(),
66                    operator: operator.to_string(),
67                    outputs: HashMap::new(),
68                    input_hashes,
69                    output_hashes: HashMap::new(),
70                    metrics: HashMap::new(),
71                    error: Some(format!("Required input '{}' could not be resolved", inp.name)),
72                };
73            }
74
75            if let Some(v) = val {
76                let h = clm_hash_string(v);
77                input_hashes.insert(inp.name.clone(), h);
78                resolved_inputs.insert(inp.name.clone(), v.clone());
79            }
80        }
81
82        let primary_input = resolved_inputs.values().next().cloned().unwrap_or_default();
83        let primary_format = manifest.inputs.first().and_then(|i| i.format.clone()).unwrap_or_else(|| "csv".to_string());
84
85        let mut outputs = HashMap::new();
86        let mut output_hashes = HashMap::new();
87
88        let run_res: Result<HashMap<String, String>, String> = match primary_format.as_str() {
89            "csv" | "tabular" => {
90                match operator {
91                    BaldwinOperator::Split => TabularManipulator::split(&primary_input, params),
92                    BaldwinOperator::Substitute => TabularManipulator::substitute(&primary_input, params).map(|s| {
93                        let mut m = HashMap::new();
94                        let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "output".to_string());
95                        m.insert(out_name, s);
96                        m
97                    }),
98                    BaldwinOperator::Augment => TabularManipulator::augment(&primary_input, params).map(|s| {
99                        let mut m = HashMap::new();
100                        let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "augmented".to_string());
101                        m.insert(out_name, s);
102                        m
103                    }),
104                    BaldwinOperator::Exclude => TabularManipulator::exclude(&primary_input, params).map(|s| {
105                        let mut m = HashMap::new();
106                        let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "sanitized".to_string());
107                        m.insert(out_name, s);
108                        m
109                    }),
110                    BaldwinOperator::Invert => TabularManipulator::invert(&primary_input, params).map(|s| {
111                        let mut m = HashMap::new();
112                        let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "inverted".to_string());
113                        m.insert(out_name, s);
114                        m
115                    }),
116                    BaldwinOperator::Port => TabularManipulator::port(&primary_input, params).map(|s| {
117                        let mut m = HashMap::new();
118                        let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "ported".to_string());
119                        m.insert(out_name, s);
120                        m
121                    }),
122                    BaldwinOperator::Custom => Ok(HashMap::new()),
123                }
124            }
125            "markdown" | "text" | "md" => {
126                match operator {
127                    BaldwinOperator::Split => DocumentManipulator::split(&primary_input, params),
128                    BaldwinOperator::Substitute => DocumentManipulator::substitute(&primary_input, params).map(|s| {
129                        let mut m = HashMap::new();
130                        let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "substituted".to_string());
131                        m.insert(out_name, s);
132                        m
133                    }),
134                    BaldwinOperator::Augment => DocumentManipulator::augment(&primary_input, params).map(|s| {
135                        let mut m = HashMap::new();
136                        let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "augmented".to_string());
137                        m.insert(out_name, s);
138                        m
139                    }),
140                    BaldwinOperator::Exclude => DocumentManipulator::exclude(&primary_input, params).map(|s| {
141                        let mut m = HashMap::new();
142                        let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "pruned".to_string());
143                        m.insert(out_name, s);
144                        m
145                    }),
146                    BaldwinOperator::Invert => DocumentManipulator::invert(&primary_input, params).map(|s| {
147                        let mut m = HashMap::new();
148                        let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "inverted".to_string());
149                        m.insert(out_name, s);
150                        m
151                    }),
152                    BaldwinOperator::Port => DocumentManipulator::port(&primary_input, params).map(|s| {
153                        let mut m = HashMap::new();
154                        let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "ported".to_string());
155                        m.insert(out_name, s);
156                        m
157                    }),
158                    BaldwinOperator::Custom => Ok(HashMap::new()),
159                }
160            }
161            _ => { // json, yaml, etc.
162                match operator {
163                    BaldwinOperator::Split => StructuredManipulator::split(&primary_input, params),
164                    BaldwinOperator::Substitute => StructuredManipulator::substitute(&primary_input, params).map(|s| {
165                        let mut m = HashMap::new();
166                        let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "substituted".to_string());
167                        m.insert(out_name, s);
168                        m
169                    }),
170                    BaldwinOperator::Augment => StructuredManipulator::augment(&primary_input, params).map(|s| {
171                        let mut m = HashMap::new();
172                        let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "augmented".to_string());
173                        m.insert(out_name, s);
174                        m
175                    }),
176                    BaldwinOperator::Exclude => StructuredManipulator::exclude(&primary_input, params).map(|s| {
177                        let mut m = HashMap::new();
178                        let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "pruned".to_string());
179                        m.insert(out_name, s);
180                        m
181                    }),
182                    BaldwinOperator::Invert => StructuredManipulator::invert(&primary_input, params).map(|s| {
183                        let mut m = HashMap::new();
184                        let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "inverted".to_string());
185                        m.insert(out_name, s);
186                        m
187                    }),
188                    BaldwinOperator::Port => StructuredManipulator::port(&primary_input, params).map(|s| {
189                        let mut m = HashMap::new();
190                        let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "ported".to_string());
191                        m.insert(out_name, s);
192                        m
193                    }),
194                    BaldwinOperator::Custom => Ok(HashMap::new()),
195                }
196            }
197        };
198
199        match run_res {
200            Ok(res_map) => {
201                // Map to declared action outputs
202                if manifest.outputs.len() > 1 && res_map.len() > 1 {
203                    for out_spec in &manifest.outputs {
204                        if let Some(val) = res_map.get(&out_spec.name) {
205                            outputs.insert(out_spec.name.clone(), val.clone());
206                            output_hashes.insert(out_spec.name.clone(), clm_hash_string(val));
207                        }
208                    }
209                } else if let Some(out_spec) = manifest.outputs.first() {
210                    let val = res_map.get(&out_spec.name)
211                        .cloned()
212                        .unwrap_or_else(|| res_map.values().next().cloned().unwrap_or_default());
213                    outputs.insert(out_spec.name.clone(), val.clone());
214                    output_hashes.insert(out_spec.name.clone(), clm_hash_string(&val));
215                }
216
217                let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
218                let mut metrics = HashMap::new();
219                metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
220                metrics.insert("operator".to_string(), json!(operator.to_string()));
221                metrics.insert("action_name".to_string(), json!(manifest.clm.name));
222
223                ExecutionResult {
224                    status: "success".to_string(),
225                    operator: operator.to_string(),
226                    outputs,
227                    input_hashes,
228                    output_hashes,
229                    metrics,
230                    error: None,
231                }
232            }
233            Err(e) => {
234                let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
235                let mut metrics = HashMap::new();
236                metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
237                ExecutionResult {
238                    status: "failed".to_string(),
239                    operator: operator.to_string(),
240                    outputs: HashMap::new(),
241                    input_hashes,
242                    output_hashes: HashMap::new(),
243                    metrics,
244                    error: Some(e),
245                }
246            }
247        }
248    }
249}
250
251pub struct HoareSandwichEngine;
252
253impl HoareSandwichEngine {
254    pub fn execute(
255        manifest: &ActionManifest,
256        input_bindings: &HashMap<String, String>,
257    ) -> HoareSandwichResult {
258        let t_start = std::time::Instant::now();
259        let action_manifest_val = manifest.to_canonical_json_value();
260        let action_hash = compute_canonical_hash(&action_manifest_val);
261
262        // 1. Build Precondition Context
263        let mut pre_ctx_map = serde_json::Map::new();
264        for inp in &manifest.inputs {
265            if let Some(payload) = input_bindings.get(&inp.name) {
266                let item_ctx = build_item_context(payload);
267                pre_ctx_map.insert(inp.name.clone(), item_ctx.clone());
268                if manifest.inputs.len() == 1 || inp.name == "dataset" {
269                    pre_ctx_map.insert("input".to_string(), item_ctx);
270                }
271            }
272        }
273        let pre_ctx = Value::Object(pre_ctx_map.clone());
274
275        // 2. Evaluate Preconditions (V_pre Gate)
276        let mut pre_verdicts = Vec::new();
277        for pre in &manifest.preconditions {
278            let passed = SafeRuleEvaluator::evaluate(&pre.rule, &pre_ctx);
279            let verdict = Verdict {
280                invariant: pre.invariant.clone(),
281                rule: pre.rule.clone(),
282                passed,
283                description: pre.description.clone(),
284            };
285            pre_verdicts.push(verdict);
286
287            if !passed {
288                let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
289                let mut metrics = HashMap::new();
290                metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
291                return HoareSandwichResult {
292                    status: "failed".to_string(),
293                    action_name: manifest.clm.name.clone(),
294                    outputs: HashMap::new(),
295                    receipt: None,
296                    precondition_verdicts: pre_verdicts,
297                    postcondition_verdicts: Vec::new(),
298                    rollback_occurred: false,
299                    rollback_time_ms: 0.0,
300                    metrics,
301                    error: Some(format!(
302                        "Precondition '{}' violated: '{}' evaluated to false",
303                        pre.invariant, pre.rule
304                    )),
305                };
306            }
307        }
308
309        // 3. Execute Action
310        let exec_result = ActionDispatcher::execute(manifest, input_bindings);
311        if exec_result.status != "success" {
312            let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
313            let mut metrics = HashMap::new();
314            metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
315            return HoareSandwichResult {
316                status: "failed".to_string(),
317                action_name: manifest.clm.name.clone(),
318                outputs: HashMap::new(),
319                receipt: None,
320                precondition_verdicts: pre_verdicts,
321                postcondition_verdicts: Vec::new(),
322                rollback_occurred: false,
323                rollback_time_ms: 0.0,
324                metrics,
325                error: exec_result.error,
326            };
327        }
328
329        // 4. Build Postcondition Context
330        let mut post_ctx_map = pre_ctx_map.clone();
331        let mut out_map = serde_json::Map::new();
332        for (name, payload) in &exec_result.outputs {
333            let item_ctx = build_item_context(payload);
334            out_map.insert(name.clone(), item_ctx);
335        }
336        if exec_result.outputs.len() == 1 {
337            let first_val = out_map.values().next().cloned().unwrap_or(Value::Null);
338            if let Value::Object(obj) = first_val {
339                for (k, v) in obj {
340                    out_map.insert(k, v);
341                }
342            }
343        }
344        post_ctx_map.insert("output".to_string(), Value::Object(out_map));
345        let post_ctx = Value::Object(post_ctx_map);
346
347        // 5. Evaluate Postconditions (V_post Witness)
348        let mut post_verdicts = Vec::new();
349        for post in &manifest.postconditions {
350            let passed = SafeRuleEvaluator::evaluate(&post.rule, &post_ctx);
351            let verdict = Verdict {
352                invariant: post.invariant.clone(),
353                rule: post.rule.clone(),
354                passed,
355                description: post.description.clone(),
356            };
357            post_verdicts.push(verdict);
358
359            if !passed {
360                let rb_start = std::time::Instant::now();
361                // Rollback simulates atomic rollback
362                let rollback_time_ms = (rb_start.elapsed().as_secs_f64() * 1000.0).max(0.01);
363                let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
364                let mut metrics = HashMap::new();
365                metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
366                return HoareSandwichResult {
367                    status: "failed".to_string(),
368                    action_name: manifest.clm.name.clone(),
369                    outputs: HashMap::new(),
370                    receipt: None,
371                    precondition_verdicts: pre_verdicts,
372                    postcondition_verdicts: post_verdicts,
373                    rollback_occurred: true,
374                    rollback_time_ms,
375                    metrics,
376                    error: Some(format!(
377                        "Postcondition '{}' violated: '{}' evaluated to false",
378                        post.invariant, post.rule
379                    )),
380                };
381            }
382        }
383
384        // 6. Generate Deterministic VCardReceipt
385        let pre_verdicts_val = serde_json::to_value(&pre_verdicts).unwrap_or(Value::Null);
386        let post_verdicts_val = serde_json::to_value(&post_verdicts).unwrap_or(Value::Null);
387
388        let pre_digest = compute_canonical_hash(&pre_verdicts_val);
389        let post_digest = compute_canonical_hash(&post_verdicts_val);
390        let witness_preimage = format!("{}:{}:{}", pre_digest, action_hash, post_digest);
391        let witness_hash = clm_hash_string(&witness_preimage);
392
393        let receipt_canonical_payload = json!({
394            "archetype": "VCardReceipt",
395            "action": {
396                "name": manifest.clm.name,
397                "hash": action_hash,
398            },
399            "inputs": exec_result.input_hashes,
400            "outputs": exec_result.output_hashes,
401            "verification": {
402                "preconditions": pre_verdicts,
403                "postconditions": post_verdicts,
404                "all_passed": true,
405            },
406            "witness": witness_hash,
407        });
408
409        let receipt_hash = compute_canonical_hash(&receipt_canonical_payload);
410        let receipt_uri = format!("{HANDLE_MCARD_RECEIPTS}{}", &receipt_hash[..16]);
411
412        let receipt = VCardReceipt {
413            uri: receipt_uri,
414            hash: receipt_hash,
415            payload: receipt_canonical_payload,
416        };
417
418        let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
419        let mut final_metrics = exec_result.metrics.clone();
420        final_metrics.insert("hoare_total_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
421
422        HoareSandwichResult {
423            status: "success".to_string(),
424            action_name: manifest.clm.name.clone(),
425            outputs: exec_result.outputs,
426            receipt: Some(receipt),
427            precondition_verdicts: pre_verdicts,
428            postcondition_verdicts: post_verdicts,
429            rollback_occurred: false,
430            rollback_time_ms: 0.0,
431            metrics: final_metrics,
432            error: None,
433        }
434    }
435}
436