clm-kernel 0.0.18

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
use serde_json::Value;
use crate::fs_utils::compute_sha256_hex;
use crate::parser::AMCard;

pub(super) fn prepare_context_inputs_and_check_preconditions(
    a_mcard: &AMCard,
    concrete_args: &[String],
    payload: Option<&str>,
    skip_conditions: bool,
    clm_root_str: &str,
    quiet: bool,
) -> Result<Value, String> {
    let mut context_val = serde_json::json!({ "inputs": Value::Null, "outputs": Value::Null });
    let mut inputs_map = serde_json::Map::new();
    let mut payload_parsed = false;

    if let Some(pay) = payload {
        let trimmed = pay.trim();
        if trimmed.starts_with('{') {
            if let Ok(Value::Object(obj)) = serde_json::from_str::<Value>(trimmed) {
                for (k, v) in obj { inputs_map.insert(k, v); }
                payload_parsed = true;
            }
        } else if trimmed.contains(':')
            && let Ok(data) = serde_yaml::from_str::<Value>(trimmed)
            && let Value::Object(obj) = data {
                for (k, v) in obj { inputs_map.insert(k, v); }
                payload_parsed = true;
            }
    }

    if !payload_parsed && let Some(pay) = payload
        && let Value::Object(ref sig_inputs) = a_mcard.signature.inputs && sig_inputs.len() == 1 {
            let first_key = sig_inputs.keys().next().unwrap();
            if let Ok(num) = pay.parse::<i64>() { inputs_map.insert(first_key.clone(), Value::from(num)); }
            else if let Ok(f) = pay.parse::<f64>() { inputs_map.insert(first_key.clone(), Value::from(f)); }
            else if pay == "true" { inputs_map.insert(first_key.clone(), Value::Bool(true)); }
            else if pay == "false" { inputs_map.insert(first_key.clone(), Value::Bool(false)); }
            else { inputs_map.insert(first_key.clone(), Value::String(pay.to_string())); }
        }

    if let Value::Object(ref sig_inputs) = a_mcard.signature.inputs {
        let keys: Vec<&String> = sig_inputs.keys().collect();
        for (i, key) in keys.iter().enumerate() {
            if !inputs_map.contains_key(*key) && let Some(arg) = concrete_args.get(i) {
                if let Ok(num) = arg.parse::<i64>() { inputs_map.insert((*key).clone(), Value::from(num)); }
                else if let Ok(f) = arg.parse::<f64>() { inputs_map.insert((*key).clone(), Value::from(f)); }
                else if arg == "true" { inputs_map.insert((*key).clone(), Value::Bool(true)); }
                else if arg == "false" { inputs_map.insert((*key).clone(), Value::Bool(false)); }
                else { inputs_map.insert((*key).clone(), Value::String(arg.clone())); }
            }
        }
    }

    if let Some(obj) = context_val.as_object_mut() {
        obj.insert("inputs".to_string(), Value::Object(inputs_map));
    }

    if !skip_conditions {
        for pre in &a_mcard.invariants.preconditions {
            match crate::invariants::evaluate_invariant(pre, clm_root_str, &context_val) {
                Ok(true) => {
                    if !quiet { eprintln!("[VCARD PRE] Invariant '{}' satisfied.", pre); }
                }
                Ok(false) => {
                    eprintln!("[PREP_ERR] Precondition violation: Invariant '{}' failed.", pre);
                    return Err(format!("Precondition violation: {}", pre));
                }
                Err(e) => {
                    eprintln!("[PREP_ERR] Precondition check error: Invariant '{}' raised error: {}", pre, e);
                    return Err(format!("Precondition check error: {}", e));
                }
            }
        }
    }

    Ok(context_val)
}

