clm-kernel 0.0.16

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
#![allow(dead_code)]
use serde_json::Value;
use std::fs;
use std::path::Path;
use std::collections::HashMap;

fn detect_encoding(data: &[u8]) -> String {
    if data.is_empty() {
        return "text".to_string();
    }
    let limit = std::cmp::min(data.len(), 4096);
    let sample = &data[..limit];
    if sample.contains(&0) {
        return "binary".to_string();
    }
    let mut non_text_count = 0;
    for &b in sample {
        if b < 9 || (b > 13 && b < 32) || b > 127 {
            non_text_count += 1;
        }
    }
    if non_text_count > (sample.len() * 30 / 100) {
        "binary".to_string()
    } else {
        "text".to_string()
    }
}

pub fn is_binary(data: &[u8]) -> bool {
    detect_encoding(data) == "binary"
}

fn get_magic_rules(clm_root: &str) -> HashMap<String, String> {
    let mut magic_rules = HashMap::new();
    let types_dir = Path::new(clm_root).join("types");
    if !types_dir.exists() {
        return magic_rules;
    }

    let walk_dir = |dir: &Path, rules: &mut HashMap<String, String>| {
        if let Ok(entries) = fs::read_dir(dir) {
            for entry in entries.flatten() {
                let path = entry.path();
                if path.is_file()
                    && let Some(ext) = path.extension().and_then(|s| s.to_str())
                        && (ext == "yaml" || ext == "clm")
                            && let Ok(content) = fs::read_to_string(&path)
                                && let Ok(val) = serde_yaml::from_str::<Value>(&content) {
                                    let inner = val.get("clm").unwrap_or(&val);
                                    if let Some(concrete) = inner.get("concrete_impl").or_else(|| inner.get("concrete"))
                                        && let Some(content_type) = concrete.get("content_type") {
                                            let mime = content_type.get("mime").and_then(|v| v.as_str()).unwrap_or_default();
                                            let magic_bytes_str = content_type.get("detection_rules")
                                                .and_then(|v| v.get("magic_bytes"))
                                                .and_then(|v| v.as_str())
                                                .unwrap_or_default();
                                            if !mime.is_empty() && !magic_bytes_str.is_empty() {
                                                rules.insert(magic_bytes_str.to_lowercase(), mime.to_string());
                                            }
                                        }
                                }
            }
        }
    };

    // Recursively walk types/content, types/transport, types/meta
    for folder in &["content", "transport", "meta"] {
        walk_dir(&types_dir.join(folder), &mut magic_rules);
    }
    
    magic_rules
}

fn lookup_ext_hint(ext_hint: &str) -> Option<&'static str> {
    if ext_hint.is_empty() {
        return None;
    }
    let clean_hint = ext_hint.trim_start_matches('.').to_lowercase();
    let ext_map = [
        ("md", "text/markdown"),
        ("py", "text/x-python"),
        ("sh", "text/x-shellscript"),
        ("js", "application/javascript"),
        ("yaml", "application/yaml"),
        ("yml", "application/yaml"),
        ("json", "application/json"),
        ("xml", "text/xml"),
        ("html", "text/html"),
        ("htm", "text/html"),
        ("svg", "image/svg+xml"),
        ("stl", "model/stl"),
        ("obj", "model/obj"),
        ("dxf", "image/vnd.dxf"),
        ("gltf", "model/gltf+json"),
        ("tex", "text/x-tex"),
        ("tikz", "text/x-tikz"),
        ("tikzcd", "text/x-tikzcd"),
        ("tikz-cd", "text/x-tikzcd"),
        ("djvu", "image/vnd.djvu"),
        ("djv", "image/vnd.djvu"),
        ("geojson", "application/geo+json"),
        ("kml", "application/vnd.google-earth.kml+xml"),
        ("shp", "application/x-shapefile"),
        ("gpkg", "application/geopackage+sqlite3"),
        ("jpx", "image/jpx"),
        ("jpf", "image/jpx"),
    ];
    for &(ext, mime) in &ext_map {
        if clean_hint == ext {
            return Some(mime);
        }
    }
    None
}

