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

↩ module page · 427 lines · 17642 B
1// nx_vizsla_deal.nx -- NISHI VIZSLA business CRM: the deal/pipeline focus (operator 2026-06-23: "crm for
2// business ... with seperate focuses"). What makes a CRM more than relationship-tending: DEALS with pipeline
3// STAGES + value + a stage-weighted forecast. Same sovereign CID/seg_store plane as money (V1) + relationships
4// (V4): a deal is a record, a stage change is an ADDITIVE event (latest-by-date wins, history kept). Lives in
5// the business realm's deal store. The stage->win-probability map is the MODEL AS DATA (refine = edit, law 11).
6//   load     <dealfile> <prefix> [segid]   DEAL <id> <account> <value_cents> <title>  -> "deal:" records
7//                                          STAGE <date> <deal-id> <stage>             -> "stg:" records
8//   pipeline <prefix> <today>              per deal: latest stage, value, weighted=value*prob; verdict =
9//                                          deals/open/won/lost + total_value/won_value/weighted_pipeline
10// Stages: lead 10 / qualified 30 / proposal 50 / negotiation 70 / won 100 / lost 0 (percent). Determinism:
11// stdout has no clocks (today via argv). Loud-fail: bad value/date, unknown stage. 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_1024: i64 = 1024
21const K_MAGIC_131072: i64 = 131072
22
23func vd_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
24func vd_p(s: *u8) -> i64 { sys_write(1, s, vd_slen(s)); return 0 }
25
26func vd_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
31}
32
33func vd_dup(s: *u8) -> *u8 {
  let n: i64 = vd_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
39}
40
41func vd_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
46}
47
48func vd_digits(s: *u8) -> i64 {
  if s[0] == (0 as u8) { return 0 }
  var i: i64 = 0
  while s[i] != (0 as u8) { let d: i64 = (s[i] as i64) - 48; if d < 0 { return 0 } if d > 9 { return 0 } i = i + 1 }
  return 1
53}
54
55func vd_isws(c: i64) -> i64 {
  if c == 32 { return 1 }
  if c == 13 { return 1 }
  if c == 9 { return 1 }
  return 0
60}
61
62func vd_tok(b: *u8, off: i64, lend: i64, dst: *u8, cap: i64) -> i64 {
  var p: i64 = off
  var go: i64 = 1
  while go == 1 { if p >= lend { go = 0 } else { if vd_isws(b[p] as i64) == 1 { p = p + 1 } else { go = 0 } } }
  var t: i64 = 0
  go = 1
  while go == 1 {
      if p >= lend { go = 0 } else {
          if vd_isws(b[p] as i64) == 1 { go = 0 } else {
              if t < cap - 1 { dst[t] = b[p]; t = t + 1 }
              p = p + 1
          }
      }
  }
  dst[t] = 0 as u8
  return p
78}
79
80func vd_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
84}
85
86func vd_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
97}
98
99func vd_kmemeq(b: *u8, off: i64, n: i64, s: *u8) -> i64 {
  if vd_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
104}
105
106func vd_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 vd_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
128}
129
130func vd_iskind(b: *u8, koff: i64, kl: i64, pfx: *u8) -> i64 {
  let pl: i64 = vd_slen(pfx)
  if kl <= pl { return 0 }
  return vd_kmemeq(b, koff, pl, pfx)
134}
135
136// civil "YYYY-MM-DD" -> days since epoch (Hinnant); -1 malformed
137func vd_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 }
  if m <= 2 { y = y - 1 }
  let era: i64 = y / 400
  let yoe: i64 = y - era * 400
  var mp: i64 = m - 3
  if m <= 2 { mp = m + 9 }
  let doy: i64 = (153 * mp + 2) / 5 + d - 1
  let doe: i64 = yoe * 365 + yoe / 4 - yoe / 100 + doy
  return era * K_MAGIC_146097 + doe - K_MAGIC_719468
