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

↩ module page · 530 lines · 21143 B
1// nx_vizsla_import.nx -- NISHI VIZSLA: import your existing relationships into a tenant. Operator 2026-06-22:
2// "i want to import my linkedin my email my phone etc i may be forgetting things." These all export in OPEN
3// standard formats that we parse SOVEREIGNLY (no API, no cloud, your data never leaves the machine -- the whole
4// Vizsla differentiator):
5//   vcard <base> <tid> <file.vcf>    phone / email / iCloud / Google / Outlook contacts (RFC 6350 vCard)
6//   linkedin <base> <tid> <conn.csv> LinkedIn "Connections.csv" (Settings->Data Privacy->Get a copy of your data)
7// Each parsed person -> a CONTACT line in the tenant's contacts.txt (default tier "network" -- you promote the
8// close ones); LinkedIn's "Connected On" date -> a TOUCH so imported pros aren't all flagged NEW. DEDUP vs the
9// tenant's EXISTING contact ids (read first) => re-importing is idempotent/safe. Name -> a stable handle
10// ([A-Za-z0-9-] lowercased). If the tenant has no contacts file yet, a default CONF+TIERs header is written.
11// Composes per-tenant like nx_vizsla_tenant; forks the blessed engine only to re-load LinkedIn touches.
12// license_tier: ORIGINAL  expect_exit: 1 (no args)
13import "nx_syscalls.nx"
14const K_MAGIC_65536: i64 = 65536
15const K_MAGIC_1024: i64 = 1024
16
17func vi_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
18func vi_p(s: *u8) -> i64 { sys_write(1, s, vi_slen(s)); return 0 }
19
20func vi_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
29}
30
31func vi_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
35}
36
37func vi_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
48}
49
50func vi_dup(s: *u8) -> *u8 {
  let n: i64 = vi_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
56}
57
58func vi_atoi(s: *u8) -> i64 {
  var v: i64 = 0
  var i: i64 = 0
  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 }
  return v
63}
64
65// next whitespace-delimited word of s from offset off -> out; returns new offset
66func vi_word(s: *u8, off: i64, out: *u8, cap: i64) -> i64 {
  var p: i64 = off
  while s[p] == (32 as u8) { p = p + 1 }
  var o: i64 = 0
  while s[p] != (0 as u8) {
      if s[p] == (32 as u8) { break }
      if o < cap - 1 { out[o] = s[p]; o = o + 1 }
      p = p + 1
  }
  out[o] = 0 as u8
  return p
77}
78
79func vi_find(list: *i64, n: i64, s: *u8) -> i64 {
  var i: i64 = 0
  while i < n { if vi_eq(list[i] as *u8, s) == 1 { return i } i = i + 1 }
  return 0 - 1
83}
84
85func vi_readall(path: *u8, szp: *i64) -> *u8 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { szp[0] = 0; return 0 as *u8 }
  let sz: i64 = sys_lseek(fd, 0, 2)
  sys_lseek(fd, 0, 0)
  let buf: *u8 = sys_mmap(sz + 64)
  var got: i64 = 0
  var n: i64 = 1
  while n > 0 { n = sys_read(fd, (buf as i64 + got) as *u8, K_MAGIC_65536); if n > 0 { got = got + n } }
  sys_close(fd)
  szp[0] = got
  return buf
