clm-kernel 0.0.9

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
#![allow(unused_imports)]
use super::*;

pub struct DocumentManipulator;

impl DocumentManipulator {
    pub fn split(data: &str, params: &HashMap<String, Value>) -> Result<HashMap<String, String>, String> {
        let delimiter = params.get("delimiter").and_then(|v| v.as_str()).unwrap_or("# ");
        let mut results = HashMap::new();
        let parts: Vec<&str> = data.split(delimiter).collect();
        if parts.len() <= 1 {
            results.insert("document".to_string(), data.to_string());
            return Ok(results);
        }

        let mut idx = 1;
        for part in &parts[1..] {
            let key = format!("section_{}", idx);
            let content = format!("{}{}", delimiter, part.trim());
            results.insert(key, content);
            idx += 1;
        }
        if !parts[0].trim().is_empty() {
            results.insert("intro".to_string(), parts[0].trim().to_string());
        }
        Ok(results)
    }

    pub fn substitute(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
        let mut res = data.to_string();
        if let (Some(target), Some(replacement)) = (
            params.get("target_header").and_then(|v| v.as_str()),
            params.get("replacement_header").and_then(|v| v.as_str()),
        ) {
            res = res.replace(target, replacement);
        } else if let Some(Value::Object(replacements)) = params.get("replacements") {
            for (old, new_val) in replacements {
                if let Some(new_str) = new_val.as_str() {
                    res = res.replace(old, new_str);
                }
            }
        }
        Ok(res)
    }

    pub fn augment(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
        let mut res = data.to_string();
        if let Some(content) = params.get("content").and_then(|v| v.as_str()) {
            if !res.ends_with('\n') {
                res.push('\n');
            }
            res.push_str(content);
            if !res.ends_with('\n') {
                res.push('\n');
            }
        }
        Ok(res)
    }

    pub fn exclude(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
        let section_title = params.get("section_title").and_then(|v| v.as_str()).unwrap_or("");
        let mut lines = Vec::new();
        let mut skipping = false;
        for line in data.lines() {
            if line.starts_with('#') && line.contains(section_title) && !section_title.is_empty() {
                skipping = true;
                continue;
            }
            if skipping && line.starts_with('#') {
                skipping = false;
            }
            if !skipping {
                lines.push(line);
            }
        }
        let mut res = lines.join("\n");
        if data.ends_with('\n') {
            res.push('\n');
        }
        Ok(res)
    }

    pub fn invert(data: &str, _params: &HashMap<String, Value>) -> Result<String, String> {
        let sections: Vec<&str> = data.split("\n#").collect();
        if sections.len() <= 1 {
            return Ok(data.to_string());
        }
        let intro = sections[0];
        let mut rest: Vec<String> = sections[1..].iter().map(|s| format!("#{}", s)).collect();
        rest.reverse();
        Ok(format!("{}\n{}", intro.trim(), rest.join("\n")))
    }

    pub fn port(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
        let target_fmt = params.get("target_format").and_then(|v| v.as_str()).unwrap_or("text").to_lowercase();
        if target_fmt == "html" {
            let mut html = String::new();
            for line in data.lines() {
                if let Some(h1) = line.strip_prefix("# ") {
                    html.push_str(&format!("<h1>{}</h1>\n", h1.trim()));
                } else if let Some(h2) = line.strip_prefix("## ") {
                    html.push_str(&format!("<h2>{}</h2>\n", h2.trim()));
                } else if !line.trim().is_empty() {
                    html.push_str(&format!("<p>{}</p>\n", line.trim()));
                }
            }
            return Ok(html);
        }
        // plain text: strip #, *, `
        let plain = data.replace(['#', '*', '`'], "");
        Ok(plain)
    }
}

pub struct StructuredManipulator;

impl StructuredManipulator {
    pub fn split(data: &str, params: &HashMap<String, Value>) -> Result<HashMap<String, String>, String> {
        let v: Value = serde_json::from_str(data)
            .or_else(|_| serde_yaml::from_str(data))
            .map_err(|e| format!("Invalid structured data: {}", e))?;

        let mut partitions = HashMap::new();
        if let Value::Object(map) = v {
            if let Some(Value::Object(groups)) = params.get("groups") {
                for (g_name, g_keys) in groups {
                    if let Value::Array(keys) = g_keys {
                        let mut sub = serde_json::Map::new();
                        for k in keys {
                            if let Some(ks) = k.as_str()
                                && let Some(val) = map.get(ks) {
                                    sub.insert(ks.to_string(), val.clone());
                                }
                        }
                        partitions.insert(g_name.clone(), serde_json::to_string_pretty(&Value::Object(sub)).unwrap());
                    }
                }
                return Ok(partitions);
            }
            let keys: Vec<&String> = map.keys().collect();
            let mid = keys.len() / 2;
            let mut part1 = serde_json::Map::new();
            let mut part2 = serde_json::Map::new();
            for (i, k) in keys.iter().enumerate() {
                if i < mid {
                    part1.insert((*k).clone(), map[*k].clone());
                } else {
                    part2.insert((*k).clone(), map[*k].clone());
                }
            }
            partitions.insert("part_1".to_string(), serde_json::to_string_pretty(&Value::Object(part1)).unwrap());
            partitions.insert("part_2".to_string(), serde_json::to_string_pretty(&Value::Object(part2)).unwrap());
            return Ok(partitions);
        }
        partitions.insert("all".to_string(), data.to_string());
        Ok(partitions)
    }

