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

↩ module page · 211 lines · 9390 B
1// nx_ims_monitor_live.nx -- IMS A1 LIVE RUN over the REAL published wiki corpus.
2//
3// READ-ONLY by construction: reads ONE framed corpus snapshot via sys_read_file
4// and computes in memory. Writes NOTHING to the corpus / NAS / anything (the
5// only output is the analysis report to stdout + knowledge/status log).
6//
7// The snapshot knowledge/status/ims_live_corpus.txt is a read-only capture of
8// the live HTTPS pages (each page's exact served bytes), framed as:
9//     ###PAGE /wiki/<url> <bytelen>\n  <bytelen bytes of page>  \n###ENDPAGE\n
10// The bytes ARE the live pages; the framing is just a transport so a sovereign
11// .nx organ can ingest the corpus without a network/CA-bundle dependency. The
12// link-graph ANALYSIS -- the actual A1 capability -- runs 100% in nx_ims_monitor.
13//
14// Populates NxWikiDocStore from the frames, resolves the root (start), then runs
15// nx_ims_orphans + nx_ims_dead_links and prints the findings (orphans[] +
16// dead_links[] with the exact offending target). Sovereign: nx_ims_monitor
17// (composing nx_wiki_index_builder + nx_wiki_backlinks) + nx_syscalls.
18// license_tier: ORIGINAL
19import "nx_ims_monitor.nx"
20import "nx_syscalls.nx"
21const LIVE_MAGIC_8192: i64 = 8192
22const LIVE_MAGIC_16384: i64 = 16384
23
24const LIVE_MAX_BYTES: i64 = 4194304     // 4 MB snapshot cap
25const LIVE_MARK_PAGE_N: i64 = 8         // len("###PAGE ")
26
27func lp(logfd: i64, s: *u8) -> i64 {
  var n: i64 = 0
  while s[n] != (0 as u8) { n = n + 1 }
  sys_write(1, s, n)
  if logfd > 0 { sys_write(logfd, s, n) }
  return 0
33}
34func ln_(logfd: i64, v: i64) -> i64 {
  var m: i64 = v
  if m < 0 { lp(logfd, "-\x00" as *u8); 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 }
  let bb: *u8 = sys_mmap(28)
  var i: i64 = 0
  while i < k { bb[i] = t[k - 1 - i]; i = i + 1 }
  sys_write(1, bb, k)
  if logfd > 0 { sys_write(logfd, bb, k) }
  return 0
47}
48func lb(logfd: i64, p: *u8, n: i64) -> i64 {
  var i: i64 = 0
  while i < n {
      if i >= LIVE_MAGIC_8192 { i = n }
      if i < n {
          sys_write(1, (p as i64 + i) as *u8, 1)
          if logfd > 0 { sys_write(logfd, (p as i64 + i) as *u8, 1) }
      }
      i = i + 1
  }
  return 0
59}
60
61// parse a base-10 integer starting at buf[off]; stop at first non-digit.
62// returns value; writes the STOP offset (position of the first non-digit, NOT
63// lim) via out_off so the caller can resume scanning right after the number.
64func parse_int(buf: *u8, off: i64, lim: i64, out_off: *i64) -> i64 {
  var i: i64 = off
  var v: i64 = 0
  var done: i64 = 0
  while done == 0 {
      if i >= lim { done = 1 }
      if done == 0 {
          let c: i64 = buf[i] as i64
          if c < 0x30 { done = 1 }
          if done == 0 { if c > 0x39 { done = 1 } }
          if done == 0 {
              v = v * 10 + (c - 0x30)
              i = i + 1
          }
      }
  }
  out_off[0] = i
  return v
82}
83
84// match "###PAGE " at buf[off] ? 1/0
85func is_page_mark(buf: *u8, off: i64, lim: i64) -> i64 {
  let mk: *u8 = "###PAGE \x00" as *u8
  if off + LIVE_MARK_PAGE_N > lim { return 0 }
  var i: i64 = 0
  var ok: i64 = 1
  while i < LIVE_MARK_PAGE_N {
      if buf[off + i] != mk[i] { ok = 0 }
      i = i + 1
  }
  return ok
95}
96
97func main() -> i64 {
  let logfd: i64 = sys_openat_append("knowledge/status/ims_monitor_live.log\x00" as *u8, 0x1a4)
  lp(logfd, "IMS-MONITOR LIVE RUN over real published wiki corpus (READ-ONLY)\n\x00" as *u8)
100
  // ---- read the framed snapshot (READ-ONLY) ----
  let lenbox: *i64 = sys_mmap(16) as *i64
  lenbox[0] = 0
  let buf: *u8 = sys_read_file("knowledge/status/ims_live_corpus.txt\x00" as *u8, lenbox)
  if (buf as i64) == 0 { lp(logfd, "FATAL: cannot read ims_live_corpus.txt snapshot\n\x00" as *u8); sys_exit(2) }
  let total: i64 = lenbox[0]
  lp(logfd, "snapshot bytes=\x00" as *u8); ln_(logfd, total); lp(logfd, "\n\x00" as *u8)
  if total < 1 { lp(logfd, "FATAL: empty snapshot\n\x00" as *u8); sys_exit(2) }
  if total > LIVE_MAX_BYTES { lp(logfd, "FATAL: snapshot too large\n\x00" as *u8); sys_exit(2) }
110
  // ---- populate the doc store from ###PAGE frames ----
  let store: *NxWikiDocStore = sys_mmap(512) as *NxWikiDocStore
  nx_wiki_doc_store_init(store, 64, LIVE_MAGIC_16384, LIVE_MAGIC_16384, LIVE_MAX_BYTES)
114
  var i: i64 = 0
  var npages: i64 = 0
  let oo: *i64 = sys_mmap(8) as *i64
  while i < total {
      if is_page_mark(buf, i, total) == 1 {
          // url starts after "###PAGE "
          let url_off: i64 = i + LIVE_MARK_PAGE_N
          // url runs to the next space
          var u: i64 = url_off
          var done_u: i64 = 0
          while done_u == 0 {
              if u >= total { done_u = 1 }
              if done_u == 0 {
                  if buf[u] == (0x20 as u8) { done_u = 1 }
                  if done_u == 0 { u = u + 1 }
              }
          }
          let url_n: i64 = u - url_off
          // byte length integer follows the space
          let blen: i64 = parse_int(buf, u + 1, total, oo)
          // body starts after the newline that ends the header line
          var hdr_end: i64 = oo[0]
          // advance to the \n
          var done_h: i64 = 0
          while done_h == 0 {
              if hdr_end >= total { done_h = 1 }
              if done_h == 0 {
                  if buf[hdr_end] == (0x0A as u8) { done_h = 1 }
                  if done_h == 0 { hdr_end = hdr_end + 1 }
              }
          }
          let body_off: i64 = hdr_end + 1
          var body_n: i64 = blen
          if body_off + body_n > total { body_n = total - body_off }
          // url + body pointers into the buffer (no copy; store copies internally)
          let url_p: *u8 = (buf as i64 + url_off) as *u8
          let body_p: *u8 = (buf as i64 + body_off) as *u8
          // title = url (we don't need markdown title extraction for HTML graph)
          let rid: i64 = nx_wiki_doc_store_add(store, url_p, url_n, url_p, url_n, body_p, body_n)
          if rid >= 0 { npages = npages + 1 }
          lp(logfd, "  ingested rowid=\x00" as *u8); ln_(logfd, rid); lp(logfd, " url=\x00" as *u8); lb(logfd, url_p, url_n); lp(logfd, " body_n=\x00" as *u8); ln_(logfd, body_n); lp(logfd, "\n\x00" as *u8)
          // jump past the body to keep scanning for the next ###PAGE
          i = body_off + body_n
      } else {
          i = i + 1
      }
  }
  lp(logfd, "pages ingested=\x00" as *u8); ln_(logfd, npages); lp(logfd, "\n\x00" as *u8)
163
  // ---- designate root = start.html ----
  let roots: *i64 = sys_mmap(NX_IMS_MAX_ROOTS * 8) as *i64
  roots[0] = nx_ims_resolve_root(store, "start\x00" as *u8, 5)
  lp(logfd, "root(start) rowid=\x00" as *u8); ln_(logfd, roots[0]); lp(logfd, "\n\x00" as *u8)
168
  // ---- ORPHANS ----
  let orph: *i64 = sys_mmap(NX_IMS_MAX_PAGES * 8) as *i64
  let oc: *i64 = sys_mmap(8) as *i64
  let rc_o: i64 = nx_ims_orphans(store, roots, 1, orph, NX_IMS_MAX_PAGES, oc)
  lp(logfd, "--- ORPHANS (published pages with 0 inbound links, excluding root) ---\n\x00" as *u8)
  lp(logfd, "orphans_rc=\x00" as *u8); ln_(logfd, rc_o); lp(logfd, " count=\x00" as *u8); ln_(logfd, oc[0]); lp(logfd, "\n\x00" as *u8)
  // lookup out-params for printing orphan urls
  let tp: *i64 = sys_mmap(8) as *i64; let tn: *i64 = sys_mmap(8) as *i64
  let up: *i64 = sys_mmap(8) as *i64; let un: *i64 = sys_mmap(8) as *i64
  let bp: *i64 = sys_mmap(8) as *i64; let bn: *i64 = sys_mmap(8) as *i64
  var oi: i64 = 0
  while oi < oc[0] {
      if oi >= NX_IMS_MAX_PAGES { oi = oc[0] }
      if oi < oc[0] {
          nx_wiki_doc_store_lookup(store, orph[oi], tp, tn, up, un, bp, bn)
          lp(logfd, "  ORPHAN rowid=\x00" as *u8); ln_(logfd, orph[oi]); lp(logfd, " url=\x00" as *u8); lb(logfd, up[0] as *u8, un[0]); lp(logfd, "\n\x00" as *u8)
      }
      oi = oi + 1
  }
188
  // ---- DEAD LINKS ----
  let dsrc: *i64 = sys_mmap(NX_IMS_MAX_PAGES * 8) as *i64
  let doff: *i64 = sys_mmap(NX_IMS_MAX_PAGES * 8) as *i64
  let dlen: *i64 = sys_mmap(NX_IMS_MAX_PAGES * 8) as *i64
  let dc: *i64 = sys_mmap(8) as *i64
  let rc_d: i64 = nx_ims_dead_links(store, dsrc, doff, dlen, NX_IMS_MAX_PAGES, dc)
  lp(logfd, "--- DEAD LINKS (outbound /wiki/ targets resolving to no published page) ---\n\x00" as *u8)
  lp(logfd, "dead_rc=\x00" as *u8); ln_(logfd, rc_d); lp(logfd, " count=\x00" as *u8); ln_(logfd, dc[0]); lp(logfd, "\n\x00" as *u8)
  var di: i64 = 0
  while di < dc[0] {
      if di >= NX_IMS_MAX_PAGES { di = dc[0] }
      if di < dc[0] {
          nx_wiki_doc_store_lookup(store, dsrc[di], tp, tn, up, un, bp, bn)
          let tok: *u8 = (bp[0] + doff[di]) as *u8
          lp(logfd, "  DEAD src=\x00" as *u8); lb(logfd, up[0] as *u8, un[0]); lp(logfd, " -> target=\x00" as *u8); lb(logfd, tok, dlen[di]); lp(logfd, "\n\x00" as *u8)
      }
      di = di + 1
  }
207
  lp(logfd, "LIVE RUN DONE pages=\x00" as *u8); ln_(logfd, npages); lp(logfd, " orphans=\x00" as *u8); ln_(logfd, oc[0]); lp(logfd, " dead_links=\x00" as *u8); ln_(logfd, dc[0]); lp(logfd, " (read-only; corpus untouched)\n\x00" as *u8)
  sys_exit(0)
  return 0
211}
nx_ims_monitor_live.nx source

`nx_ims_monitor_live.nx` source