170}
171
172// stage -> win probability percent, or -1 if unknown (the MODEL AS DATA)
173func vd_prob(stage: *u8) -> i64 {
  if vd_eq(stage, "lead" as *u8) == 1 { return 10 }
  if vd_eq(stage, "qualified" as *u8) == 1 { return 30 }
  if vd_eq(stage, "proposal" as *u8) == 1 { return 50 }
  if vd_eq(stage, "negotiation" as *u8) == 1 { return 70 }
  if vd_eq(stage, "won" as *u8) == 1 { return 100 }
  if vd_eq(stage, "lost" as *u8) == 1 { return 0 }
  return 0 - 1
181}
182
183// canonicalize+store one record; st: [0]=writer [1]=seen [2]=nseen [3]=added [4]=dup_infile [5]=dup_instore [6]=prefix
184func vd_put(keys: *i64, vals: *i64, nf: i64, kp: *u8, st: *i64) -> i64 {
  let enc: *u8 = sys_mmap(K_MAGIC_2048)
  let el: i64 = canon_encode(keys, vals, nf, enc)
  let cid: *u8 = sys_mmap(96)
  cid_of(enc, el, cid)
  let kbuf: *u8 = sys_mmap(128)
  var ko: i64 = 0
  ko = vd_cat(kbuf, ko, kp)
  ko = vd_cat(kbuf, ko, cid)
  kbuf[ko] = 0 as u8
  let seen: *i64 = st[1] as *i64
  var fresh: i64 = 1
  var si: i64 = 0
  while si < st[2] { if vd_eq(seen[si] as *u8, kbuf) == 1 { fresh = 0; st[4] = st[4] + 1; si = st[2] } si = si + 1 }
  if fresh == 1 { if st[2] < K_MAGIC_2048 { seen[st[2]] = vd_dup(kbuf) as i64; st[2] = st[2] + 1 } }
  if fresh == 1 {
      let pp: *i64 = sys_mmap(16) as *i64
      let ll: *i64 = sys_mmap(16) as *i64
      if ss_get_idx(st[6] as *u8, kbuf, pp, ll) == 1 { fresh = 0; st[5] = st[5] + 1 }
  }
  if fresh == 1 {
      if ss_add(st[0] as *i64, 1, kbuf, enc, el) != 0 { return 0 - 1 }
      st[3] = st[3] + 1
  }
  return 0
209}
210
211// ---------------- LOAD ----------------
212func vd_cmd_load(argc: i64, argv: *i64) -> i64 {
  if argc < 4 { vd_p("VIZSLA-DEAL load needs <dealfile> <prefix> -- fail loud\n" as *u8); return 1 }
  let lfile: *u8 = argv[2] as *u8
  let prefix: *u8 = argv[3] as *u8
  var segid: i64 = 0
  if argc > 4 { segid = vd_atoi(argv[4] as *u8) }
  if segid == 0 { segid = sys_now_us() }
219
  let szp: *i64 = sys_mmap(16) as *i64
  let b: *u8 = ss_readall(lfile, szp)
  let sz: i64 = szp[0]
  if sz <= 0 { vd_p("VIZSLA-DEAL dealfile MISSING/EMPTY -- fail loud\n" as *u8); return 1 }
224
  let dkeys: *i64 = sys_mmap(8 * 8) as *i64
  let dvals: *i64 = sys_mmap(8 * 8) as *i64
  dkeys[0] = "kind" as *u8 as i64; dkeys[1] = "id" as *u8 as i64; dkeys[2] = "account" as *u8 as i64
  dkeys[3] = "value" as *u8 as i64; dkeys[4] = "title" as *u8 as i64
  dvals[0] = "deal" as *u8 as i64
  let skeys: *i64 = sys_mmap(8 * 8) as *i64
  let svals: *i64 = sys_mmap(8 * 8) as *i64
  skeys[0] = "kind" as *u8 as i64; skeys[1] = "date" as *u8 as i64; skeys[2] = "deal" as *u8 as i64; skeys[3] = "stage" as *u8 as i64
  svals[0] = "stg" as *u8 as i64
234
  let st: *i64 = sys_mmap(8 * 8) as *i64
  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
237
  let t0: *u8 = sys_mmap(128)
  let f1: *u8 = sys_mmap(128)
  let f2: *u8 = sys_mmap(128)
  let f3: *u8 = sys_mmap(128)
  let f4: *u8 = sys_mmap(256)
  var scanned: 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 p: i64 = vd_tok(b, i, e, t0, 128)
      if t0[0] == (35 as u8) { t0[0] = 0 as u8 }
      if vd_eq(t0, "DEAL" as *u8) == 1 {
          p = vd_tok(b, p, e, f1, 128); p = vd_tok(b, p, e, f2, 128); p = vd_tok(b, p, e, f3, 128); p = vd_tok(b, p, e, f4, 256)
          if f1[0] == (0 as u8) { vd_p("VIZSLA-DEAL DEAL missing id -- fail loud\n" as *u8); return 1 }
          if f2[0] == (0 as u8) { vd_p("VIZSLA-DEAL DEAL missing account -- fail loud\n" as *u8); return 1 }
          if vd_digits(f3) == 0 { vd_p("VIZSLA-DEAL DEAL value not digits (cents) -- fail loud\n" as *u8); return 1 }
          if f4[0] == (0 as u8) { vd_p("VIZSLA-DEAL DEAL missing title -- fail loud\n" as *u8); return 1 }
          dvals[1] = f1 as i64; dvals[2] = f2 as i64; dvals[3] = f3 as i64; dvals[4] = f4 as i64
          scanned = scanned + 1
          if vd_put(dkeys, dvals, 5, "deal:" as *u8, st) != 0 { vd_p("VIZSLA-DEAL writer full -- fail loud\n" as *u8); return 1 }
      }
      if vd_eq(t0, "STAGE" as *u8) == 1 {
          p = vd_tok(b, p, e, f1, 128); p = vd_tok(b, p, e, f2, 128); p = vd_tok(b, p, e, f3, 128)
          if vd_datedays(f1) < 0 { vd_p("VIZSLA-DEAL STAGE bad date -- fail loud\n" as *u8); return 1 }
          if f2[0] == (0 as u8) { vd_p("VIZSLA-DEAL STAGE missing deal-id -- fail loud\n" as *u8); return 1 }
          if vd_prob(f3) < 0 { vd_p("VIZSLA-DEAL STAGE unknown stage (lead|qualified|proposal|negotiation|won|lost) -- fail loud\n" as *u8); return 1 }
          svals[1] = f1 as i64; svals[2] = f2 as i64; svals[3] = f3 as i64
          scanned = scanned + 1
          if vd_put(skeys, svals, 4, "stg:" as *u8, st) != 0 { vd_p("VIZSLA-DEAL writer full -- fail loud\n" as *u8); return 1 }
      }
      i = e + 1
  }