    pub fn substitute(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
        let mut v: Value = serde_json::from_str(data)
            .or_else(|_| serde_yaml::from_str(data))
            .map_err(|e| format!("Invalid structured data: {}", e))?;

        if let (Value::Object(map), Some(Value::Object(replacements))) = (&mut v, params.get("replacements")) {
            for (k, new_val) in replacements {
                if map.contains_key(k) {
                    map.insert(k.clone(), new_val.clone());
                }
            }
        }
        serde_json::to_string_pretty(&v).map_err(|e| e.to_string())
    }

    pub fn augment(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
        let mut v: Value = serde_json::from_str(data)
            .or_else(|_| serde_yaml::from_str(data))
            .map_err(|e| format!("Invalid structured data: {}", e))?;

        if let (Value::Object(map), Some(Value::Object(fields))) = (&mut v, params.get("fields")) {
            for (k, val) in fields {
                map.insert(k.clone(), val.clone());
            }
        }
        serde_json::to_string_pretty(&v).map_err(|e| e.to_string())
    }

    pub fn exclude(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
        let mut v: Value = serde_json::from_str(data)
            .or_else(|_| serde_yaml::from_str(data))
            .map_err(|e| format!("Invalid structured data: {}", e))?;

        let mut drop_keys = Vec::new();
        if let Some(Value::Array(keys)) = params.get("keys") {
            for k in keys {
                if let Some(s) = k.as_str() {
                    drop_keys.push(s.to_string());
                }
            }
        }

        fn prune(val: &mut Value, drop: &[String]) {
            match val {
                Value::Object(map) => {
                    for k in drop {
                        map.remove(k);
                    }
                    for (_, child) in map.iter_mut() {
                        prune(child, drop);
                    }
                }
                Value::Array(arr) => {
                    for child in arr.iter_mut() {
                        prune(child, drop);
                    }
                }
                _ => {}
            }
        }
        prune(&mut v, &drop_keys);
        serde_json::to_string_pretty(&v).map_err(|e| e.to_string())
    }

    pub fn invert(data: &str, _params: &HashMap<String, Value>) -> Result<String, String> {
        let v: Value = serde_json::from_str(data)
            .or_else(|_| serde_yaml::from_str(data))
            .map_err(|e| format!("Invalid structured data: {}", e))?;

        match v {
            Value::Object(map) => {
                let mut inverted = serde_json::Map::new();
                for (k, val) in map {
                    let val_str = match val {
                        Value::String(s) => s,
                        other => other.to_string(),
                    };
                    inverted.insert(val_str, Value::String(k));
                }
                serde_json::to_string_pretty(&Value::Object(inverted)).map_err(|e| e.to_string())
            }
            Value::Array(mut arr) => {
                arr.reverse();
                serde_json::to_string_pretty(&Value::Array(arr)).map_err(|e| e.to_string())
            }
            other => serde_json::to_string_pretty(&other).map_err(|e| e.to_string()),
        }
    }

    pub fn port(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
        let mut v: Value = serde_json::from_str(data)
            .or_else(|_| serde_yaml::from_str(data))
            .map_err(|e| format!("Invalid structured data: {}", e))?;

        if let Some(target_runtime) = params.get("target_runtime").and_then(|r| r.as_str())
            && let Value::Object(map) = &mut v {
                map.insert("target_runtime".to_string(), Value::String(target_runtime.to_string()));
            }

        let target_fmt = params.get("target_format").and_then(|v| v.as_str()).unwrap_or("json").to_lowercase();
        if target_fmt == "yaml" || target_fmt == "application/yaml" {
            serde_yaml::to_string(&v).map_err(|e| e.to_string())
        } else {
            serde_json::to_string_pretty(&v).map_err(|e| e.to_string())
        }
    }
}

// ── Rule / Invariant Evaluator ──────────────────────────────────────────────