clm-kernel 0.0.21

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
//! Satori Protocol XML Parser and Serializer.
//!
//! Normalizes omnichannel chat streams (Discord, Telegram, Slack, WebSockets, CLI)
//! into canonical Satori AST elements and vice versa.

use super::element::{SatoriElement, SatoriMessage};
use quick_xml::events::Event;
use quick_xml::reader::Reader;
use std::collections::HashMap;

/// Parses a Satori XML fragment into a vector of SatoriElement AST nodes.
/// Gracefully falls back to plain text if the input is not XML formatted.
pub fn parse_satori_xml(xml_input: &str) -> Result<Vec<SatoriElement>, String> {
    let trimmed = xml_input.trim();
    if trimmed.is_empty() {
        return Ok(Vec::new());
    }

    // Quick check: if no XML brackets, return text directly
    if !trimmed.contains('<') || !trimmed.contains('>') {
        return Ok(vec![SatoriElement::text(trimmed)]);
    }

    let mut reader = Reader::from_str(xml_input);
    reader.trim_text(false);
    let mut elements = Vec::new();

    loop {
        match reader.read_event() {
            Ok(Event::Start(ref e)) => {
                let tag_name = String::from_utf8_lossy(e.name().as_ref()).to_string();
                if tag_name == "text" {
                    // Will capture next text event
                    continue;
                }
                if let Ok(elem) = parse_element_from_event(&tag_name, e) { elements.push(elem) }
            }
            Ok(Event::Empty(ref e)) => {
                let tag_name = String::from_utf8_lossy(e.name().as_ref()).to_string();
                if let Ok(elem) = parse_element_from_event(&tag_name, e) { elements.push(elem) }
            }
            Ok(Event::Text(ref e)) => {
                let txt = match e.unescape() {
                    Ok(cow) => cow.to_string(),
                    Err(_) => String::from_utf8_lossy(e.as_ref()).to_string(),
                };
                if !txt.is_empty() {
                    if let Some(SatoriElement::Text { text }) = elements.last_mut() {
                        text.push_str(&txt);
                    } else {
                        elements.push(SatoriElement::text(txt));
                    }
                }
            }
            Ok(Event::End(_)) => {
                // Closed tags
            }
            Ok(Event::Eof) => break,
            Err(_) => {
                // If malformed XML, fallback to plain text if nothing parsed yet
                if elements.is_empty() {
                    return Ok(vec![SatoriElement::text(xml_input)]);
                }
                break;
            }
            _ => {}
        }
    }

    if elements.is_empty() && !xml_input.is_empty() {
        elements.push(SatoriElement::text(xml_input));
    }

    Ok(elements)
}

fn parse_element_from_event(
    tag_name: &str,
    e: &quick_xml::events::BytesStart,
) -> Result<SatoriElement, String> {
    let mut attrs = HashMap::new();
    for a in e.attributes().flatten() {
        let key = String::from_utf8_lossy(a.key.as_ref()).to_string();
        let val = match a.unescape_value() {
            Ok(cow) => cow.to_string(),
            Err(_) => String::from_utf8_lossy(a.value.as_ref()).to_string(),
        };
        attrs.insert(key, val);
    }

    match tag_name {
        "at" => {
            let id = attrs
                .remove("id")
                .or_else(|| attrs.remove("user_id"))
                .unwrap_or_default();
            Ok(SatoriElement::at(id))
        }
        "quote" => {
            let id = attrs.remove("id").unwrap_or_default();
            Ok(SatoriElement::quote(id))
        }
        "image" => {
            let src = attrs
                .remove("src")
                .or_else(|| attrs.remove("url"))
                .unwrap_or_default();
            Ok(SatoriElement::image(src))
        }
        "audio" => {
            let src = attrs
                .remove("src")
                .or_else(|| attrs.remove("url"))
                .unwrap_or_default();
            Ok(SatoriElement::audio(src))
        }
        "button" => {
            let id = attrs.remove("id").unwrap_or_default();
            let label = attrs.remove("label").unwrap_or_default();
            Ok(SatoriElement::button(id, label))
        }
        "action" => {
            let id = attrs.remove("id").unwrap_or_default();
            Ok(SatoriElement::action(id))
        }
        other => {
            let id = attrs.remove("id").unwrap_or_else(|| other.to_string());
            Ok(SatoriElement::action(id))
        }
    }
}

/// Serializes elements into a Satori XML fragment.
pub fn serialize_satori_xml(elements: &[SatoriElement]) -> String {
    elements.iter().map(|e| e.to_xml()).collect::<Vec<_>>().join("")
}

/// Parses full SatoriMessage from XML.
pub fn parse_satori_message(
    id: &str,
    channel_id: &str,
    user_did: &str,
    xml_input: &str,
) -> Result<SatoriMessage, String> {
    let elements = parse_satori_xml(xml_input)?;
    let timestamp = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .map(|d| d.as_secs())
        .unwrap_or(0);

    Ok(SatoriMessage::new(
        id,
        channel_id,
        user_did,
        elements,
        timestamp,
    ))
}