1use 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}