clm-kernel 0.0.2

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
use serde_json::Value;
use std::env;
use std::fs;
use std::path::Path;
use crate::db::{handle_register_batch, resolve_handle_content};
use crate::fs_utils::compute_sha256_hex;

pub fn jsonl_emit(
    event_type: &str,
    kv_args: Vec<String>,
    clm_root: &str,
) -> Result<String, String> {
    let mut map = serde_json::Map::new();
    map.insert("event".to_string(), Value::String(event_type.to_string()));

    let timestamp = crate::utils::now_iso8601();
    map.insert("timestamp".to_string(), Value::String(timestamp));

    let agent_did = env::var("CLM_AGENT_DID")
        .unwrap_or_else(|_| "did:clm:bootstrap".to_string());
    map.insert("agent_did".to_string(), Value::String(agent_did));

    for kv in kv_args {
        if let Some(pos) = kv.find('=') {
            let key = &kv[..pos];
            let val_str = &kv[pos + 1..];

            let val = if val_str == "null" {
                Value::Null
            } else if val_str.starts_with('[') && val_str.ends_with(']') {
                if let Ok(parsed_arr) = serde_json::from_str::<Value>(val_str) {
                    parsed_arr
                } else {
                    Value::String(val_str.to_string())
                }
            } else if val_str.starts_with('{') && val_str.ends_with('}') {
                if let Ok(parsed_obj) = serde_json::from_str::<Value>(val_str) {
                    parsed_obj
                } else {
                    Value::String(val_str.to_string())
                }
            } else if let Ok(num) = val_str.parse::<i64>() {
                Value::Number(num.into())
            } else {
                Value::String(val_str.to_string())
            };

            map.insert(key.to_string(), val);
        }
    }

    let json_line = Value::Object(map).to_string();
    let zero_fs = crate::utils::is_zero_fs();

    // 1. File write
    let events_dir = Path::new(clm_root).join("data").join("events");
    let log_file_str = env::var("CLM_EVENT_LOG_PATH")
        .unwrap_or_else(|_| events_dir.join("token_events.jsonl").to_string_lossy().to_string());
    let log_file = Path::new(&log_file_str);

    if !zero_fs || log_file_str.contains("/tmp") {
        if let Some(parent) = log_file.parent() {
            let _ = fs::create_dir_all(parent);
        }
        let mut open_opts = fs::OpenOptions::new();
        open_opts.create(true).append(true);
        if let Ok(mut file) = open_opts.open(log_file) {
            use std::io::Write;
            let _ = writeln!(file, "{}", json_line);
        }
    }

    // 2. DB write if CLM_RUN_ID is set
    let run_id_res = env::var("CLM_RUN_ID");
    if let Ok(run_id) = run_id_res
        && !run_id.is_empty() {
            let handle_name = format!("run:{}:events", run_id);
            let current_content = resolve_handle_content("execution_log", clm_root, &handle_name)
                .unwrap_or(None);

            let new_content = match current_content {
                Some(content) => {
                    if content.is_empty() {
                        json_line.clone()
                    } else {
                        format!("{}\n{}", content, json_line)
                    }
                }
                None => json_line.clone(),
            };

            let new_hash = compute_sha256_hex(new_content.as_bytes());
            if let Err(e) = handle_register_batch("execution_log", clm_root, &handle_name, &new_hash, &new_content) {
                eprintln!("[RUST JSONL_EMIT] ❌ Failed to register event in DB: {}", e);
            }
        }

    // println!("{}", json_line);
    Ok(json_line)
}