272
  var committed: i64 = 0
  if st[3] > 0 {
      if ss_commit(prefix, st[0] as *i64, segid) != 0 { vd_p("VIZSLA-DEAL commit FAILED -- fail loud\n" as *u8); return 1 }
      committed = 1
  }
278
  let rep: *u8 = sys_mmap(K_MAGIC_4096)
  var o: i64 = 0
  o = vd_cat(rep, o, "VIZSLA-DEAL-LOAD scanned=" as *u8); o = vd_catn(rep, o, scanned)
  o = vd_cat(rep, o, " new=" as *u8); o = vd_catn(rep, o, st[3])
  o = vd_cat(rep, o, " dup_infile=" as *u8); o = vd_catn(rep, o, st[4])
  o = vd_cat(rep, o, " dup_instore=" as *u8); o = vd_catn(rep, o, st[5])
  o = vd_cat(rep, o, " segment=" as *u8)
  if committed == 1 { o = vd_cat(rep, o, "seg-" as *u8); o = vd_catn(rep, o, segid) } else { o = vd_cat(rep, o, "none" as *u8) }
  o = vd_cat(rep, o, "\n" as *u8)
  sys_write(1, rep, o)
  return 0
290}
291
292// ---------------- PIPELINE ----------------
293func vd_cmd_pipeline(argc: i64, argv: *i64) -> i64 {
  if argc < 3 { vd_p("VIZSLA-DEAL pipeline needs <prefix> [today] -- fail loud\n" as *u8); return 1 }
  let prefix: *u8 = argv[2] as *u8
296
  let d_id: *i64 = sys_mmap(8 * K_MAGIC_1024) as *i64
  let d_acct: *i64 = sys_mmap(8 * K_MAGIC_1024) as *i64
  let d_val: *i64 = sys_mmap(8 * K_MAGIC_1024) as *i64
  let d_stage: *i64 = sys_mmap(8 * K_MAGIC_1024) as *i64
  let d_sdate: *i64 = sys_mmap(8 * K_MAGIC_1024) as *i64
  var nd: i64 = 0
  let s_deal: *i64 = sys_mmap(8 * K_MAGIC_2048) as *i64
  let s_date: *i64 = sys_mmap(8 * K_MAGIC_2048) as *i64
  let s_stage: *i64 = sys_mmap(8 * K_MAGIC_2048) as *i64
  var ns: i64 = 0
307
  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)
  let fc: *u8 = sys_mmap(256)
  let fd: *u8 = sys_mmap(128)
  var s: i64 = 0
  while s < nseg {
      let path: *u8 = sys_mmap(512)
      var po: i64 = 0
      po = vd_cat(path, po, prefix); po = vd_cat(path, po, segs[s] as *u8); po = vd_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
          let rec: *u8 = (b as i64 + voff) as *u8
          var isd: i64 = 0
          var iss: i64 = 0
          if kind == 1 { isd = vd_iskind(b, koff, kl, "deal:" as *u8) }
          if kind == 1 { iss = vd_iskind(b, koff, kl, "stg:" as *u8) }
          if isd == 1 {
              if vd_field(rec, vl, "id" as *u8, fa, 128) == 1 {
                  if nd < K_MAGIC_1024 {
                      vd_field(rec, vl, "account" as *u8, fb, 128)
                      vd_field(rec, vl, "value" as *u8, fd, 128)
                      vd_field(rec, vl, "title" as *u8, fc, 256)
                      d_id[nd] = vd_dup(fa) as i64
                      d_acct[nd] = vd_dup(fb) as i64
                      d_val[nd] = vd_atoi(fd)
                      d_stage[nd] = "(none)" as *u8 as i64
                      d_sdate[nd] = 0 - 1
                      nd = nd + 1
                  }
              }
          }
          if iss == 1 {
              if vd_field(rec, vl, "deal" as *u8, fa, 128) == 1 {
                  if ns < K_MAGIC_2048 {
                      vd_field(rec, vl, "date" as *u8, fb, 128)
                      vd_field(rec, vl, "stage" as *u8, fc, 256)
                      s_deal[ns] = vd_dup(fa) as i64
                      s_date[ns] = vd_datedays(fb)
                      s_stage[ns] = vd_dup(fc) as i64
                      ns = ns + 1
                  }
              }
          }
          j = voff + vl
      }
      s = s + 1
  }