97}
98
99// upper bound on the number of lines in `path` (newlines + 1 for a possibly-unterminated final line); 0 if
100// unreadable. Used to size the dedup set DATA-DRIVEN so no fixed cap can silently drop ids.
101func vi_count_lines(path: *u8) -> i64 {
  let szp: *i64 = sys_mmap(16) as *i64
  let b: *u8 = vi_readall(path, szp)
  let sz: i64 = szp[0]
  if sz <= 0 { return 0 }
  var nl: i64 = 0
  var i: i64 = 0
  while i < sz { if b[i] == (10 as u8) { nl = nl + 1 } i = i + 1 }
  return nl + 1
110}
111
112func vi_exists(path: *u8) -> i64 { let fd: i64 = sys_openat_rd(path); if fd < 0 { return 0 } sys_close(fd); return 1 }
113
114func vi_writefile(path: *u8, content: *u8) -> i64 {
  let fd: i64 = sys_openat_wr(path, 0x1a4)
  if fd < 0 { return 0 - 1 }
  sys_write(fd, content, vi_slen(content))
  sys_close(fd)
  return 0
120}
121
122func vi_append(path: *u8, buf: *u8, n: i64) -> i64 {
  let fd: i64 = sys_openat_append(path, 0x1a4)
  if fd < 0 { return 0 - 1 }
  sys_write(fd, buf, n)
  sys_close(fd)
  return 0
128}
129
130func vi_tpath(out: *u8, base: *u8, tid: *u8, suffix: *u8) -> i64 {
  var o: i64 = 0
  o = vi_cat(out, o, base); o = vi_cat(out, o, tid); o = vi_cat(out, o, suffix)
  out[o] = 0 as u8
  return o
135}
136
137// "John Smith" -> disp "John-Smith" (preserve case, separators->'-') + id "john-smith" (lowercased); ret len (0=empty)
138func vi_sanitize(src: *u8, disp: *u8, id: *u8) -> i64 {
  var i: i64 = 0
  var o: i64 = 0
  var lastsep: i64 = 1
  while src[i] != (0 as u8) {
      let c: i64 = src[i] as i64
      var isaln: i64 = 0
      if c >= 48 { if c <= 57 { isaln = 1 } }
      if c >= 65 { if c <= 90 { isaln = 1 } }
      if c >= 97 { if c <= 122 { isaln = 1 } }
      if isaln == 1 {
          disp[o] = c as u8
          var lc: i64 = c
          if c >= 65 { if c <= 90 { lc = c + 32 } }
          id[o] = lc as u8
          o = o + 1
          lastsep = 0
      } else {
          if lastsep == 0 { disp[o] = 45 as u8; id[o] = 45 as u8; o = o + 1; lastsep = 1 }
      }
      i = i + 1
  }
  if o > 0 { if disp[o - 1] == (45 as u8) { o = o - 1 } }
  disp[o] = 0 as u8
  id[o] = 0 as u8
  return o
164}
165
166// 3-letter English month -> 1..12 (else 0)
167func vi_mon3(s: *u8) -> i64 {
  if vi_eq(s, "Jan" as *u8) == 1 { return 1 }
  if vi_eq(s, "Feb" as *u8) == 1 { return 2 }
  if vi_eq(s, "Mar" as *u8) == 1 { return 3 }
  if vi_eq(s, "Apr" as *u8) == 1 { return 4 }
  if vi_eq(s, "May" as *u8) == 1 { return 5 }
  if vi_eq(s, "Jun" as *u8) == 1 { return 6 }
  if vi_eq(s, "Jul" as *u8) == 1 { return 7 }
  if vi_eq(s, "Aug" as *u8) == 1 { return 8 }
  if vi_eq(s, "Sep" as *u8) == 1 { return 9 }
  if vi_eq(s, "Oct" as *u8) == 1 { return 10 }
  if vi_eq(s, "Nov" as *u8) == 1 { return 11 }
  if vi_eq(s, "Dec" as *u8) == 1 { return 12 }
  return 0
181}
182
183// vCard BDAY value (e.g. "1985-07-03", "--0703", "19850703") -> "MM-DD" via last two digit-groups; ret 1 if ok
184func vi_bday_mmdd(src: *u8, out: *u8) -> i64 {
  let g: *i64 = sys_mmap(8 * 8) as *i64
  var ng: i64 = 0
  var cur: i64 = 0
  var indig: i64 = 0
  var i: i64 = 0
  var go: i64 = 1
  while go == 1 {
      let c: i64 = src[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 ng < 8 { g[ng] = cur; ng = ng + 1 } cur = 0; indig = 0 } }
      if c == 0 { go = 0 }
      i = i + 1
  }
  if ng < 2 { out[0] = 45 as u8; out[1] = 0 as u8; return 0 }
  let mm: i64 = g[ng - 2]
  let dd: i64 = g[ng - 1]
  if mm < 1 { out[0] = 45 as u8; out[1] = 0 as u8; return 0 }
  if mm > 12 { out[0] = 45 as u8; out[1] = 0 as u8; return 0 }
  if dd < 1 { out[0] = 45 as u8; out[1] = 0 as u8; return 0 }
  if dd > 31 { out[0] = 45 as u8; out[1] = 0 as u8; return 0 }
  var o: i64 = 0
  if mm < 10 { out[o] = 48 as u8; o = o + 1 }
  o = vi_catn(out, o, mm)
  out[o] = 45 as u8; o = o + 1
  if dd < 10 { out[o] = 48 as u8; o = o + 1 }
  o = vi_catn(out, o, dd)
  out[o] = 0 as u8
  return 1
