code wiki / _hdl_build / nx_vizsla_graph.nx
`nx_vizsla_graph.nx` source

↩ module page · 357 lines · 14027 B
1// nx_vizsla_graph.nx -- NISHI VIZSLA: INTRO-GRAPH / WHO-KNOWS-WHOM (PRM/CRM depth, the marquee feature Clay /
2// Affinity sell as "warm intro paths"). Operator 2026-06-23: real-system depth. Models the relationship NETWORK
3// as undirected edges between people ("a knows b") on the sovereign seg_store plane (additive "edge:" CID
4// records) and answers the killer question: to reach someone you don't know directly, WHO in your network can
5// introduce you? = BFS shortest path. Computed locally; the social graph never leaves the machine (no cloud
6// graph-mining / no contact-scraping for ad targeting -- the privacy exceed).
7//   link      <prefix> <a> <b> <date>   record an undirected edge a--b (additive, idempotent)
8//   neighbors <prefix> <id>             everyone directly connected to <id>
9//   path      <prefix> <from> <to>      shortest intro path from <from> to <to>; the intermediates = introducers
10// Integer-only, deterministic. license_tier: ORIGINAL
11import "nx_syscalls.nx"
12import "nx_canon_cid.nx"
13import "nx_seg_store.nx"
14const K_MAGIC_1970: i64 = 1970
15const K_MAGIC_4096: i64 = 4096
16const K_MAGIC_2048: i64 = 2048
17const K_MAGIC_1024: i64 = 1024
18const K_MAGIC_65536: i64 = 65536
19
20func vx_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
21func vx_p(s: *u8) -> i64 { sys_write(1, s, vx_slen(s)); return 0 }
22
23func vx_eq(a: *u8, b: *u8) -> i64 {
  var i: i64 = 0
  var go: i64 = 1
  while go == 1 { if a[i] != b[i] { return 0 } if a[i] == (0 as u8) { return 1 } i = i + 1 }
  return 0
28}
29
30func vx_dup(s: *u8) -> *u8 {
  let n: i64 = vx_slen(s)
  let d: *u8 = sys_mmap(n + 2)
  var i: i64 = 0
  while i <= n { d[i] = s[i]; i = i + 1 }
  return d
36}
37
38// lexicographic a > b (byte compare) -- for canonical edge orientation so a--b and b--a dedup to one record
39func vx_lex_gt(a: *u8, b: *u8) -> i64 {
  var i: i64 = 0
  var go: i64 = 1
  while go == 1 {
      let ca: i64 = a[i] as i64
      let cb: i64 = b[i] as i64
      if ca != cb { if ca > cb { return 1 } return 0 }
      if ca == 0 { return 0 }
      i = i + 1
  }
  return 0
50}
51
52func vx_cat(dst: *u8, off: i64, s: *u8) -> i64 {
  var i: i64 = 0
  while s[i] != (0 as u8) { dst[off + i] = s[i]; i = i + 1 }
  return off + i
56}
57
58func vx_catn(dst: *u8, off: i64, v: i64) -> i64 {
  var o: i64 = off
  var m: i64 = v
  if m < 0 { dst[o] = 45 as u8; o = o + 1; m = 0 - m }
  let t: *u8 = sys_mmap(28)
  var k: i64 = 0
  if m == 0 { t[0] = 48 as u8; k = 1 }
  while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
  var i: i64 = 0
  while i < k { dst[o + i] = t[k - 1 - i]; i = i + 1 }
  return o + k
69}
70
71func vx_kmemeq(b: *u8, off: i64, n: i64, s: *u8) -> i64 {
  if vx_slen(s) != n { return 0 }
  var i: i64 = 0
  while i < n { if b[off + i] != s[i] { return 0 } i = i + 1 }
  return 1
76}
77
78func vx_iskind(b: *u8, koff: i64, kl: i64, pfx: *u8) -> i64 {
  let pl: i64 = vx_slen(pfx)
  if kl <= pl { return 0 }
  return vx_kmemeq(b, koff, pl, pfx)
82}
83
84func vx_field(rec: *u8, rl: i64, want: *u8, out: *u8, cap: i64) -> i64 {
  if rl < 8 { return 0 }
  let nf: i64 = ss_r32(rec, 4)
  var off: i64 = 8
  var fi: i64 = 0
  while fi < nf {
      if off + 8 > rl { return 0 }
      let kl: i64 = ss_r32(rec, off)
      let koff: i64 = off + 4
      let vl: i64 = ss_r32(rec, koff + kl)
      let voff: i64 = koff + kl + 4
      if vx_kmemeq(rec, koff, kl, want) == 1 {
          var t: i64 = 0
          while t < vl { if t < cap - 1 { out[t] = rec[voff + t] } t = t + 1 }
          if t > cap - 1 { t = cap - 1 }
          out[t] = 0 as u8
          return 1
      }
      off = voff + vl
      fi = fi + 1
  }
  return 0
106}
107
108func vx_datedays(s: *u8) -> i64 {
  let nums: *i64 = sys_mmap(8 * 4) as *i64
  var nn: i64 = 0
  var cur: i64 = 0
  var indig: i64 = 0
  var i: i64 = 0
  var go: i64 = 1
  while go == 1 {
      let c: i64 = s[i] as i64
      var isd: i64 = 0
      if c >= 48 { if c <= 57 { isd = 1 } }
      if isd == 1 { cur = cur * 10 + (c - 48); indig = 1 }
      if isd == 0 { if indig == 1 { if nn < 4 { nums[nn] = cur; nn = nn + 1 } cur = 0; indig = 0 } }
      if c == 0 { go = 0 }
      i = i + 1
  }
  if nn != 3 { return 0 - 1 }
  var y: i64 = nums[0]
  let m: i64 = nums[1]
  let d: i64 = nums[2]
  if y < K_MAGIC_1970 { return 0 - 1 }
  if m < 1 { return 0 - 1 }
  if m > 12 { return 0 - 1 }
  if d < 1 { return 0 - 1 }
  if d > 31 { return 0 - 1 }
  return 1
134}
135
136// collect edge: records -> ef[],et[] (string ids); returns count
137func vx_collect_edges(prefix: *u8, ef: *i64, et: *i64) -> i64 {
  var n: i64 = 0
  let segs: *i64 = sys_mmap(8 * 260) as *i64
  let nseg: i64 = ss_manifest(prefix, segs)
  let fa: *u8 = sys_mmap(128)
  let fb: *u8 = sys_mmap(128)
  var s: i64 = 0
  while s < nseg {
      let path: *u8 = sys_mmap(512)
      var po: i64 = 0
      po = vx_cat(path, po, prefix); po = vx_cat(path, po, segs[s] as *u8); po = vx_cat(path, po, ".docs" as *u8)
      path[po] = 0 as u8
      let szp: *i64 = sys_mmap(16) as *i64
      let b: *u8 = ss_readall(path, szp)
      let sz: i64 = szp[0]
      var j: i64 = 0
      while j + 9 <= sz {
          let kind: i64 = b[j]
          let kl: i64 = ss_r32(b, j + 1)
          let koff: i64 = j + 5
          let vl: i64 = ss_r32(b, koff + kl)
          let voff: i64 = koff + kl + 4
          var take: i64 = 0
          if kind == 1 { take = vx_iskind(b, koff, kl, "edge:" as *u8) }
          if take == 1 {
              let rec: *u8 = (b as i64 + voff) as *u8
              if vx_field(rec, vl, "a" as *u8, fa, 128) == 1 {
                  vx_field(rec, vl, "b" as *u8, fb, 128)
                  if n < K_MAGIC_4096 { ef[n] = vx_dup(fa) as i64; et[n] = vx_dup(fb) as i64; n = n + 1 }
              }
          }
          j = voff + vl
      }
      s = s + 1
  }
  return n
173}
174
175func vx_intern(nid: *i64, nnp: *i64, s: *u8) -> i64 {
  var i: i64 = 0
  while i < nnp[0] { if vx_eq(nid[i] as *u8, s) == 1 { return i } i = i + 1 }
  if nnp[0] < K_MAGIC_2048 { nid[nnp[0]] = vx_dup(s) as i64; let r: i64 = nnp[0]; nnp[0] = nnp[0] + 1; return r }
  return 0 - 1
180}
181
182// ---------------- LINK ----------------
183func vx_cmd_link(argc: i64, argv: *i64) -> i64 {
  if argc < 6 { vx_p("VIZSLA-GRAPH link needs <prefix> <a> <b> <date> -- fail loud\n" as *u8); return 1 }
  let prefix: *u8 = argv[2] as *u8
  let a: *u8 = argv[3] as *u8
  let b: *u8 = argv[4] as *u8
  let date: *u8 = argv[5] as *u8
  if vx_datedays(date) < 0 { vx_p("VIZSLA-GRAPH link: bad date (YYYY-MM-DD) -- fail loud\n" as *u8); return 1 }
  if vx_eq(a, b) == 1 { vx_p("VIZSLA-GRAPH link: a==b refused (self-loop) -- fail loud\n" as *u8); return 1 }
191
  // canonical edge orientation (lexicographic) so a--b and b--a dedup to one record
  var lo: *u8 = a
  var hi: *u8 = b
  if vx_lex_gt(a, b) == 1 { lo = b; hi = a }
196
  let keys: *i64 = sys_mmap(8 * 8) as *i64
  let vals: *i64 = sys_mmap(8 * 8) as *i64
  keys[0] = "kind" as *u8 as i64; keys[1] = "a" as *u8 as i64; keys[2] = "b" as *u8 as i64; keys[3] = "date" as *u8 as i64
  vals[0] = "edge" as *u8 as i64; vals[1] = lo as i64; vals[2] = hi as i64; vals[3] = date as i64
201
  let enc: *u8 = sys_mmap(K_MAGIC_2048)
  let el: i64 = canon_encode(keys, vals, 4, enc)
  let cid: *u8 = sys_mmap(96)
  cid_of(enc, el, cid)
  let kbuf: *u8 = sys_mmap(160)
  var ko: i64 = 0
  ko = vx_cat(kbuf, ko, "edge:" as *u8); ko = vx_cat(kbuf, ko, cid); kbuf[ko] = 0 as u8
209
  var new: i64 = 1
  let pp: *i64 = sys_mmap(16) as *i64
  let ll: *i64 = sys_mmap(16) as *i64
  if ss_get_idx(prefix, kbuf, pp, ll) == 1 { new = 0 }
  var committed: i64 = 0
  let segid: i64 = sys_now_us()
  if new == 1 {
      let wr: *i64 = ss_begin()
      if ss_add(wr, 1, kbuf, enc, el) != 0 { vx_p("VIZSLA-GRAPH link: writer full -- fail loud\n" as *u8); return 1 }
      if ss_commit(prefix, wr, segid) != 0 { vx_p("VIZSLA-GRAPH link: commit FAILED -- fail loud\n" as *u8); return 1 }
      committed = 1
  }
  let rep: *u8 = sys_mmap(K_MAGIC_1024)
  var o: i64 = 0
  o = vx_cat(rep, o, "VIZSLA-GRAPH-LINK a=" as *u8); o = vx_cat(rep, o, a)
  o = vx_cat(rep, o, " b=" as *u8); o = vx_cat(rep, o, b)
  o = vx_cat(rep, o, " new=" as *u8); o = vx_catn(rep, o, new)
  o = vx_cat(rep, o, " segment=" as *u8)
  if committed == 1 { o = vx_cat(rep, o, "seg-" as *u8); o = vx_catn(rep, o, segid) } else { o = vx_cat(rep, o, "none" as *u8) }
  o = vx_cat(rep, o, "\n" as *u8)
  sys_write(1, rep, o)
  return 0
232}
233
234// ---------------- NEIGHBORS ----------------
235func vx_cmd_neighbors(argc: i64, argv: *i64) -> i64 {
  if argc < 4 { vx_p("VIZSLA-GRAPH neighbors needs <prefix> <id> -- fail loud\n" as *u8); return 1 }
  let prefix: *u8 = argv[2] as *u8
  let id: *u8 = argv[3] as *u8
  let ef: *i64 = sys_mmap(8 * K_MAGIC_4096) as *i64
  let et: *i64 = sys_mmap(8 * K_MAGIC_4096) as *i64
  let ne: i64 = vx_collect_edges(prefix, ef, et)
  let seen: *i64 = sys_mmap(8 * K_MAGIC_2048) as *i64
  var nse: i64 = 0
  let rep: *u8 = sys_mmap(K_MAGIC_65536)
  var o: i64 = 0
  o = vx_cat(rep, o, "VIZSLA-GRAPH-NEIGHBORS id=" as *u8); o = vx_cat(rep, o, id); o = vx_cat(rep, o, " nodes=" as *u8)
  var cnt: i64 = 0
  var e: i64 = 0
  while e < ne {
      var other: i64 = 0
      if vx_eq(ef[e] as *u8, id) == 1 { other = et[e] }
      if vx_eq(et[e] as *u8, id) == 1 { other = ef[e] }
      if other != 0 {
          var dup: i64 = 0
          var k: i64 = 0
          while k < nse { if vx_eq(seen[k] as *u8, other as *u8) == 1 { dup = 1; k = nse } k = k + 1 }
          if dup == 0 { if nse < K_MAGIC_2048 { seen[nse] = other; nse = nse + 1 } if cnt > 0 { o = vx_cat(rep, o, "," as *u8) } o = vx_cat(rep, o, other as *u8); cnt = cnt + 1 }
      }
      e = e + 1
  }
  if cnt == 0 { o = vx_cat(rep, o, "-" as *u8) }
  o = vx_cat(rep, o, " count=" as *u8); o = vx_catn(rep, o, cnt); o = vx_cat(rep, o, "\n" as *u8)
  sys_write(1, rep, o)
  return 0
265}
266
267// ---------------- PATH (BFS shortest intro path) ----------------
268func vx_cmd_path(argc: i64, argv: *i64) -> i64 {
  if argc < 5 { vx_p("VIZSLA-GRAPH path needs <prefix> <from> <to> -- fail loud\n" as *u8); return 1 }
  let prefix: *u8 = argv[2] as *u8
  let from: *u8 = argv[3] as *u8
  let to: *u8 = argv[4] as *u8
  let ef: *i64 = sys_mmap(8 * K_MAGIC_4096) as *i64
  let et: *i64 = sys_mmap(8 * K_MAGIC_4096) as *i64
  let ne: i64 = vx_collect_edges(prefix, ef, et)
276
  // intern nodes; build edge index pairs
  let nid: *i64 = sys_mmap(8 * K_MAGIC_2048) as *i64
  let nnp: *i64 = sys_mmap(16) as *i64
  nnp[0] = 0
  let eu: *i64 = sys_mmap(8 * K_MAGIC_4096) as *i64
  let ev: *i64 = sys_mmap(8 * K_MAGIC_4096) as *i64
  var e: i64 = 0
  while e < ne { eu[e] = vx_intern(nid, nnp, ef[e] as *u8); ev[e] = vx_intern(nid, nnp, et[e] as *u8); e = e + 1 }
  let si: i64 = vx_intern(nid, nnp, from)
  let ti: i64 = vx_intern(nid, nnp, to)
  let nn: i64 = nnp[0]
288
  // BFS
  let dist: *i64 = sys_mmap(8 * K_MAGIC_2048) as *i64
  let par: *i64 = sys_mmap(8 * K_MAGIC_2048) as *i64
  var z: i64 = 0
  while z < nn { dist[z] = 0 - 1; par[z] = 0 - 1; z = z + 1 }
  let q: *i64 = sys_mmap(8 * K_MAGIC_2048) as *i64
  var qh: i64 = 0
  var qt: i64 = 0
  dist[si] = 0; q[qt] = si; qt = qt + 1
  var found: i64 = 0
  while qh < qt {
      let u: i64 = q[qh]; qh = qh + 1
      if u == ti { found = 1; qh = qt }
      else {
          var k: i64 = 0
          while k < ne {
              var v: i64 = 0 - 1
              if eu[k] == u { v = ev[k] }
              if ev[k] == u { v = eu[k] }
              if v >= 0 { if dist[v] < 0 { dist[v] = dist[u] + 1; par[v] = u; q[qt] = v; qt = qt + 1 } }
              k = k + 1
          }
      }
  }
313
  let rep: *u8 = sys_mmap(K_MAGIC_65536)
  var o: i64 = 0
  if dist[ti] < 0 {
      o = vx_cat(rep, o, "VIZSLA-GRAPH-PATH from=" as *u8); o = vx_cat(rep, o, from)
      o = vx_cat(rep, o, " to=" as *u8); o = vx_cat(rep, o, to)
      o = vx_cat(rep, o, " length=-1 via=NONE path=NONE\n" as *u8)
      sys_write(1, rep, o)
      return 0
  }
  // reconstruct path ti -> si via parents, then reverse
  let stack: *i64 = sys_mmap(8 * K_MAGIC_2048) as *i64
  var sp: i64 = 0
  var cur: i64 = ti
  var go: i64 = 1
  while go == 1 { stack[sp] = cur; sp = sp + 1; if cur == si { go = 0 } else { cur = par[cur] } }
  let plen: i64 = dist[ti]
  o = vx_cat(rep, o, "VIZSLA-GRAPH-PATH from=" as *u8); o = vx_cat(rep, o, from)
  o = vx_cat(rep, o, " to=" as *u8); o = vx_cat(rep, o, to)
  o = vx_cat(rep, o, " length=" as *u8); o = vx_catn(rep, o, plen)
  // via = intermediates (exclude endpoints)
  o = vx_cat(rep, o, " via=" as *u8)
  var vc: i64 = 0
  var i: i64 = sp - 2
  while i >= 1 { if vc > 0 { o = vx_cat(rep, o, "," as *u8) } o = vx_cat(rep, o, nid[stack[i]] as *u8); vc = vc + 1; i = i - 1 }
  if vc == 0 { o = vx_cat(rep, o, "-" as *u8) }
  // full path from>..>to
  o = vx_cat(rep, o, " path=" as *u8)
  var p: i64 = sp - 1
  var first: i64 = 1
  while p >= 0 { if first == 0 { o = vx_cat(rep, o, ">" as *u8) } o = vx_cat(rep, o, nid[stack[p]] as *u8); first = 0; p = p - 1 }
  o = vx_cat(rep, o, "\n" as *u8)
  sys_write(1, rep, o)
  return 0
347}
348
349func main(argc: i64, argv: *i64) -> i64 {
  if argc < 2 { vx_p("VIZSLA-GRAPH usage: link|neighbors|path -- fail loud\n" as *u8); return 1 }
  let cmd: *u8 = argv[1] as *u8
  if vx_eq(cmd, "link" as *u8) == 1 { return vx_cmd_link(argc, argv) }
  if vx_eq(cmd, "neighbors" as *u8) == 1 { return vx_cmd_neighbors(argc, argv) }
  if vx_eq(cmd, "path" as *u8) == 1 { return vx_cmd_path(argc, argv) }
  vx_p("VIZSLA-GRAPH unknown command (link|neighbors|path) -- fail loud\n" as *u8)
  return 1
357}
nx_vizsla_graph.nx source

`nx_vizsla_graph.nx` source
