nx_mcp_coverage.nx source
↩ module page · 200 lines · 8083 B
1// nx_mcp_coverage.nx -- THE STANDING MCP/API EXPOSURE COVERAGE ORGAN (operator 2026-07-16: make
2// MCP+API+workstream+agent exposure a standing SOTA discipline; "small sharp tools" compose INTO
3// curated exposed capabilities; full coverage of the logical areas, NOT blind wrapping; what we
4// SHOULD expose vs not). Reads knowledge/mcp/coverage_map.txt (logical areas x should-tier x live
5// state), grades coverage, EMITS the WIRE queue (built-not-exposed, ready) + the BUILD queue (true
6// gaps) for the forge/workstreams to consume, and ENFORCES the exposure policy: a PRIMITIVE
7// (std_/fc_/sys_) or a GATE/TEST (_gate/_test/_smoke) marked as an exposed capability is a
8// POLICY-VIOLATION (the anti-blind-wrapping tooth) -- returns the violation count (0 = clean).
9// usage: nx_mcp_coverage [mapfile] exit 0 (measurement; count is the deliverable)
10// DATA SUBSTRATE (no-TSV law, 2026-07-16): the map lives in the SOVEREIGN store
11// knowledge/store/mcp_coverage key "map" (write/refresh via `nx_sov put-file`); the default
12// (no argv) reads THE STORE. An explicit mapfile arg still reads a file (gate negctl fixtures +
13// the transitional flat co-edit surface -- which is now a DERIVED view, store = SSOT).
14// license_tier: ORIGINAL expect_exit: 0
15import "nx_forge_ctx.nx"
16import "nx_sov_ledger.nx"
17const K_MAGIC_262144: i64 = 262144
18const K_MAGIC_262143: i64 = 262143
19
20// copy |-field k (0-based, "AREA"=0) of line [ls,le) into out (NUL-term); k too large -> empty.
21func mc_field(buf: *u8, ls: i64, le: i64, k: i64, out: *u8) -> i64 {
22 var field: i64 = 0
23 var o: i64 = 0
24 var i: i64 = ls
25 while i < le {
26 let c: i64 = buf[i] as i64
27 if c == 124 {
28 field = field + 1
29 if field > k { i = le }
30 }
31 if c != 124 {
32 if field == k { out[o] = c as u8; o = o + 1 }
33 }
34 if i < le { i = i + 1 }
35 }
36 out[o] = 0 as u8
37 return o
38}
39
40// is this organ name a PRIMITIVE (std_/fc_/sys_) or a GATE/TEST (_gate/_test/_smoke)? 1 = yes.
41func mc_is_internal_kind(name: *u8) -> i64 {
42 let n: i64 = std_slen(name)
43 if n >= 4 {
44 if name[0] == (115 as u8) && name[1] == (116 as u8) && name[2] == (100 as u8) && name[3] == (95 as u8) { return 1 }
45 if name[0] == (115 as u8) && name[1] == (121 as u8) && name[2] == (115 as u8) && name[3] == (95 as u8) { return 1 }
46 }
47 if n >= 3 {
48 if name[0] == (102 as u8) && name[1] == (99 as u8) && name[2] == (95 as u8) { return 1 }
49 }
50 let g: i64 = fc_contains(name, n, "_gate" as *u8, 5)
51 if g == 1 { return 1 }
52 let t: i64 = fc_contains(name, n, "_test" as *u8, 5)
53 if t == 1 { return 1 }
54 let s: i64 = fc_contains(name, n, "_smoke" as *u8, 6)
55 if s == 1 { return 1 }
56 return 0
57}
58
59// parse+grade a map already in memory (the shared core; storage-agnostic)
60func mc_run_buf(buf: *u8, n: i64) -> i64 {
61 let should: *u8 = sys_mmap(64) as *u8
62 let state: *u8 = sys_mmap(64) as *u8
63 let organ: *u8 = sys_mmap(128) as *u8
64 let area: *u8 = sys_mmap(128) as *u8
65 var live: i64 = 0
66 var exec: i64 = 0
67 var wire: i64 = 0
68 var gapb: i64 = 0
69 var intn: i64 = 0
70 var rows: i64 = 0
71 var viol: i64 = 0
72 std_putln("MCP-COVERAGE WIRE queue (built, ready to expose):" as *u8)
73 var i: i64 = 0
74 while i < n {
75 var e: i64 = i
76 var sc: i64 = 1
77 while sc == 1 {
78 if e >= n { sc = 0 }
79 if sc == 1 {
80 if buf[e] == (10 as u8) { sc = 0 }
81 if buf[e] != (10 as u8) { e = e + 1 }
82 }
83 }
84 // AREA| rows only (skip comments/blank)
85 let ll: i64 = e - i
86 if ll > 5 {
87 if buf[i] == (65 as u8) && buf[i+1] == (82 as u8) && buf[i+2] == (69 as u8) && buf[i+3] == (65 as u8) && buf[i+4] == (124 as u8) {
88 mc_field(buf, i, e, 1, area)
89 mc_field(buf, i, e, 2, should)
90 mc_field(buf, i, e, 3, state)
91 mc_field(buf, i, e, 4, organ)
92 rows = rows + 1
93 // policy consistency: primitive/gate organ marked as an EXPOSED capability = VIOLATION
94 let internalkind: i64 = mc_is_internal_kind(organ)
95 let is_internal_should: i64 = std_streq(should, "internal" as *u8)
96 if internalkind == 1 && is_internal_should == 0 {
97 viol = viol + 1
98 std_puts(" POLICY-VIOLATION area=" as *u8)
99 std_puts(area)
100 std_puts(" organ=" as *u8)
101 std_puts(organ)
102 std_putln(" is a primitive/gate marked EXPOSED (keep internal)" as *u8)
103 }
104 // state tally + queues
105 if std_streq(state, "live" as *u8) == 1 { live = live + 1 }
106 if std_streq(state, "exec" as *u8) == 1 { exec = exec + 1 }
107 if std_streq(state, "internal" as *u8) == 1 { intn = intn + 1 }
108 if std_streq(state, "wire" as *u8) == 1 {
109 wire = wire + 1
110 std_puts(" WIRE " as *u8)
111 std_puts(area)
112 std_puts(" -> " as *u8)
113 std_putln(organ)
114 }
115 if std_streq(state, "gap-build" as *u8) == 1 { gapb = gapb + 1 }
116 }
117 }
118 i = e + 1
119 }
120 std_putln("MCP-COVERAGE BUILD queue (true gaps):" as *u8)
121 // second pass for the BUILD queue print (keeps output grouped)
122 i = 0
123 while i < n {
124 var e2: i64 = i
125 var sc2: i64 = 1
126 while sc2 == 1 {
127 if e2 >= n { sc2 = 0 }
128 if sc2 == 1 {
129 if buf[e2] == (10 as u8) { sc2 = 0 }
130 if buf[e2] != (10 as u8) { e2 = e2 + 1 }
131 }
132 }
133 let ll2: i64 = e2 - i
134 if ll2 > 5 {
135 if buf[i] == (65 as u8) && buf[i+1] == (82 as u8) && buf[i+2] == (69 as u8) && buf[i+3] == (65 as u8) && buf[i+4] == (124 as u8) {
136 mc_field(buf, i, e2, 1, area)
137 mc_field(buf, i, e2, 3, state)
138 if std_streq(state, "gap-build" as *u8) == 1 {
139 std_puts(" BUILD " as *u8)
140 std_putln(area)
141 }
142 }
143 }
144 i = e2 + 1
145 }
146 let covered: i64 = live + exec
147 let pct: i64 = 0
148 var pc: i64 = 0
149 if rows > 0 { pc = covered * 100 / rows }
150 std_puts("MCP-COVERAGE SCORECARD areas=" as *u8)
151 std_pdec(rows)
152 std_puts(" live=" as *u8)
153 std_pdec(live)
154 std_puts(" exec=" as *u8)
155 std_pdec(exec)
156 std_puts(" wire=" as *u8)
157 std_pdec(wire)
158 std_puts(" gap-build=" as *u8)
159 std_pdec(gapb)
160 std_puts(" internal=" as *u8)
161 std_pdec(intn)
162 std_puts(" | covered=" as *u8)
163 std_pdec(pc)
164 std_puts("% policy-violations=" as *u8)
165 std_pdec(viol)
166 std_puts("\n" as *u8)
167 return viol
168}
169
170// file wrapper (gate fixtures + the transitional flat co-edit view)
171func mc_run(mapf: *u8) -> i64 {
172 let buf: *u8 = sys_mmap(K_MAGIC_262144) as *u8
173 let n: i64 = fc_read(mapf, buf, K_MAGIC_262143)
174 if n <= 0 { std_putln("MCP-COVERAGE map-unreadable" as *u8); return 0 - 1 }
175 return mc_run_buf(buf, n)
176}
177
178// SOVEREIGN default: the map from the seg_store (SSOT; refresh via nx_sov put-file)
179func mc_run_store() -> i64 {
180 let buf: *u8 = sys_mmap(K_MAGIC_262144) as *u8
181 let n: i64 = sov_get_copy("knowledge/store/mcp_coverage" as *u8, "map" as *u8, buf, K_MAGIC_262143)
182 if n <= 0 { std_putln("MCP-COVERAGE store map absent (seed: nx_sov put-file knowledge/store/mcp_coverage map <file>)" as *u8); return 0 - 1 }
183 std_putln("MCP-COVERAGE source=sovereign-store knowledge/store/mcp_coverage" as *u8)
184 return mc_run_buf(buf, n)
185}
186
187func main(argc: i64, argv: *i64) -> i64 {
188 var v: i64 = 0
189 if argc >= 2 {
190 let a1: i64 = argv[1]
191 let mapf: *u8 = a1 as *u8
192 v = mc_run(mapf)
193 }
194 if argc < 2 { v = mc_run_store() }
195 std_puts("MCP-COVERAGE done (violations=" as *u8)
196 std_pdec(v)
197 std_putln(")" as *u8)
198 sys_exit(0)
199 return 0
200}