code wiki / _hdl_build / nx_vizsla_contact.nx
nx_vizsla_contact.nx source
↩ module page · 393 lines · 16482 B
1// nx_vizsla_contact.nx -- NISHI VIZSLA: the RICH CONTACT MODEL (PRM/CRM depth foundation). Operator 2026-06-23:
2// the engine must have "the depth of real system". A real contact is not id/name/tier/bday -- it has company,
3// role, multiple emails/phones, location, tags, custom fields. This stores arbitrary key->value fields per
4// contact as ADDITIVE CID records on the sovereign seg_store plane (latest-by-date wins per (contact,key);
5// history kept, tamper-evident, idempotent). Layered OVER the basic CONTACT roster -- the relate/health engines
6// still use the roster; this adds the rich profile. Search-by-field (`find`) is the foundation for segment +
7// reporting. Computed locally; no cloud, no enrichment-by-data-sale.
8// load <fieldfile> <prefix> [segid] FIELD <date> <contact> <key> <value> -> "fld:" records
9// profile <prefix> <contact> all CURRENT fields of one contact (latest value per key)
10// find <prefix> <key> <value> contacts whose current <key> == <value> (search/segment)
11// Determinism: stdout has no clocks. Loud-fail: bad date, missing field, missing args. license_tier: ORIGINAL
12import "nx_syscalls.nx"
13import "nx_canon_cid.nx"
14import "nx_seg_store.nx"
15const K_MAGIC_1970: i64 = 1970
16const K_MAGIC_146097: i64 = 146097
17const K_MAGIC_719468: i64 = 719468
18const K_MAGIC_2048: i64 = 2048
19const K_MAGIC_4096: i64 = 4096
20const K_MAGIC_65536: i64 = 65536
21const K_MAGIC_1024: i64 = 1024
22
23func vk_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
24func vk_p(s: *u8) -> i64 { sys_write(1, s, vk_slen(s)); return 0 }
25
26func vk_eq(a: *u8, b: *u8) -> i64 {
27 var i: i64 = 0
28 var go: i64 = 1
29 while go == 1 { if a[i] != b[i] { return 0 } if a[i] == (0 as u8) { return 1 } i = i + 1 }
30 return 0
31}
32
33func vk_dup(s: *u8) -> *u8 {
34 let n: i64 = vk_slen(s)
35 let d: *u8 = sys_mmap(n + 2)
36 var i: i64 = 0
37 while i <= n { d[i] = s[i]; i = i + 1 }
38 return d
39}
40
41func vk_atoi(s: *u8) -> i64 {
42 var v: i64 = 0
43 var i: i64 = 0
44 while s[i] != (0 as u8) { let d: i64 = (s[i] as i64) - 48; if d >= 0 { if d <= 9 { v = v * 10 + d } } i = i + 1 }
45 return v
46}
47
48func vk_isws(c: i64) -> i64 { if c == 32 { return 1 } if c == 13 { return 1 } if c == 9 { return 1 } return 0 }
49
50func vk_tok(b: *u8, off: i64, lend: i64, dst: *u8, cap: i64) -> i64 {
51 var p: i64 = off
52 var go: i64 = 1
53 while go == 1 { if p >= lend { go = 0 } else { if vk_isws(b[p] as i64) == 1 { p = p + 1 } else { go = 0 } } }
54 var t: i64 = 0
55 go = 1
56 while go == 1 {
57 if p >= lend { go = 0 } else {
58 if vk_isws(b[p] as i64) == 1 { go = 0 } else { if t < cap - 1 { dst[t] = b[p]; t = t + 1 } p = p + 1 }
59 }
60 }
61 dst[t] = 0 as u8
62 return p
63}
64
65func vk_cat(dst: *u8, off: i64, s: *u8) -> i64 {
66 var i: i64 = 0
67 while s[i] != (0 as u8) { dst[off + i] = s[i]; i = i + 1 }
68 return off + i
69}
70
71func vk_catn(dst: *u8, off: i64, v: i64) -> i64 {
72 var o: i64 = off
73 var m: i64 = v
74 if m < 0 { dst[o] = 45 as u8; o = o + 1; m = 0 - m }
75 let t: *u8 = sys_mmap(28)
76 var k: i64 = 0
77 if m == 0 { t[0] = 48 as u8; k = 1 }
78 while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
79 var i: i64 = 0
80 while i < k { dst[o + i] = t[k - 1 - i]; i = i + 1 }
81 return o + k
82}
83
84func vk_kmemeq(b: *u8, off: i64, n: i64, s: *u8) -> i64 {
85 if vk_slen(s) != n { return 0 }
86 var i: i64 = 0
87 while i < n { if b[off + i] != s[i] { return 0 } i = i + 1 }
88 return 1
89}
90
91func vk_iskind(b: *u8, koff: i64, kl: i64, pfx: *u8) -> i64 {
92 let pl: i64 = vk_slen(pfx)
93 if kl <= pl { return 0 }
94 return vk_kmemeq(b, koff, pl, pfx)
95}
96
97func vk_field(rec: *u8, rl: i64, want: *u8, out: *u8, cap: i64) -> i64 {
98 if rl < 8 { return 0 }
99 let nf: i64 = ss_r32(rec, 4)
100 var off: i64 = 8
101 var fi: i64 = 0
102 while fi < nf {
103 if off + 8 > rl { return 0 }
104 let kl: i64 = ss_r32(rec, off)
105 let koff: i64 = off + 4
106 let vl: i64 = ss_r32(rec, koff + kl)
107 let voff: i64 = koff + kl + 4
108 if vk_kmemeq(rec, koff, kl, want) == 1 {
109 var t: i64 = 0
110 while t < vl { if t < cap - 1 { out[t] = rec[voff + t] } t = t + 1 }
111 if t > cap - 1 { t = cap - 1 }
112 out[t] = 0 as u8
113 return 1
114 }
115 off = voff + vl
116 fi = fi + 1
117 }
118 return 0
119}
120
121func vk_datedays(s: *u8) -> i64 {
122 let nums: *i64 = sys_mmap(8 * 4) as *i64
123 var nn: i64 = 0
124 var cur: i64 = 0
125 var indig: i64 = 0
126 var i: i64 = 0
127 var go: i64 = 1
128 while go == 1 {
129 let c: i64 = s[i] as i64
130 var isd: i64 = 0
131 if c >= 48 { if c <= 57 { isd = 1 } }
132 if isd == 1 { cur = cur * 10 + (c - 48); indig = 1 }
133 if isd == 0 { if indig == 1 { if nn < 4 { nums[nn] = cur; nn = nn + 1 } cur = 0; indig = 0 } }
134 if c == 0 { go = 0 }
135 i = i + 1
136 }
137 if nn != 3 { return 0 - 1 }
138 var y: i64 = nums[0]
139 let m: i64 = nums[1]
140 let d: i64 = nums[2]
141 if y < K_MAGIC_1970 { return 0 - 1 }
142 if m < 1 { return 0 - 1 }
143 if m > 12 { return 0 - 1 }
144 if d < 1 { return 0 - 1 }
145 if d > 31 { return 0 - 1 }
146 if m <= 2 { y = y - 1 }
147 let era: i64 = y / 400
148 let yoe: i64 = y - era * 400
149 var mp: i64 = m - 3
150 if m <= 2 { mp = m + 9 }
151 let doy: i64 = (153 * mp + 2) / 5 + d - 1
152 let doe: i64 = yoe * 365 + yoe / 4 - yoe / 100 + doy
153 return era * K_MAGIC_146097 + doe - K_MAGIC_719468
154}
155
156func vk_put(keys: *i64, vals: *i64, nf: i64, kp: *u8, st: *i64) -> i64 {
157 let enc: *u8 = sys_mmap(K_MAGIC_2048)
158 let el: i64 = canon_encode(keys, vals, nf, enc)
159 let cid: *u8 = sys_mmap(96)
160 cid_of(enc, el, cid)
161 let kbuf: *u8 = sys_mmap(128)
162 var ko: i64 = 0
163 ko = vk_cat(kbuf, ko, kp); ko = vk_cat(kbuf, ko, cid); kbuf[ko] = 0 as u8
164 let seen: *i64 = st[1] as *i64
165 var fresh: i64 = 1
166 var si: i64 = 0
167 while si < st[2] { if vk_eq(seen[si] as *u8, kbuf) == 1 { fresh = 0; st[4] = st[4] + 1; si = st[2] } si = si + 1 }
168 if fresh == 1 { if st[2] < K_MAGIC_2048 { seen[st[2]] = vk_dup(kbuf) as i64; st[2] = st[2] + 1 } }
169 if fresh == 1 {
170 let pp: *i64 = sys_mmap(16) as *i64
171 let ll: *i64 = sys_mmap(16) as *i64
172 if ss_get_idx(st[6] as *u8, kbuf, pp, ll) == 1 { fresh = 0; st[5] = st[5] + 1 }
173 }
174 if fresh == 1 { if ss_add(st[0] as *i64, 1, kbuf, enc, el) != 0 { return 0 - 1 } st[3] = st[3] + 1 }
175 return 0
176}
177
178// ---------------- LOAD ----------------
179func vk_cmd_load(argc: i64, argv: *i64) -> i64 {
180 if argc < 4 { vk_p("VIZSLA-CONTACT load needs <fieldfile> <prefix> -- fail loud\n" as *u8); return 1 }
181 let lfile: *u8 = argv[2] as *u8
182 let prefix: *u8 = argv[3] as *u8
183 var segid: i64 = 0
184 if argc > 4 { segid = vk_atoi(argv[4] as *u8) }
185 if segid == 0 { segid = sys_now_us() }
186 let szp: *i64 = sys_mmap(16) as *i64
187 let b: *u8 = ss_readall(lfile, szp)
188 let sz: i64 = szp[0]
189 if sz <= 0 { vk_p("VIZSLA-CONTACT fieldfile MISSING/EMPTY -- fail loud\n" as *u8); return 1 }
190
191 let keys: *i64 = sys_mmap(8 * 8) as *i64
192 let vals: *i64 = sys_mmap(8 * 8) as *i64
193 keys[0] = "kind" as *u8 as i64; keys[1] = "date" as *u8 as i64; keys[2] = "contact" as *u8 as i64
194 keys[3] = "key" as *u8 as i64; keys[4] = "value" as *u8 as i64
195 vals[0] = "fld" as *u8 as i64
196
197 let st: *i64 = sys_mmap(8 * 8) as *i64
198 st[0] = ss_begin() as i64; st[1] = sys_mmap(8 * K_MAGIC_2048); st[2] = 0; st[3] = 0; st[4] = 0; st[5] = 0; st[6] = prefix as i64
199
200 let t0: *u8 = sys_mmap(128)
201 let f1: *u8 = sys_mmap(128)
202 let f2: *u8 = sys_mmap(128)
203 let f3: *u8 = sys_mmap(128)
204 let f4: *u8 = sys_mmap(256)
205 var scanned: i64 = 0
206 var i: i64 = 0
207 while i < sz {
208 var e: i64 = i
209 var go: i64 = 1
210 while go == 1 { if e >= sz { go = 0 } else { if b[e] == (10 as u8) { go = 0 } else { e = e + 1 } } }
211 var p: i64 = vk_tok(b, i, e, t0, 128)
212 if t0[0] == (35 as u8) { t0[0] = 0 as u8 }
213 if vk_eq(t0, "FIELD" as *u8) == 1 {
214 p = vk_tok(b, p, e, f1, 128); p = vk_tok(b, p, e, f2, 128); p = vk_tok(b, p, e, f3, 128); p = vk_tok(b, p, e, f4, 256)
215 if vk_datedays(f1) < 0 { vk_p("VIZSLA-CONTACT FIELD bad date -- fail loud\n" as *u8); return 1 }
216 if f2[0] == (0 as u8) { vk_p("VIZSLA-CONTACT FIELD missing contact -- fail loud\n" as *u8); return 1 }
217 if f3[0] == (0 as u8) { vk_p("VIZSLA-CONTACT FIELD missing key -- fail loud\n" as *u8); return 1 }
218 if f4[0] == (0 as u8) { vk_p("VIZSLA-CONTACT FIELD missing value -- fail loud\n" as *u8); return 1 }
219 vals[1] = f1 as i64; vals[2] = f2 as i64; vals[3] = f3 as i64; vals[4] = f4 as i64
220 scanned = scanned + 1
221 if vk_put(keys, vals, 5, "fld:" as *u8, st) != 0 { vk_p("VIZSLA-CONTACT writer full -- fail loud\n" as *u8); return 1 }
222 }
223 i = e + 1
224 }
225 var committed: i64 = 0
226 if st[3] > 0 { if ss_commit(prefix, st[0] as *i64, segid) != 0 { vk_p("VIZSLA-CONTACT commit FAILED -- fail loud\n" as *u8); return 1 } committed = 1 }
227
228 let rep: *u8 = sys_mmap(K_MAGIC_4096)
229 var o: i64 = 0
230 o = vk_cat(rep, o, "VIZSLA-CONTACT-LOAD scanned=" as *u8); o = vk_catn(rep, o, scanned)
231 o = vk_cat(rep, o, " new=" as *u8); o = vk_catn(rep, o, st[3])
232 o = vk_cat(rep, o, " dup_infile=" as *u8); o = vk_catn(rep, o, st[4])
233 o = vk_cat(rep, o, " dup_instore=" as *u8); o = vk_catn(rep, o, st[5])
234 o = vk_cat(rep, o, " segment=" as *u8)
235 if committed == 1 { o = vk_cat(rep, o, "seg-" as *u8); o = vk_catn(rep, o, segid) } else { o = vk_cat(rep, o, "none" as *u8) }
236 o = vk_cat(rep, o, "\n" as *u8)
237 sys_write(1, rep, o)
238 return 0
239}
240
241// collect all fld: records -> arrays (rct, rkey, rval, rdate); returns count
242func vk_collect(prefix: *u8, rct: *i64, rkey: *i64, rval: *i64, rdate: *i64) -> i64 {
243 var n: i64 = 0
244 let segs: *i64 = sys_mmap(8 * 260) as *i64
245 let nseg: i64 = ss_manifest(prefix, segs)
246 let fa: *u8 = sys_mmap(128)
247 let fb: *u8 = sys_mmap(128)
248 let fc: *u8 = sys_mmap(256)
249 let fdt: *u8 = sys_mmap(128)
250 var s: i64 = 0
251 while s < nseg {
252 let path: *u8 = sys_mmap(512)
253 var po: i64 = 0
254 po = vk_cat(path, po, prefix); po = vk_cat(path, po, segs[s] as *u8); po = vk_cat(path, po, ".docs" as *u8)
255 path[po] = 0 as u8
256 let szp: *i64 = sys_mmap(16) as *i64
257 let b: *u8 = ss_readall(path, szp)
258 let sz: i64 = szp[0]
259 var j: i64 = 0
260 while j + 9 <= sz {
261 let kind: i64 = b[j]
262 let kl: i64 = ss_r32(b, j + 1)
263 let koff: i64 = j + 5
264 let vl: i64 = ss_r32(b, koff + kl)
265 let voff: i64 = koff + kl + 4
266 var take: i64 = 0
267 if kind == 1 { take = vk_iskind(b, koff, kl, "fld:" as *u8) }
268 if take == 1 {
269 let rec: *u8 = (b as i64 + voff) as *u8
270 if vk_field(rec, vl, "contact" as *u8, fa, 128) == 1 {
271 vk_field(rec, vl, "key" as *u8, fb, 128)
272 vk_field(rec, vl, "value" as *u8, fc, 256)
273 vk_field(rec, vl, "date" as *u8, fdt, 128)
274 if n < K_MAGIC_4096 { rct[n] = vk_dup(fa) as i64; rkey[n] = vk_dup(fb) as i64; rval[n] = vk_dup(fc) as i64; rdate[n] = vk_datedays(fdt); n = n + 1 }
275 }
276 }
277 j = voff + vl
278 }
279 s = s + 1
280 }
281 return n
282}
283
284// latest value for (contact,key) across the records -> out; 1 if any
285func vk_latest(rct: *i64, rkey: *i64, rval: *i64, rdate: *i64, n: i64, contact: *u8, key: *u8, out: *u8, cap: i64) -> i64 {
286 var best: i64 = 0 - 1
287 var found: i64 = 0
288 var i: i64 = 0
289 while i < n {
290 if vk_eq(rct[i] as *u8, contact) == 1 { if vk_eq(rkey[i] as *u8, key) == 1 { if rdate[i] > best {
291 best = rdate[i]
292 var t: i64 = 0
293 let v: *u8 = rval[i] as *u8
294 while v[t] != (0 as u8) { if t < cap - 1 { out[t] = v[t] } t = t + 1 }
295 out[t] = 0 as u8
296 found = 1
297 } } }
298 i = i + 1
299 }
300 return found
301}
302
303// ---------------- PROFILE ----------------
304func vk_cmd_profile(argc: i64, argv: *i64) -> i64 {
305 if argc < 4 { vk_p("VIZSLA-CONTACT profile needs <prefix> <contact> -- fail loud\n" as *u8); return 1 }
306 let prefix: *u8 = argv[2] as *u8
307 let contact: *u8 = argv[3] as *u8
308 let rct: *i64 = sys_mmap(8 * K_MAGIC_4096) as *i64
309 let rkey: *i64 = sys_mmap(8 * K_MAGIC_4096) as *i64
310 let rval: *i64 = sys_mmap(8 * K_MAGIC_4096) as *i64
311 let rdate: *i64 = sys_mmap(8 * K_MAGIC_4096) as *i64
312 let n: i64 = vk_collect(prefix, rct, rkey, rval, rdate)
313
314 let emitted: *i64 = sys_mmap(8 * 256) as *i64
315 var ne: i64 = 0
316 let rep: *u8 = sys_mmap(K_MAGIC_65536)
317 var o: i64 = 0
318 let lv: *u8 = sys_mmap(256)
319 var fields: i64 = 0
320 var i: i64 = 0
321 while i < n {
322 var mine: i64 = 0
323 if vk_eq(rct[i] as *u8, contact) == 1 { mine = 1 }
324 var done: i64 = 0
325 if mine == 1 { var k: i64 = 0; while k < ne { if vk_eq(emitted[k] as *u8, rkey[i] as *u8) == 1 { done = 1; k = ne } k = k + 1 } }
326 if mine == 1 { if done == 0 {
327 vk_latest(rct, rkey, rval, rdate, n, contact, rkey[i] as *u8, lv, 256)
328 o = vk_cat(rep, o, "VIZSLA-CONTACT-FIELD contact=" as *u8); o = vk_cat(rep, o, contact)
329 o = vk_cat(rep, o, " key=" as *u8); o = vk_cat(rep, o, rkey[i] as *u8)
330 o = vk_cat(rep, o, " value=" as *u8); o = vk_cat(rep, o, lv); o = vk_cat(rep, o, "\n" as *u8)
331 if ne < 256 { emitted[ne] = rkey[i]; ne = ne + 1 }
332 fields = fields + 1
333 } }
334 i = i + 1
335 }
336 o = vk_cat(rep, o, "VIZSLA-CONTACT-PROFILE contact=" as *u8); o = vk_cat(rep, o, contact)
337 o = vk_cat(rep, o, " fields=" as *u8); o = vk_catn(rep, o, fields); o = vk_cat(rep, o, "\n" as *u8)
338 sys_write(1, rep, o)
339 return 0
340}
341
342// ---------------- FIND (search by field) ----------------
343func vk_cmd_find(argc: i64, argv: *i64) -> i64 {
344 if argc < 5 { vk_p("VIZSLA-CONTACT find needs <prefix> <key> <value> -- fail loud\n" as *u8); return 1 }
345 let prefix: *u8 = argv[2] as *u8
346 let key: *u8 = argv[3] as *u8
347 let value: *u8 = argv[4] as *u8
348 let rct: *i64 = sys_mmap(8 * K_MAGIC_4096) as *i64
349 let rkey: *i64 = sys_mmap(8 * K_MAGIC_4096) as *i64
350 let rval: *i64 = sys_mmap(8 * K_MAGIC_4096) as *i64
351 let rdate: *i64 = sys_mmap(8 * K_MAGIC_4096) as *i64
352 let n: i64 = vk_collect(prefix, rct, rkey, rval, rdate)
353
354 let seen: *i64 = sys_mmap(8 * K_MAGIC_1024) as *i64
355 var nseen: i64 = 0
356 let rep: *u8 = sys_mmap(K_MAGIC_65536)
357 var o: i64 = 0
358 let lv: *u8 = sys_mmap(256)
359 var matches: i64 = 0
360 var i: i64 = 0
361 while i < n {
362 var consider: i64 = 0
363 if vk_eq(rkey[i] as *u8, key) == 1 { consider = 1 }
364 var dup: i64 = 0
365 if consider == 1 { var k: i64 = 0; while k < nseen { if vk_eq(seen[k] as *u8, rct[i] as *u8) == 1 { dup = 1; k = nseen } k = k + 1 } }
366 if consider == 1 { if dup == 0 {
367 if nseen < K_MAGIC_1024 { seen[nseen] = rct[i]; nseen = nseen + 1 }
368 vk_latest(rct, rkey, rval, rdate, n, rct[i] as *u8, key, lv, 256)
369 if vk_eq(lv, value) == 1 {
370 o = vk_cat(rep, o, "VIZSLA-CONTACT-MATCH contact=" as *u8); o = vk_cat(rep, o, rct[i] as *u8)
371 o = vk_cat(rep, o, " key=" as *u8); o = vk_cat(rep, o, key)
372 o = vk_cat(rep, o, " value=" as *u8); o = vk_cat(rep, o, value); o = vk_cat(rep, o, "\n" as *u8)
373 matches = matches + 1
374 }
375 } }
376 i = i + 1
377 }
378 o = vk_cat(rep, o, "VIZSLA-CONTACT-FIND key=" as *u8); o = vk_cat(rep, o, key)
379 o = vk_cat(rep, o, " value=" as *u8); o = vk_cat(rep, o, value)
380 o = vk_cat(rep, o, " matches=" as *u8); o = vk_catn(rep, o, matches); o = vk_cat(rep, o, "\n" as *u8)
381 sys_write(1, rep, o)
382 return 0
383}
384
385func main(argc: i64, argv: *i64) -> i64 {
386 if argc < 2 { vk_p("VIZSLA-CONTACT usage: load|profile|find -- fail loud\n" as *u8); return 1 }
387 let cmd: *u8 = argv[1] as *u8
388 if vk_eq(cmd, "load" as *u8) == 1 { return vk_cmd_load(argc, argv) }
389 if vk_eq(cmd, "profile" as *u8) == 1 { return vk_cmd_profile(argc, argv) }
390 if vk_eq(cmd, "find" as *u8) == 1 { return vk_cmd_find(argc, argv) }
391 vk_p("VIZSLA-CONTACT unknown command (load|profile|find) -- fail loud\n" as *u8)
392 return 1
393}