366
  // latest stage per deal (by date)
  var di: i64 = 0
  while di < nd {
      var k: i64 = 0
      while k < ns {
          if vd_eq(s_deal[k] as *u8, d_id[di] as *u8) == 1 { if s_date[k] > d_sdate[di] { d_sdate[di] = s_date[k]; d_stage[di] = s_stage[k] } }
          k = k + 1
      }
      di = di + 1
  }
377
  let rep: *u8 = sys_mmap(K_MAGIC_131072)
  var o: i64 = 0
  var nopen: i64 = 0
  var nwon: i64 = 0
  var nlost: i64 = 0
  var total: i64 = 0
  var wonv: i64 = 0
  var wpipe: i64 = 0
  var i2: i64 = 0
  while i2 < nd {
      let stage: *u8 = d_stage[i2] as *u8
      let val: i64 = d_val[i2]
      var prob: i64 = vd_prob(stage)
      if prob < 0 { prob = 0 }
      total = total + val
      var stt: *u8 = "OPEN" as *u8
      var weighted: i64 = 0
      if vd_eq(stage, "won" as *u8) == 1 { stt = "WON" as *u8; nwon = nwon + 1; wonv = wonv + val }
      if vd_eq(stage, "lost" as *u8) == 1 { stt = "LOST" as *u8; nlost = nlost + 1 }
      if vd_eq(stt, "OPEN" as *u8) == 1 { nopen = nopen + 1; weighted = val * prob / 100; wpipe = wpipe + weighted }
      o = vd_cat(rep, o, "VIZSLA-DEAL-PIPE deal=" as *u8); o = vd_cat(rep, o, d_id[i2] as *u8)
      o = vd_cat(rep, o, " account=" as *u8); o = vd_cat(rep, o, d_acct[i2] as *u8)
      o = vd_cat(rep, o, " stage=" as *u8); o = vd_cat(rep, o, stage)
      o = vd_cat(rep, o, " value=" as *u8); o = vd_catn(rep, o, val)
      o = vd_cat(rep, o, " prob=" as *u8); o = vd_catn(rep, o, prob)
      o = vd_cat(rep, o, " weighted=" as *u8); o = vd_catn(rep, o, weighted)
      o = vd_cat(rep, o, " state=" as *u8); o = vd_cat(rep, o, stt)
      o = vd_cat(rep, o, "\n" as *u8)
      i2 = i2 + 1
  }
  o = vd_cat(rep, o, "VIZSLA-DEAL-PIPE-VERDICT deals=" as *u8); o = vd_catn(rep, o, nd)
  o = vd_cat(rep, o, " open=" as *u8); o = vd_catn(rep, o, nopen)
  o = vd_cat(rep, o, " won=" as *u8); o = vd_catn(rep, o, nwon)
  o = vd_cat(rep, o, " lost=" as *u8); o = vd_catn(rep, o, nlost)
  o = vd_cat(rep, o, " total_value=" as *u8); o = vd_catn(rep, o, total)
  o = vd_cat(rep, o, " won_value=" as *u8); o = vd_catn(rep, o, wonv)
  o = vd_cat(rep, o, " weighted_pipeline=" as *u8); o = vd_catn(rep, o, wpipe)
  o = vd_cat(rep, o, "\n" as *u8)
  sys_write(1, rep, o)
  return 0
418}
419
420func main(argc: i64, argv: *i64) -> i64 {
  if argc < 2 { vd_p("VIZSLA-DEAL usage: load|pipeline -- fail loud\n" as *u8); return 1 }
  let cmd: *u8 = argv[1] as *u8
  if vd_eq(cmd, "load" as *u8) == 1 { return vd_cmd_load(argc, argv) }
  if vd_eq(cmd, "pipeline" as *u8) == 1 { return vd_cmd_pipeline(argc, argv) }
  vd_p("VIZSLA-DEAL unknown command (load|pipeline) -- fail loud\n" as *u8)
  return 1
427}
nx_vizsla_deal.nx source

`nx_vizsla_deal.nx` source
