cel-context 0.1.1

Portable context snapshots for AI agents. Normalize UI, browser, app, log, and external signals into reusable elements and snapshots.
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

//! Generic context snapshot — builds a ScreenContext from caller-provided streams.
//!
//! Usage:
//!   cargo run -p cel-context --example context_snapshot
//!   cargo run -p cel-context --example context_snapshot -- --json

use std::collections::HashMap;

use cel_context::{
    Bounds, ContentRole, ContextContribution, ContextElement, ContextMerger, ContextSource,
    ElementState, StreamStatus,
};

fn main() {
    let json_output = std::env::args().any(|arg| arg == "--json");

    let mut merger = ContextMerger::new().with_defaults("Example CRM", "Customer Detail");
    merger.push(
        ContextContribution::new(
            "crm_api",
            vec![
                element(
                    "crm:title",
                    "heading",
                    "Customer: Acme Corp",
                    ContextSource::NativeApi,
                    None,
                ),
                element(
                    "crm:button:save",
                    "button",
                    "Save changes",
                    ContextSource::NativeApi,
                    Some(Bounds {
                        x: 720,
                        y: 64,
                        width: 128,
                        height: 36,
                    }),
                ),
            ],
        )
        .with_app("Example CRM")
        .with_window("Customer Detail")
        .with_stream_status(StreamStatus {
            accessibility: false,
            display: false,
            network: false,
            signals: false,
            vision: false,
            audio_capture: false,
        }),
    );
    merger.push(ContextContribution::new(
        "browser_dom",
        vec![element(
            "dom:input:notes",
            "textbox",
            "Internal notes",
            ContextSource::Cdp,
            Some(Bounds {
                x: 160,
                y: 420,
                width: 520,
                height: 120,
            }),
        )],
    ));

    let ctx = merger.build();

    if json_output {
        println!("{}", serde_json::to_string_pretty(&ctx).unwrap());
        return;
    }

    println!("=== CEL Context Snapshot ===");
    println!("App:       {}", ctx.app);
    println!("Window:    {}", ctx.window);
    println!("Timestamp: {} ms", ctx.timestamp_ms);
    println!("Elements:  {}", ctx.elements.len());
    println!();

    for (i, elem) in ctx.elements.iter().enumerate() {
        let label = elem.label.as_deref().unwrap_or("(no label)");
        let bounds = elem
            .bounds
            .as_ref()
            .map(|b| format!("[{},{} {}x{}]", b.x, b.y, b.width, b.height))
            .unwrap_or_else(|| "(no bounds)".into());
        println!(
            "  {:>2}. [{:.2}] {:12} {:22} {} {:?}",
            i + 1,
            elem.confidence,
            elem.element_type,
            label,
            bounds,
            elem.source
        );
    }
}

fn element(
    id: &str,
    element_type: &str,
    label: &str,
    source: ContextSource,
    bounds: Option<Bounds>,
) -> ContextElement {
    ContextElement {
        id: id.into(),
        label: Some(label.into()),
        description: None,
        element_type: element_type.into(),
        value: None,
        bounds,
        state: ElementState::default(),
        parent_id: None,
        actions: Vec::new(),
        confidence: 0.0,
        source,
        content_role: ContentRole::Interactive,
        properties: HashMap::new(),
    }
}