215}
216
217// line [0,llen) begins with "field" then ':' or ';' ?
218func vi_field_is(line: *u8, llen: i64, field: *u8) -> i64 {
  let fl: i64 = vi_slen(field)
  if fl >= llen { return 0 }
  var j: i64 = 0
  while j < fl { if line[j] != field[j] { return 0 } j = j + 1 }
  let nx: i64 = line[fl] as i64
  if nx == 58 { return 1 }
  if nx == 59 { return 1 }
  return 0
227}
228
229// value after the first ':' in line[0,llen)
230func vi_value(line: *u8, llen: i64, out: *u8, cap: i64) -> i64 {
  var p: i64 = 0
  while p < llen { if line[p] == (58 as u8) { break } p = p + 1 }
  if p >= llen { out[0] = 0 as u8; return 0 }
  p = p + 1
  var o: i64 = 0
  while p < llen { if o < cap - 1 { out[o] = line[p]; o = o + 1 } p = p + 1 }
  out[o] = 0 as u8
  return o
239}
240
241// k-th comma field of line[0,llen) -> out (k from 0)
242func vi_csv_field(line: *u8, llen: i64, k: i64, out: *u8, cap: i64) -> i64 {
  var idx: i64 = 0
  var p: i64 = 0
  while idx < k {
      if p >= llen { out[0] = 0 as u8; return 0 }
      if line[p] == (44 as u8) { idx = idx + 1 }
      p = p + 1
  }
  var o: i64 = 0
  var go: i64 = 1
  while go == 1 {
      if p >= llen { go = 0 } else {
          if line[p] == (44 as u8) { go = 0 } else {
              if o < cap - 1 { out[o] = line[p]; o = o + 1 }
              p = p + 1
          }
      }
  }
  out[o] = 0 as u8
  return o
262}
263
264// fill seen[] with the tenant's existing CONTACT ids (so re-import is idempotent); returns count
265func vi_existing_ids(cpath: *u8, seen: *i64, ns0: i64, cap: i64) -> i64 {
  let szp: *i64 = sys_mmap(16) as *i64
  let b: *u8 = vi_readall(cpath, szp)
  let sz: i64 = szp[0]
  var ns: i64 = ns0
  if sz <= 0 { return ns }
  let tok: *u8 = sys_mmap(256)
  var i: i64 = 0
  while i < sz {
      var e: i64 = i
      var go: i64 = 1
      while go == 1 { if e >= sz { go = 0 } else { if b[e] == (10 as u8) { go = 0 } else { e = e + 1 } } }
      var le: i64 = e
      if le > i { if b[le - 1] == (13 as u8) { le = le - 1 } }
      let llen: i64 = le - i
      let line: *u8 = (b as i64 + i) as *u8
      if vi_field_is(line, llen, "CONTACT" as *u8) == 0 {
          // not "CONTACT:" form -- CONTACT lines are space-delimited, so check prefix "CONTACT "
          if llen > 8 {
              if line[0] == (67 as u8) { if line[7] == (32 as u8) {
                  var p: i64 = 8
                  var o: i64 = 0
                  while p < llen { if line[p] == (32 as u8) { break } if o < 255 { tok[o] = line[p]; o = o + 1 } p = p + 1 }
                  tok[o] = 0 as u8
                  if o > 0 { if vi_find(seen, ns, tok) < 0 { if ns < cap { seen[ns] = vi_dup(tok) as i64; ns = ns + 1 } } }
              } }
          }
      }
      i = e + 1
  }
  return ns
296}
297
298func vi_ensure_contacts(cpath: *u8, lpath: *u8) -> i64 {
  if vi_exists(cpath) == 0 { vi_writefile(cpath, "CONF soon_days 14\nTIER inner 14\nTIER close 45\nTIER network 120\n" as *u8) }
  if vi_exists(lpath) == 0 { vi_writefile(lpath, "# interaction journal (imported + manual)\n" as *u8) }
  return 0
302}
303
304func vi_emit_contact(cpath: *u8, id: *u8, disp: *u8, bday: *u8) -> i64 {
  let buf: *u8 = sys_mmap(K_MAGIC_1024)
  var o: i64 = 0
  o = vi_cat(buf, o, "CONTACT " as *u8); o = vi_cat(buf, o, id); buf[o] = 32 as u8; o = o + 1
  o = vi_cat(buf, o, disp); buf[o] = 32 as u8; o = o + 1
  o = vi_cat(buf, o, "network " as *u8); o = vi_cat(buf, o, bday); buf[o] = 10 as u8; o = o + 1
  return vi_append(cpath, buf, o)
311}
312
313func vi_emit_touch(lpath: *u8, date: *u8, id: *u8) -> i64 {
  let buf: *u8 = sys_mmap(K_MAGIC_1024)
  var o: i64 = 0
  o = vi_cat(buf, o, "TOUCH " as *u8); o = vi_cat(buf, o, date); buf[o] = 32 as u8; o = o + 1
  o = vi_cat(buf, o, id); o = vi_cat(buf, o, " connected-on-linkedin\n" as *u8)
  return vi_append(lpath, buf, o)
319}
320
321// fork+exec the blessed relate engine "load <log> <prefix>" (re-ingest imported touches)
322func vi_reload(logp: *u8, prefix: *u8) -> i64 {
  let pid: i64 = sys_fork()
  if pid == 0 {
      let argv: *i64 = sys_mmap(64) as *i64
      argv[0] = "_offc/nx_vizsla_relate.elf" as *u8 as i64
      argv[1] = "load" as *u8 as i64
      argv[2] = logp as i64
      argv[3] = prefix as i64
      argv[4] = 0
      let envp: *i64 = sys_mmap(16) as *i64
      envp[0] = 0
      sys_execve("_offc/nx_vizsla_relate.elf" as *u8, argv, envp)
      sys_exit(127)
  }
  let st: *i64 = sys_mmap(16) as *i64
  sys_wait4(pid, st, 0)
  return (st[0] >> 8) & 0xff
339}
340
341// ---------------- VCARD ----------------
342func vi_cmd_vcard(argc: i64, argv: *i64) -> i64 {
  if argc < 5 { vi_p("VIZSLA-IMPORT vcard needs <base> <tid> <file.vcf> -- fail loud\n" as *u8); return 1 }
  let base: *u8 = argv[2] as *u8
  let tid: *u8 = argv[3] as *u8
  let vpath: *u8 = argv[4] as *u8
  let cpath: *u8 = sys_mmap(K_MAGIC_1024); vi_tpath(cpath, base, tid, ".contacts.txt" as *u8)
  let lpath: *u8 = sys_mmap(K_MAGIC_1024); vi_tpath(lpath, base, tid, ".relate_log.txt" as *u8)
  vi_ensure_contacts(cpath, lpath)
350
  // DATA-DRIVEN dedup-set size: seen[] holds at most one id per line across the tenant's existing contacts
  // + the import source, so size it from their actual line counts. No fixed cap -> re-import stays idempotent
  // at any scale (this was the janitor-caps silent-truncation smell: a 4096 cap dropped ids past 4096 and
  // re-emitted them as duplicates every re-import). Eaten here, data-driven.
  let cap: i64 = vi_count_lines(cpath) + vi_count_lines(vpath)
  let seen: *i64 = sys_mmap(8 * cap) as *i64
  var ns: i64 = vi_existing_ids(cpath, seen, 0, cap)
358
  let szp: *i64 = sys_mmap(16) as *i64
  let b: *u8 = vi_readall(vpath, szp)
  let sz: i64 = szp[0]
  if sz <= 0 { vi_p("VIZSLA-IMPORT vcf MISSING/EMPTY -- fail loud\n" as *u8); return 1 }
363
  let tmp: *u8 = sys_mmap(512)
  let disp: *u8 = sys_mmap(256)
  let id: *u8 = sys_mmap(256)
  let bday: *u8 = sys_mmap(32)
  var have_fn: i64 = 0
  var have_bd: i64 = 0
  var imported: i64 = 0
  var skipped: i64 = 0
  var i: i64 = 0
  while i < sz {
      var e: i64 = i
      var go: i64 = 1
      while go == 1 { if e >= sz { go = 0 } else { if b[e] == (10 as u8) { go = 0 } else { e = e + 1 } } }
      var le: i64 = e
      if le > i { if b[le - 1] == (13 as u8) { le = le - 1 } }
      let llen: i64 = le - i
      let line: *u8 = (b as i64 + i) as *u8
      if vi_field_is(line, llen, "BEGIN" as *u8) == 1 { have_fn = 0; have_bd = 0 }
      if vi_field_is(line, llen, "FN" as *u8) == 1 {
          vi_value(line, llen, tmp, 512)
          if vi_sanitize(tmp, disp, id) > 0 { have_fn = 1 }
      }
      if vi_field_is(line, llen, "BDAY" as *u8) == 1 {
          vi_value(line, llen, tmp, 512)
          have_bd = vi_bday_mmdd(tmp, bday)
      }
      if vi_field_is(line, llen, "END" as *u8) == 1 {
          if have_fn == 1 {
              if vi_find(seen, ns, id) < 0 {
                  var bd: *u8 = "-" as *u8
                  if have_bd == 1 { bd = bday }
                  vi_emit_contact(cpath, id, disp, bd)
                  if ns < cap { seen[ns] = vi_dup(id) as i64; ns = ns + 1 }
                  imported = imported + 1
              } else { skipped = skipped + 1 }
          }
          have_fn = 0; have_bd = 0
      }
      i = e + 1
  }
404
  let rep: *u8 = sys_mmap(256)
  var o: i64 = 0
  o = vi_cat(rep, o, "VIZSLA-IMPORT-VCARD tenant=" as *u8); o = vi_cat(rep, o, tid)
  o = vi_cat(rep, o, " imported=" as *u8); o = vi_catn(rep, o, imported)
  o = vi_cat(rep, o, " skipped=" as *u8); o = vi_catn(rep, o, skipped)
  o = vi_cat(rep, o, " (review " as *u8); o = vi_cat(rep, o, cpath); o = vi_cat(rep, o, ", promote close ones from network)\n" as *u8)
  sys_write(1, rep, o)
  return 0
413}
414
415// ---------------- LINKEDIN ----------------
416func vi_cmd_linkedin(argc: i64, argv: *i64) -> i64 {
  if argc < 5 { vi_p("VIZSLA-IMPORT linkedin needs <base> <tid> <Connections.csv> -- fail loud\n" as *u8); return 1 }
  let base: *u8 = argv[2] as *u8
  let tid: *u8 = argv[3] as *u8
  let cpath0: *u8 = argv[4] as *u8
  let cpath: *u8 = sys_mmap(K_MAGIC_1024); vi_tpath(cpath, base, tid, ".contacts.txt" as *u8)
  let lpath: *u8 = sys_mmap(K_MAGIC_1024); vi_tpath(lpath, base, tid, ".relate_log.txt" as *u8)
  let prefix: *u8 = sys_mmap(K_MAGIC_1024); vi_tpath(prefix, base, tid, ".relate-" as *u8)
  vi_ensure_contacts(cpath, lpath)
425
  // DATA-DRIVEN dedup-set size (see vi_cmd_vcard): from existing-contacts + source line counts, no fixed cap.
  let cap: i64 = vi_count_lines(cpath) + vi_count_lines(cpath0)
  let seen: *i64 = sys_mmap(8 * cap) as *i64
  var ns: i64 = vi_existing_ids(cpath, seen, 0, cap)
430
  let szp: *i64 = sys_mmap(16) as *i64
  let b: *u8 = vi_readall(cpath0, szp)
  let sz: i64 = szp[0]
  if sz <= 0 { vi_p("VIZSLA-IMPORT csv MISSING/EMPTY -- fail loud\n" as *u8); return 1 }
435
  // locate header columns by name (robust to column order)
  var i_first: i64 = 0 - 1
  var i_last: i64 = 0 - 1
  var i_conn: i64 = 0 - 1
  let fld: *u8 = sys_mmap(256)
  let first: *u8 = sys_mmap(256)
  let last: *u8 = sys_mmap(256)
  let conn: *u8 = sys_mmap(256)
  let nm: *u8 = sys_mmap(512)
  let disp: *u8 = sys_mmap(256)
  let id: *u8 = sys_mmap(256)
  let mon: *u8 = sys_mmap(16)
  let dnum: *u8 = sys_mmap(16)
  let ynum: *u8 = sys_mmap(16)
  let date: *u8 = sys_mmap(32)
  var imported: i64 = 0
  var skipped: i64 = 0
  var i: i64 = 0
  while i < sz {
      var e: i64 = i
      var go: i64 = 1
      while go == 1 { if e >= sz { go = 0 } else { if b[e] == (10 as u8) { go = 0 } else { e = e + 1 } } }
      var le: i64 = e
      if le > i { if b[le - 1] == (13 as u8) { le = le - 1 } }
      let llen: i64 = le - i
      let line: *u8 = (b as i64 + i) as *u8
      if i_first < 0 {
          // still seeking the header row (the one whose first field is "First Name")
          vi_csv_field(line, llen, 0, fld, 256)
          if vi_eq(fld, "First Name" as *u8) == 1 {
              var k: i64 = 0
              while k < 16 {
                  let got: i64 = vi_csv_field(line, llen, k, fld, 256)
                  if vi_eq(fld, "First Name" as *u8) == 1 { i_first = k }
                  if vi_eq(fld, "Last Name" as *u8) == 1 { i_last = k }
                  if vi_eq(fld, "Connected On" as *u8) == 1 { i_conn = k }
                  if got == 0 { k = 16 } else { k = k + 1 }
              }
          }
      } else {
          vi_csv_field(line, llen, i_first, first, 256)
          vi_csv_field(line, llen, i_last, last, 256)
          var no: i64 = 0
          no = vi_cat(nm, no, first); nm[no] = 32 as u8; no = no + 1; no = vi_cat(nm, no, last); nm[no] = 0 as u8
          if vi_sanitize(nm, disp, id) > 0 {
              if vi_find(seen, ns, id) < 0 {
                  vi_emit_contact(cpath, id, disp, "-" as *u8)
                  if ns < cap { seen[ns] = vi_dup(id) as i64; ns = ns + 1 }
                  imported = imported + 1
                  // "Connected On" e.g. "15 Jun 2026" -> TOUCH 2026-06-15
                  if i_conn >= 0 {
                      vi_csv_field(line, llen, i_conn, conn, 256)
                      var ci: i64 = 0
                      ci = vi_word(conn, ci, dnum, 16)
                      ci = vi_word(conn, ci, mon, 16)
                      ci = vi_word(conn, ci, ynum, 16)
                      let mn: i64 = vi_mon3(mon)
                      if mn > 0 {
                          var do2: i64 = 0
                          do2 = vi_cat(date, do2, ynum); date[do2] = 45 as u8; do2 = do2 + 1
                          if mn < 10 { date[do2] = 48 as u8; do2 = do2 + 1 }
                          do2 = vi_catn(date, do2, mn); date[do2] = 45 as u8; do2 = do2 + 1
                          let dv: i64 = vi_atoi(dnum)
                          if dv < 10 { date[do2] = 48 as u8; do2 = do2 + 1 }
                          do2 = vi_catn(date, do2, dv); date[do2] = 0 as u8
                          vi_emit_touch(lpath, date, id)
                      }
                  }
              } else { skipped = skipped + 1 }
          }
      }
      i = e + 1
  }
  if i_first < 0 { vi_p("VIZSLA-IMPORT linkedin: no 'First Name' header found -- is this a LinkedIn Connections.csv? -- fail loud\n" as *u8); return 1 }
510
  vi_reload(lpath, prefix)
512
  let rep: *u8 = sys_mmap(256)
  var o: i64 = 0
  o = vi_cat(rep, o, "VIZSLA-IMPORT-LINKEDIN tenant=" as *u8); o = vi_cat(rep, o, tid)
  o = vi_cat(rep, o, " imported=" as *u8); o = vi_catn(rep, o, imported)
  o = vi_cat(rep, o, " skipped=" as *u8); o = vi_catn(rep, o, skipped)
  o = vi_cat(rep, o, " (connection dates -> TOUCHes; promote close ones from network)\n" as *u8)
  sys_write(1, rep, o)
  return 0
521}
522
523func main(argc: i64, argv: *i64) -> i64 {
  if argc < 2 { vi_p("VIZSLA-IMPORT usage: <vcard|linkedin> <base> <tenant-id> <file> -- fail loud\n" as *u8); return 1 }
  let cmd: *u8 = argv[1] as *u8
  if vi_eq(cmd, "vcard" as *u8) == 1 { return vi_cmd_vcard(argc, argv) }
  if vi_eq(cmd, "linkedin" as *u8) == 1 { return vi_cmd_linkedin(argc, argv) }
  vi_p("VIZSLA-IMPORT unknown command (vcard|linkedin) -- fail loud\n" as *u8)
  return 1
530}
nx_vizsla_import.nx source

`nx_vizsla_import.nx` source