pub(super) fn parse_outputs_and_check_postconditions(
    a_mcard: &AMCard,
    output: &str,
    context_val: &mut Value,
    skip_conditions: bool,
    clm_root_str: &str,
    quiet: bool,
) -> Result<(), String> {
    let mut outputs_map = serde_json::Map::new();
    let trimmed = output.trim();
    let mut parsed = false;

    if trimmed.starts_with('{') {
        if let Ok(Value::Object(obj)) = serde_json::from_str::<Value>(trimmed) {
            for (k, v) in obj { outputs_map.insert(k, v); }
            parsed = true;
        }
    } else if trimmed.contains(':')
        && let Ok(data) = serde_yaml::from_str::<Value>(trimmed)
        && let Value::Object(obj) = data {
            for (k, v) in obj { outputs_map.insert(k, v); }
            parsed = true;
        }

    if !parsed && let Value::Object(ref sig_outputs) = a_mcard.signature.outputs && sig_outputs.len() == 1 {
        let first_key = sig_outputs.keys().next().unwrap();
        if let Ok(num) = trimmed.parse::<i64>() { outputs_map.insert(first_key.clone(), Value::from(num)); }
        else if let Ok(f) = trimmed.parse::<f64>() { outputs_map.insert(first_key.clone(), Value::from(f)); }
        else if trimmed == "true" { outputs_map.insert(first_key.clone(), Value::Bool(true)); }
        else if trimmed == "false" { outputs_map.insert(first_key.clone(), Value::Bool(false)); }
        else { outputs_map.insert(first_key.clone(), Value::String(trimmed.to_string())); }
    }

    if !outputs_map.contains_key("a_hash") && let Ok(h) = std::env::var("CLM_ACTIVE_A_HASH") {
        outputs_map.insert("a_hash".to_string(), Value::String(h));
    }
    if !outputs_map.contains_key("c_hash") && let Ok(h) = std::env::var("CLM_ACTIVE_C_HASH") {
        outputs_map.insert("c_hash".to_string(), Value::String(h));
    }
    if !outputs_map.contains_key("b_hash") && let Ok(h) = std::env::var("CLM_ACTIVE_B_HASH") {
        outputs_map.insert("b_hash".to_string(), Value::String(h));
    }

    if let Some(obj) = context_val.as_object_mut() {
        obj.insert("outputs".to_string(), Value::Object(outputs_map));
    }

    if !skip_conditions {
        for post in &a_mcard.invariants.postconditions {
            match crate::invariants::evaluate_invariant(post, clm_root_str, context_val) {
                Ok(true) => {
                    if !quiet { eprintln!("[VCARD POST] Invariant '{}' satisfied.", post); }
                }
                Ok(false) => {
                    eprintln!("[POST_ERR] Postcondition violation: Invariant '{}' failed.", post);
                    return Err(format!("Postcondition violation: {}", post));
                }
                Err(e) => {
                    eprintln!("[POST_ERR] Postcondition check error: Invariant '{}' raised error: {}", post, e);
                    return Err(format!("Postcondition check error: {}", e));
                }
            }
        }
    }

    Ok(())
}

pub(super) fn check_noether_and_emit_exec_mcard(
    operation: &str,
    output: &str,
    clm_data: &serde_yaml::Value,
    clm_root_str: &str,
    quiet: bool,
) {
    let raw_hex = compute_sha256_hex(output.as_bytes());
    let output_hash = format!("sha256:{}", raw_hex);
    
    let a_hash_str = clm_data.get("_meta").and_then(|m| m.get("a_hash")).and_then(|v| v.as_str())
        .map(|s| s.to_string())
        .unwrap_or_else(|| {
            let spec = clm_data.get("abstract_spec").cloned().unwrap_or(serde_yaml::Value::Null);
            let serialized = serde_yaml::to_string(&spec).unwrap_or_default();
            format!("sha256:{}", compute_sha256_hex(serialized.replace('\r', "").as_bytes()))
        });
    
    let c_hash_str = clm_data.get("_meta").and_then(|m| m.get("c_hash")).and_then(|v| v.as_str())
        .map(|s| s.to_string())
        .unwrap_or_else(|| {
            let spec = clm_data.get("concrete_impl").cloned().unwrap_or(serde_yaml::Value::Null);
            let serialized = serde_yaml::to_string(&spec).unwrap_or_default();
            format!("sha256:{}", compute_sha256_hex(serialized.replace('\r', "").as_bytes()))
        });

    let inputs_len = clm_data.get("concrete_impl").and_then(|v| v.get("inputs")).and_then(|v| v.as_sequence()).map(|a| a.len()).unwrap_or(0);
    let outputs_len = clm_data.get("concrete_impl").and_then(|v| v.get("outputs")).and_then(|v| v.as_sequence()).map(|a| a.len()).unwrap_or(0);
    let x_t_d = (outputs_len as i32) - (inputs_len as i32);
    
    if !quiet {
        eprintln!("[VCARD POST] 🔍 Noetherian P-invariant conservation check: x^T D = 0");
        if x_t_d == 0 {
            eprintln!("   ✅ P-Inv: place marking conservation holds (x^T D = 0) [OK]");
        } else {
            eprintln!("   ⚠️ P-Inv: place marking conservation drift detected: x^T D = {} (inputs={}, outputs={})", x_t_d, inputs_len, outputs_len);
        }
    }

    let extra_yaml = format!("content: |\n  {}", output.replace('\n', "\n  "));
    match crate::db::emit_exec_mcard(
        operation, &output_hash, &extra_yaml, &a_hash_str, &c_hash_str, clm_root_str,
    ) {
        Ok(exec_mcard_path) => {
            if !quiet {
                eprintln!("[VCARD POST] ✅ Execution MCard generated: {}", exec_mcard_path);
                eprintln!("[VCARD POST]   g_time: {}", crate::fs_utils::compute_g_time());
                eprintln!("[VCARD POST]   content_hash: {}", raw_hex);
            }
        }
        Err(e) => {
            eprintln!("[VCARD POST] ❌ Failed to emit execution MCard: {}", e);
        }
    }
}