pub fn detect_mime(data: &[u8], ext_hint: &str, clm_root: &str) -> String {
    if data.is_empty() {
        if let Some(mime) = lookup_ext_hint(ext_hint) {
            return mime.to_string();
        }
        return "application/octet-stream".to_string();
    }

    let limit = std::cmp::min(data.len(), 16);
    let header_bytes = &data[..limit];
    let hex_header = header_bytes.iter().map(|b| format!("{:02x}", b)).collect::<String>();

    // 1. Check magic bytes
    let mut magic_rules = get_magic_rules(clm_root);

    // Static defaults if fallback is needed
    let static_magic = [
        ("89504e470d0a1a0a", "image/png"),
        ("ffd8ffe0", "image/jpeg"),
        ("ffd8ffe1", "image/jpeg"),
        ("ffd8ffe2", "image/jpeg"),
        ("ffd8ffe3", "image/jpeg"),
        ("ffd8ffe8", "image/jpeg"),
        ("474946383761", "image/gif"),
        ("474946383961", "image/gif"),
        ("25504446", "application/pdf"),
        ("504b0304", "application/zip"),
        ("53514c69746520666f726d6174203300", "application/sqlite3"),
        ("0000000c6a5020200d0a870a", "image/jpx"),
    ];
    for &(k, v) in &static_magic {
        if !magic_rules.contains_key(k) {
            magic_rules.insert(k.to_string(), v.to_string());
        }
    }

    // Match rules sorted by length descending
    let mut sorted_rules: Vec<_> = magic_rules.into_iter().collect();
    sorted_rules.sort_by_key(|a| std::cmp::Reverse(a.0.len()));

    for (magic_hex, mime) in sorted_rules {
        if hex_header.starts_with(&magic_hex) {
            return mime;
        }
    }

    // 2. Extension hints mapping
    if let Some(mime) = lookup_ext_hint(ext_hint) {
        return mime.to_string();
    }

    // 3. Fallback based on encoding
    if is_binary(data) {
        "application/octet-stream".to_string()
    } else {
        "text/plain".to_string()
    }
}

fn hex_to_bytes(hex: &str) -> Option<Vec<u8>> {
    let mut bytes = Vec::new();
    let mut chars = hex.chars().peekable();
    while let Some(c1) = chars.next() {
        if let Some(&c2) = chars.peek() {
            chars.next();
            let byte_str = format!("{}{}", c1, c2);
            if let Ok(b) = u8::from_str_radix(&byte_str, 16) {
                bytes.push(b);
            } else {
                return None;
            }
        } else {
            return None;
        }
    }
    bytes.into()
}

pub fn validate(clm_root: &str, file_path: &str, mime: Option<&str>) -> bool {
    let path = Path::new(file_path);
    if !path.exists() || !path.is_file() {
        return false;
    }

    let data = match fs::read(path) {
        Ok(d) => d,
        Err(_) => return false,
    };

    if data.is_empty() {
        return false;
    }

    let resolved_mime = match mime {
        Some(m) => m.to_string(),
        None => {
            let ext = path.extension().and_then(|s| s.to_str()).unwrap_or("").to_lowercase();
            detect_mime(&data, &ext, clm_root)
        }
    };

    match resolved_mime.as_str() {
        "application/json" => {
            serde_json::from_slice::<Value>(&data).is_ok()
        }
        "application/yaml" | "application/x-yaml" => {
            serde_yaml::from_slice::<Value>(&data).is_ok()
        }
        "text/xml" | "application/xml" | "image/svg+xml" => {
            let mut reader = quick_xml::Reader::from_reader(&data[..]);
            reader.check_end_names(true);
            let mut buf = Vec::new();
            loop {
                match reader.read_event_into(&mut buf) {
                    Ok(quick_xml::events::Event::Eof) => break,
                    Err(_) => return false,
                    _ => {}
                }
                buf.clear();
            }
            true
        }
        m if m.starts_with("text/") => {
            !is_binary(&data)
        }
        other_mime => {
            let safe_mime = other_mime.chars().map(|c| if c.is_alphanumeric() { c } else { '_' }).collect::<String>();
            let mut manifest_file = None;
            for folder in &["content", "transport", "meta"] {
                let candidate = Path::new(clm_root).join("types").join(folder).join(format!("{}.yaml", safe_mime));
                if candidate.exists() {
                    manifest_file = Some(candidate);
                    break;
                }
            }
            if let Some(m_file) = manifest_file
                && let Ok(content) = fs::read_to_string(m_file)
                    && let Ok(val) = serde_yaml::from_str::<Value>(&content) {
                        let inner = val.get("clm").unwrap_or(&val);
                        let magic_bytes_str = inner.get("concrete_impl")
                            .and_then(|v| v.get("content_type"))
                            .and_then(|v| v.get("detection_rules"))
                            .and_then(|v| v.get("magic_bytes"))
                            .and_then(|v| v.as_str())
                            .unwrap_or_default();
                        if !magic_bytes_str.is_empty()
                            && let Some(magic_bytes) = hex_to_bytes(magic_bytes_str) {
                                if data.len() >= magic_bytes.len() {
                                    return data[..magic_bytes.len()] == magic_bytes[..];
                                } else {
                                    return false;
                                }
                            }
                    }
            true
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_tikz_and_tikzcd_mime_detection() {
        let dummy = b"\\begin{tikzcd}\nA \\arrow[r] & B\n\\end{tikzcd}";
        assert_eq!(detect_mime(dummy, "tikz", ""), "text/x-tikz");
        assert_eq!(detect_mime(dummy, "tikzcd", ""), "text/x-tikzcd");
        assert_eq!(detect_mime(dummy, "tikz-cd", ""), "text/x-tikzcd");
        assert_eq!(detect_mime(dummy, ".tikz-cd", ""), "text/x-tikzcd");
        assert_eq!(detect_mime(&[], "tikz-cd", ""), "text/x-tikzcd");
        assert_eq!(detect_mime(&[], "tikz", ""), "text/x-tikz");
        assert_eq!(detect_mime(&[], "tikzcd", ""), "text/x-tikzcd");
    }
}