clm-kernel 0.0.9

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::io::{self, Read};
use std::path::Path;
use crate::db::{card_exists, handle_register_batch, resolve_handle_hash, setter_card_batch};
use crate::fs_utils::{compute_content_hash, compute_stripped_file_hash, get_file_handle};
use crate::yaml::{parse_to_mcards, evaluate_jq};
use crate::classifier::{classify, detect_dialect};
use crate::cache::{setter_mcard_cache, setter_mcard_cache_handle};

pub fn memoize_clm_state(
    _file_path: &str,
    content_hash: &str,
    json_ast: &str,
    clm_root: &str,
) -> Result<(), String> {
    let parsed: Value = serde_json::from_str(json_ast)
        .map_err(|e| format!("Invalid JSON AST: {}", e))?;

    let classification = classify(&parsed);
    let dialect = detect_dialect(&parsed, &classification);

    let items = vec![
        ("ast", json_ast.to_string()),
        ("classification", classification),
        ("dialect", dialect),
    ];

    for (key, val) in items {
        let val_hash = compute_content_hash(&val);
        let handle_name = format!("{}:{}", key, content_hash);

        // Register in DB
        handle_register_batch("content_memory", clm_root, &handle_name, &val_hash, &val)
            .map_err(|e| format!("Failed to register handle {}: {}", handle_name, e))?;

        // Cache in L1
        setter_mcard_cache_handle(&handle_name, &val_hash);
        setter_mcard_cache(&val_hash, &val);
    }

    Ok(())
}

pub fn check_and_register_file_mcard(file_path: &str, clm_root: &str) -> Result<(), String> {
    let path = Path::new(file_path);
    if !path.is_file() {
        return Err(format!("Not a file: {}", file_path));
    }

    let handle_name = get_file_handle(file_path, Some(clm_root));
    let content_hash = compute_stripped_file_hash(path)
        .map_err(|e| format!("Failed to compute file hash: {}", e))?;

    let existing_hash = resolve_handle_hash("content_memory", clm_root, &handle_name)
        .unwrap_or(None);

    if existing_hash.is_none() || existing_hash.as_ref().unwrap() != &content_hash {
        // Read file contents
        let raw_content = fs::read_to_string(path)
            .map_err(|e| format!("Failed to read file: {}", e))?;
        let content = raw_content.trim_end_matches(['\n', '\r']).to_string();

        // Register file handle
        handle_register_batch("content_memory", clm_root, &handle_name, &content_hash, &content)
            .map_err(|e| format!("Failed to register handle {}: {}", handle_name, e))?;

        if existing_hash.is_none() {
            eprintln!(
                "[MCARD_KERNEL] 🆕 Registered physical file MCard handle: {} -> {}",
                handle_name, content_hash
            );
        } else {
            eprintln!(
                "[MCARD_KERNEL] 🔄 Change detected in physical file! Updated handle: {} ({} -> {})",
                handle_name,
                existing_hash.unwrap(),
                content_hash
            );
        }

        // Memoize CLM state
        match parse_to_mcards(file_path) {
            Ok(json_ast) => {
                if let Err(e) = memoize_clm_state(file_path, &content_hash, &json_ast, clm_root) {
                    eprintln!(
                        "[MCARD_KERNEL] ⚠️ Failed to memoize CLM state for {}: {}",
                        file_path, e
                    );
                }
            }
            Err(e) => {
                eprintln!(
                    "[MCARD_KERNEL] ⚠️ Failed to parse CLM AST for memoization: {} (File registered successfully without AST caching)",
                    e
                );
            }
        }
    }

    Ok(())
}

