Skip to main content

vibe/stdlib_v2/topology_and_manifold/
ontological_context.rs

1//! AI-Native Ontological Context Manifold, Latent Pointers & Structural AST Deltas (ยง21.4).
2
3use super::{extract_list, extract_record, extract_str, fnv1a_64, fnv1a_value};
4use crate::cbor_ast::{encode, encode_value_cbor_ld, TAG_CBOR_LD_COMPRESSED, TAG_VIBE_AST};
5use crate::error::{DiagCode, Diagnostic};
6use crate::span::Span;
7use crate::value::Value;
8use crate::{parse_program, project_program, ProjectOptions};
9use std::collections::{BTreeMap, BTreeSet};
10
11pub fn call_ontological_context(
12    path: &str,
13    args: &[Value],
14    span: Span,
15) -> Result<Option<Value>, Diagnostic> {
16    match path {
17        "context.fork_by_ontology" => Ok(Some(context_fork_by_ontology(args, span)?)),
18        "context.spawn_swarm" => Ok(Some(context_spawn_swarm(args, span)?)),
19        "context.collapse_manifold" => Ok(Some(context_collapse_manifold(args, span)?)),
20        "manifold.mount" => Ok(Some(manifold_mount(args, span)?)),
21        "context.to_latent_pointer" => Ok(Some(context_to_latent_pointer(args, span)?)),
22        "context.query_distance" => Ok(Some(context_query_distance(args, span)?)),
23        "inference.next_valid_logit_mask" => Ok(Some(inference_next_valid_logit_mask(args, span)?)),
24        "ast.apply_structural_delta" => Ok(Some(ast_apply_structural_delta(args, span)?)),
25        "diagnostic.to_compact_token_error" => {
26            Ok(Some(diagnostic_to_compact_token_error(args, span)?))
27        }
28        _ => Ok(None),
29    }
30}
31
32fn context_fork_by_ontology(args: &[Value], span: Span) -> Result<Value, Diagnostic> {
33    let state_rec = extract_record(args, 0, "context.fork_by_ontology", span)?;
34    let ontology_iri = extract_str(args, 1, "context.fork_by_ontology", span)?;
35    let objective = args
36        .get(2)
37        .and_then(|v| v.as_str())
38        .unwrap_or("ontological-subtask");
39
40    let domain_tag = ontology_iri
41        .trim_end_matches('#')
42        .trim_end_matches('/')
43        .rsplit(['/', ':', '#'])
44        .next()
45        .unwrap_or("");
46
47    let mut projected = BTreeMap::new();
48    for (k, v) in state_rec {
49        if domain_tag.is_empty()
50            || k.starts_with(domain_tag)
51            || k.contains(domain_tag)
52            || !k.contains(':')
53        {
54            projected.insert(k.clone(), v.clone());
55        }
56    }
57    if projected.is_empty() {
58        projected = state_rec.clone();
59    }
60
61    let proj_val = Value::Record(projected.clone());
62    let cbor_bytes = encode_value_cbor_ld(&proj_val, ontology_iri);
63    let fork_hash = fnv1a_64(&cbor_bytes) ^ fnv1a_64(objective.as_bytes());
64
65    let mut out = BTreeMap::new();
66    out.insert("fork_id".into(), Value::String(format!("fork:{fork_hash:016x}")));
67    out.insert("ontology".into(), Value::Iri(ontology_iri.to_string()));
68    out.insert("objective".into(), Value::String(objective.to_string()));
69    out.insert("projected_state".into(), Value::Record(projected));
70    out.insert("cbor_ld_byte_len".into(), Value::I64(cbor_bytes.len() as i64));
71    Ok(Value::Record(out))
72}
73
74fn context_spawn_swarm(args: &[Value], span: Span) -> Result<Value, Diagnostic> {
75    let branches = extract_list(args, 0, "context.spawn_swarm", span)?;
76    let swarm_hash = fnv1a_value(&Value::List(branches.to_vec()));
77    let mut out = BTreeMap::new();
78    out.insert("swarm_id".into(), Value::String(format!("swarm:{swarm_hash:016x}")));
79    out.insert("branch_count".into(), Value::I64(branches.len() as i64));
80    out.insert("branches".into(), Value::List(branches.to_vec()));
81    out.insert("deterministic_order".into(), Value::Bool(true));
82    Ok(Value::Record(out))
83}
84
85fn context_collapse_manifold(args: &[Value], span: Span) -> Result<Value, Diagnostic> {
86    let branch_outputs = extract_list(args, 0, "context.collapse_manifold", span)?;
87    let shared_ontology = args
88        .get(1)
89        .and_then(|v| v.as_str())
90        .unwrap_or("https://qualiadb.org/contexts/vibe-v0.02.jsonld");
91
92    let mut merged = BTreeMap::new();
93    let mut conflict_keys = BTreeSet::new();
94
95    for b in branch_outputs {
96        if let Value::Record(rec) = b {
97            let source_map = match rec.get("projected_state") {
98                Some(Value::Record(ps)) => ps,
99                _ => rec,
100            };
101            for (k, v) in source_map {
102                if k == "fork_id" || k == "cbor_ld_byte_len" {
103                    continue;
104                }
105                if let Some(prev) = merged.get(k) {
106                    if prev != v {
107                        conflict_keys.insert(k.clone());
108                    }
109                } else {
110                    merged.insert(k.clone(), v.clone());
111                }
112            }
113        }
114    }
115
116    let conflicts: Vec<Value> = conflict_keys.into_iter().map(Value::String).collect();
117    let collapsed = conflicts.is_empty();
118    let merged_val = Value::Record(merged.clone());
119    let _cbor = encode_value_cbor_ld(&merged_val, shared_ontology);
120
121    let mut out = BTreeMap::new();
122    out.insert("collapsed".into(), Value::Bool(collapsed));
123    out.insert("ontology".into(), Value::Iri(shared_ontology.to_string()));
124    out.insert("merged_state".into(), merged_val);
125    out.insert("conflicts".into(), Value::List(conflicts));
126    out.insert("cbor_ld_tag".into(), Value::I64(TAG_CBOR_LD_COMPRESSED as i64));
127    Ok(Value::Record(out))
128}
129
130fn manifold_mount(args: &[Value], span: Span) -> Result<Value, Diagnostic> {
131    let resource_iri = extract_str(args, 0, "manifold.mount", span)?;
132    let schema = args.get(1).cloned().unwrap_or(Value::Null);
133    let h = fnv1a_64(resource_iri.as_bytes()) | (1u64 << 63);
134    let mut out = BTreeMap::new();
135    out.insert("mounted".into(), Value::Bool(true));
136    out.insert("pointer_did".into(), Value::Iri(format!("did:q42:{h:016x}")));
137    out.insert("resource_iri".into(), Value::Iri(resource_iri.to_string()));
138    out.insert("token_cost".into(), Value::I64(1));
139    out.insert("schema".into(), schema);
140    Ok(Value::Record(out))
141}
142
143fn context_to_latent_pointer(args: &[Value], span: Span) -> Result<Value, Diagnostic> {
144    let target = args.first().ok_or_else(|| {
145        Diagnostic::new(
146            DiagCode::E100,
147            span,
148            "context.to_latent_pointer requires 1 argument",
149        )
150    })?;
151    let fp = fnv1a_value(target) | (1u64 << 63);
152    let mut features = Vec::with_capacity(8);
153    let mut sum_sq = 0.0f64;
154    let mut raw = [0.0f64; 8];
155    for (i, slot) in raw.iter_mut().enumerate() {
156        let byte = ((fp >> (i * 8)) & 0xFF) as f64;
157        *slot = (byte / 127.5) - 1.0;
158        sum_sq += (*slot) * (*slot);
159    }
160    let norm = sum_sq.sqrt().max(1e-12);
161    for r in raw {
162        features.push(Value::F64(r / norm));
163    }
164
165    let mut out = BTreeMap::new();
166    out.insert("pointer_did".into(), Value::Iri(format!("did:q42:latent:{fp:016x}")));
167    out.insert("fingerprint".into(), Value::U64(fp));
168    out.insert("features".into(), Value::List(features));
169    Ok(Value::Record(out))
170}
171
172fn extract_features(v: &Value) -> Option<Vec<f64>> {
173    if let Value::Record(r) = v {
174        if let Some(Value::List(l)) = r.get("features") {
175            let vec: Vec<f64> = l.iter().filter_map(|x| x.as_f64()).collect();
176            if !vec.is_empty() {
177                return Some(vec);
178            }
179        }
180    }
181    None
182}
183
184fn context_query_distance(args: &[Value], span: Span) -> Result<Value, Diagnostic> {
185    if args.len() < 2 {
186        return Err(Diagnostic::new(
187            DiagCode::E100,
188            span,
189            "context.query_distance requires 2 arguments",
190        ));
191    }
192    if args[0] == args[1] {
193        return Ok(Value::F64(0.0));
194    }
195    if let (Some(fa), Some(fb)) = (extract_features(&args[0]), extract_features(&args[1])) {
196        let n = fa.len().min(fb.len());
197        let sum_sq: f64 = (0..n).map(|i| (fa[i] - fb[i]).powi(2)).sum();
198        return Ok(Value::F64(sum_sq.sqrt()));
199    }
200    let ha = fnv1a_value(&args[0]);
201    let hb = fnv1a_value(&args[1]);
202    let hamming = (ha ^ hb).count_ones() as f64 / 64.0;
203    Ok(Value::F64(hamming))
204}
205
206fn inference_next_valid_logit_mask(args: &[Value], span: Span) -> Result<Value, Diagnostic> {
207    let _state = extract_record(args, 0, "inference.next_valid_logit_mask", span)?;
208    let phase = extract_str(args, 1, "inference.next_valid_logit_mask", span)?;
209    let tokens: &[&str] = match phase {
210        "top_level" | "module" => &[
211            "@context",
212            "@ontology",
213            "@Clean",
214            "@Provenance",
215            "let",
216            "fn",
217            "intent",
218            "need",
219            "provide",
220            "promise",
221            "consensus",
222        ],
223        "statement" | "block" => &[
224            "let", "if", "match", "observe", "receive", "spawn", "emit", "yield", "Must", "May",
225            "MustNot",
226        ],
227        "expression" => &["(", "{", "[", "true", "false", "null", "|>"],
228        _ => &["let", "fn", "|>", "{", "}"],
229    };
230    let allowed: Vec<Value> = tokens.iter().map(|t| Value::String((*t).to_string())).collect();
231    let mut out = BTreeMap::new();
232    out.insert("phase".into(), Value::String(phase.to_string()));
233    out.insert("allowed_tokens".into(), Value::List(allowed.clone()));
234    out.insert("masked_count".into(), Value::I64(32000 - allowed.len() as i64));
235    out.insert("syntax_safe".into(), Value::Bool(true));
236    Ok(Value::Record(out))
237}
238
239fn ast_apply_structural_delta(args: &[Value], span: Span) -> Result<Value, Diagnostic> {
240    let src = extract_str(args, 0, "ast.apply_structural_delta", span)?;
241    let delta = extract_record(args, 1, "ast.apply_structural_delta", span)?;
242
243    let mut mutated_src = src.to_string();
244    if let (Some(from), Some(to)) = (
245        delta.get("replace_from").and_then(|v| v.as_str()),
246        delta.get("replace_to").and_then(|v| v.as_str()),
247    ) {
248        mutated_src = mutated_src.replace(from, to);
249    }
250    if let Some(append_stmt) = delta.get("append_statement").and_then(|v| v.as_str()) {
251        mutated_src.push('\n');
252        mutated_src.push_str(append_stmt);
253    }
254
255    let prog = parse_program(&mutated_src)?;
256    let projected = project_program(&prog, &ProjectOptions::default());
257    let cbor_bytes = encode(&prog);
258
259    let mut out = BTreeMap::new();
260    out.insert("projected_source".into(), Value::String(projected));
261    out.insert("ast_cbor_tag".into(), Value::I64(TAG_VIBE_AST as i64));
262    out.insert("byte_len".into(), Value::I64(cbor_bytes.len() as i64));
263    Ok(Value::Record(out))
264}
265
266fn diagnostic_to_compact_token_error(args: &[Value], span: Span) -> Result<Value, Diagnostic> {
267    let diag_rec = extract_record(args, 0, "diagnostic.to_compact_token_error", span)?;
268    let code = diag_rec
269        .get("code")
270        .and_then(|v| v.as_str())
271        .unwrap_or("E300");
272    let start = diag_rec
273        .get("start")
274        .and_then(|v| v.as_i64())
275        .unwrap_or(span.start as i64);
276    let end = diag_rec
277        .get("end")
278        .and_then(|v| v.as_i64())
279        .unwrap_or(span.end as i64);
280    let fix = diag_rec
281        .get("fix")
282        .and_then(|v| v.as_str())
283        .unwrap_or("align-type-or-guard");
284    let directive = format!("{code}@{start}..{end}:{fix}");
285    let token_est = ((directive.len() / 4) + 1) as i64;
286
287    let mut out = BTreeMap::new();
288    out.insert("code".into(), Value::String(code.to_string()));
289    out.insert("span".into(), Value::List(vec![Value::I64(start), Value::I64(end)]));
290    out.insert("compact_directive".into(), Value::String(directive));
291    out.insert("token_estimate".into(), Value::I64(token_est));
292    Ok(Value::Record(out))
293}