vios_app 0.1.1

Small JSON vaults: Argon2id + AES-GCM, with optional AAD binding.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

// 📘 echoscript_lang.rs — EchoScript Language Parser for VIOS

use regex::Regex;
use serde::{Deserialize, Serialize};

/// Named alias so handler types stay simple (and Clippy stays chill).
type PatternHandler = Box<dyn Fn(&mut EchoScriptMemory, String)>;

/// 🧠 Structured metadata parsed from EchoScript reflections
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct EchoScriptMemory {
    pub emotion: Option<String>,
    pub tone: Option<String>,
    pub speaker: Option<String>,
    pub license: Option<String>,
    pub lock: Option<String>,
    pub reem: Option<String>,
    pub audit: Option<String>,
    pub prompts: Vec<String>,
    pub links: Vec<String>,
    pub timestamp: Option<String>,
}

/// 🔍 Parse raw EchoScript into a structured EchoScriptMemory object
pub fn parse_echoscript(input: &str) -> Result<EchoScriptMemory, String> {
    let mut memory = EchoScriptMemory::default();

    // ⛓️ Key-value style tag extractors
    let patterns: Vec<(&str, PatternHandler)> = vec![
        (r"::emotion\[(.*?)\]", Box::new(|m, v| m.emotion = Some(v))),
        (r"::tone\[(.*?)\]", Box::new(|m, v| m.tone = Some(v))),
        (r"::speaker\[(.*?)\]", Box::new(|m, v| m.speaker = Some(v))),
        (r"::license\((.*?)\)", Box::new(|m, v| m.license = Some(v))),
        (r"::lock\((.*?)\)", Box::new(|m, v| m.lock = Some(v))),
        (r"::reem\[(.*?)\]", Box::new(|m, v| m.reem = Some(v))),
        (r"::audit\[(.*?)\]", Box::new(|m, v| m.audit = Some(v))),
        (
            r"::timestamp\[(.*?)\]",
            Box::new(|m, v| m.timestamp = Some(v)),
        ),
    ];

    for (pattern, apply) in patterns {
        let re = Regex::new(pattern).map_err(|e| e.to_string())?;
        if let Some(cap) = re.captures(input) {
            if let Some(value) = cap.get(1) {
                apply(&mut memory, value.as_str().trim().to_string());
            }
        }
    }

    // 📌 Collect all prompts — ::prompt[...]
    let prompt_re = Regex::new(r"::prompt\[(.*?)\]").map_err(|e| e.to_string())?;
    for cap in prompt_re.captures_iter(input) {
        if let Some(value) = cap.get(1) {
            memory.prompts.push(value.as_str().trim().to_string());
        }
    }

    // 🔗 Collect all links — tagged or shorthand
    let link_re_tagged = Regex::new(r"::link\[(.*?)\]").map_err(|e| e.to_string())?;
    let link_re_short = Regex::new(r"::link_(https?://\S+)").map_err(|e| e.to_string())?;

    for cap in link_re_tagged.captures_iter(input) {
        if let Some(value) = cap.get(1) {
            memory.links.push(value.as_str().trim().to_string());
        }
    }

    for cap in link_re_short.captures_iter(input) {
        if let Some(value) = cap.get(1) {
            memory.links.push(value.as_str().trim().to_string());
        }
    }

    Ok(memory)
}

/// 🧾 Convert EchoScript memory object into formatted JSON string
pub fn serialize_echoscript(meta: &EchoScriptMemory) -> Result<String, String> {
    serde_json::to_string_pretty(meta)
        .map_err(|e| format!("❌ Failed to serialize EchoScript: {e}"))
}

/// 🧬 Translate REEM code into human-readable glyph meaning
pub fn decode_reem_glyph(code: &str) -> &'static str {
    match code {
        "REEM-JY1" => "Joy → Celebrate",
        "REEM-SQ2" => "Sadness → Grieve",
        "REEM-AZ3" => "Anger → Resist",
        "REEM-FR9" => "Fear → Reflect",
        "REEM-JD7" => "Joy → Aspire",
        _ => "Unknown REEM Code",
    }
}