pub fn memorize_mcard_bytes(
    raw_bytes: &[u8],
    pillar: &str,
    clm_root: &str,
    base_filename: Option<&str>,
) -> Result<i32, String> {
    let data_root = Path::new(clm_root).join("data");
    let is_sandbox = crate::db::TEST_SANDBOX_ACTIVE.with(|active| active.get());
    let zero_fs = is_sandbox || env::var("CLM_ZERO_FS").unwrap_or_default() == "true";

    let mcard_content_str = std::str::from_utf8(raw_bytes).ok();
    let parsed_yaml: Option<Value> = mcard_content_str.and_then(|s| serde_yaml::from_str(s).ok());

    let is_yaml_ext = base_filename
        .map(|f| f.ends_with(".yaml") || f.ends_with(".yml"))
        .unwrap_or(false);

    if is_yaml_ext {
        let has_content_hash = match parsed_yaml.as_ref().map(|y| evaluate_jq(y, ".mcard.content_hash")) {
            Some(Value::String(s)) => !s.is_empty() && s != "null",
            _ => false,
        };
        if !has_content_hash {
            let fn_str = base_filename.unwrap_or("");
            eprintln!("[MEMORIZE] ❌ Not a valid MCard (missing content_hash): {}", fn_str);
            return Err(format!("[MEMORIZE] ❌ Not a valid MCard (missing content_hash): {}", fn_str));
        }
        let has_g_time = match parsed_yaml.as_ref().map(|y| evaluate_jq(y, ".mcard.g_time")) {
            Some(Value::String(s)) => !s.is_empty() && s != "null",
            _ => false,
        };
        if !has_g_time {
            let fn_str = base_filename.unwrap_or("");
            eprintln!("[MEMORIZE] ❌ Not a valid MCard (missing g_time): {}", fn_str);
            return Err(format!("[MEMORIZE] ❌ Not a valid MCard (missing g_time): {}", fn_str));
        }
    }

    let content_hash_str = match parsed_yaml.as_ref().map(|y| evaluate_jq(y, ".mcard.content_hash")) {
        Some(Value::String(s)) if !s.is_empty() && s != "null" => s,
        _ => crate::hash::raw_hash_bytes(raw_bytes),
    };

    let g_time_str = match parsed_yaml.as_ref().map(|y| evaluate_jq(y, ".mcard.g_time")) {
        Some(Value::String(s)) if !s.is_empty() && s != "null" => s,
        _ => chrono::Utc::now().to_rfc3339(),
    };

    let target_dir = match pillar {
        "identity" | "id" | "agent_identities" => data_root.join("agent_identity"),
        "memory" | "mem" | "content" | "content_memory" => data_root.join("content_memory"),
        "log" | "exec" | "execution" | "execution_log" => data_root.join("execution_logs"),
        "auto" => {
            let src_fn_str = parsed_yaml.as_ref()
                .map(|y| evaluate_jq(y, ".mcard.source.filename"))
                .and_then(|v| match v { Value::String(s) => Some(s), _ => None })
                .unwrap_or_default();
            let basename_file = base_filename.unwrap_or("").to_string();

            let computed_dir = if basename_file.starts_with("exec_") {
                data_root.join("execution_logs")
            } else if src_fn_str.ends_with(".pem")
                || src_fn_str.ends_with(".key")
                || src_fn_str.ends_with(".cert")
                || src_fn_str.ends_with(".crt")
                || src_fn_str.ends_with(".pub")
                || src_fn_str.ends_with(".sig")
                || src_fn_str.ends_with(".did")
            {
                data_root.join("agent_identity")
            } else if !src_fn_str.is_empty() && src_fn_str != "null" {
                data_root.join("content_memory")
            } else {
                data_root.join("execution_logs")
            };
            eprintln!(
                "[MEMORIZE] Auto-classified pillar: {}",
                computed_dir.file_name().unwrap().to_string_lossy()
            );
            computed_dir
        }
        _ => {
            return Err(format!(
                "[MEMORIZE] ❌ Unknown pillar: {} (use: identity, memory, log, or auto)",
                pillar
            ))
        }
    };

    if !zero_fs {
        let _ = fs::create_dir_all(&target_dir);
    }

    let pillar_name = target_dir.file_name().unwrap().to_string_lossy().to_string();
    let db_name = match pillar_name.as_str() {
        "agent_identity" => "agent_identities",
        "content_memory" => "content_memory",
        "execution_logs" => "execution_log",
        _ => "content_memory",
    };

    let short_hash = if content_hash_str.len() >= 8 {
        &content_hash_str[0..8]
    } else {
        &content_hash_str
    };

    // Duplicate detection
    let mut existing_db = false;
    if card_exists(db_name, clm_root, &content_hash_str).unwrap_or(false) {
        existing_db = true;
    }

    let mut existing_file = String::new();
    if !zero_fs && target_dir.exists()
        && let Ok(entries) = fs::read_dir(&target_dir) {
            for entry in entries.flatten() {
                let name = entry.file_name().to_string_lossy().to_string();
                if name.contains(short_hash) && (name.ends_with(".yaml") || name.ends_with(".dat")) {
                    existing_file = entry.path().to_string_lossy().to_string();
                    break;
                }
            }
        }

    if !existing_file.is_empty() || (zero_fs && existing_db) {
        eprintln!("[MEMORIZE] ⏭️  Duplicate detected — already memorized");
        if !existing_file.is_empty() {
            eprintln!("[MEMORIZE]   existing: {}", existing_file);
        }
        if existing_db {
            eprintln!("[MEMORIZE]   db_check:   found in {}.db", db_name);
        }
        eprintln!("[MEMORIZE]   pillar:       {}", pillar_name);
        eprintln!("[MEMORIZE]   content_hash: {}", content_hash_str);
        return Ok(2);
    }

    let unix_ts = chrono::Utc::now().timestamp();
    let ext = if parsed_yaml.is_some() { "yaml" } else { "dat" };
    let target_file = target_dir.join(format!("mcard_{}_{}.{}", unix_ts, short_hash, ext));

    if !zero_fs {
        fs::write(&target_file, raw_bytes)
            .map_err(|e| format!("[MEMORIZE] ❌ Failed to store MCard: {}", e))?;
    }

    // DB write
    let content_to_store = mcard_content_str.unwrap_or_default();
    setter_card_batch(db_name, clm_root, &content_hash_str, content_to_store, &g_time_str)
        .map_err(|e| format!("Failed to write to database: {}", e))?;
    eprintln!("[MEMORIZE]   db_write:     {}", db_name);

    // L1 cache write if utf-8
    if let Some(s) = mcard_content_str {
        setter_mcard_cache(&content_hash_str, s);
    }

    eprintln!("[MEMORIZE] ✅ MCard memorized");
    eprintln!("[MEMORIZE]   pillar:       {}", pillar_name);
    if !zero_fs {
        eprintln!("[MEMORIZE]   stored_at:    {}", target_file.display());
    }
    eprintln!("[MEMORIZE]   content_hash: {}", content_hash_str);
    eprintln!("[MEMORIZE]   g_time:       {}", g_time_str);

    Ok(0)
}

pub fn memorize_mcard_string(
    mcard_content_str: &str,
    pillar: &str,
    clm_root: &str,
    base_filename: Option<&str>,
) -> Result<i32, String> {
    memorize_mcard_bytes(
        mcard_content_str.as_bytes(),
        pillar,
        clm_root,
        base_filename,
    )
}

pub fn memorize_mcard(mcard_file: &str, pillar: &str, clm_root: &str) -> Result<i32, String> {
    let raw_bytes = if mcard_file == "/dev/stdin" || mcard_file == "-" {
        let mut buffer = Vec::new();
        let mut stdin = io::stdin();
        stdin.read_to_end(&mut buffer).map_err(|e| e.to_string())?;
        buffer
    } else {
        let path = Path::new(mcard_file);
        if !path.is_file() {
            return Err(format!("[MEMORIZE] ❌ MCard file not found: {}", mcard_file));
        }
        fs::read(path).map_err(|e| e.to_string())?
    };

    let basename_file = Path::new(mcard_file)
        .file_name()
        .map(|f| f.to_string_lossy().to_string());

    memorize_mcard_bytes(
        &raw_bytes,
        pillar,
        clm_root,
        basename_file.as_deref(),
    )
}