vibelang 0.1.1

Programmatically instantiate Web Agents from Vibelang files
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use std::collections::HashMap;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AstNodeType {
    // Core program structure
    Program,
    FunctionDecl,
    FunctionBody,
    TypeDecl,
    VarDecl,
    ClassDecl,
    ClassBody,
    MemberVar,
    Import,

    // Type system
    BasicType,
    MeaningType,

    // Parameters and arguments
    ParamList,
    Parameter,

    // Statements
    Block,
    ExprStmt,
    ReturnStmt,
    PromptBlock,

    // Expressions
    CallExpr,
    Identifier,

    // Literals
    StringLiteral,
    IntLiteral,
    FloatLiteral,
    BoolLiteral,
}

#[derive(Debug, Clone)]
pub enum PropertyValue {
    String(String),
    Int(i64),
    Float(f64),
    Bool(bool),
}

#[derive(Debug, Clone)]
pub struct AstNode {
    pub node_type: AstNodeType,
    pub children: Vec<Box<AstNode>>,
    pub properties: HashMap<String, PropertyValue>,
    pub line: usize,
    pub column: usize,
    pub parent: Option<*mut AstNode>,
}

impl AstNode {
    pub fn new(node_type: AstNodeType) -> Self {
        Self {
            node_type,
            children: Vec::new(),
            properties: HashMap::new(),
            line: 0,
            column: 0,
            parent: None,
        }
    }

    pub fn add_child(&mut self, child: AstNode) {
        self.children.push(Box::new(child));
    }

    // Property setters matching C API
    pub fn set_string(&mut self, name: &str, value: &str) {
        self.properties
            .insert(name.to_string(), PropertyValue::String(value.to_string()));
    }

    pub fn set_int(&mut self, name: &str, value: i64) {
        self.properties
            .insert(name.to_string(), PropertyValue::Int(value));
    }

    pub fn set_float(&mut self, name: &str, value: f64) {
        self.properties
            .insert(name.to_string(), PropertyValue::Float(value));
    }

    pub fn set_bool(&mut self, name: &str, value: bool) {
        self.properties
            .insert(name.to_string(), PropertyValue::Bool(value));
    }

    // Property getters matching C API
    pub fn get_string(&self, name: &str) -> Option<&String> {
        match self.properties.get(name) {
            Some(PropertyValue::String(s)) => Some(s),
            _ => None,
        }
    }

    pub fn get_int(&self, name: &str) -> Option<i64> {
        match self.properties.get(name) {
            Some(PropertyValue::Int(i)) => Some(*i),
            _ => None,
        }
    }

    pub fn get_float(&self, name: &str) -> Option<f64> {
        match self.properties.get(name) {
            Some(PropertyValue::Float(f)) => Some(*f),
            _ => None,
        }
    }

    pub fn get_bool(&self, name: &str) -> Option<bool> {
        match self.properties.get(name) {
            Some(PropertyValue::Bool(b)) => Some(*b),
            _ => None,
        }
    }
}

pub fn extract_string_value(node: &AstNode) -> Option<&String> {
    match node.node_type {
        AstNodeType::StringLiteral => node.get_string("value"),
        AstNodeType::Identifier => node.get_string("name"),
        _ => None,
    }
}