nx_forge_rag.nx source
↩ module page · 229 lines · 8389 B
1// nx_forge_rag.nx v2 (TOP-K) -- augment the coding pack with the TOP-K semantically-retrieved verified
2// organs as exemplars (was top-1; eats the noisy-top-1 debt: a single soft-margin hit can miss, k hits
3// are robust). Reuses nx_code_index internals (ci_embed + ci_store_load + ci_cos_pm) for a k-best scan
4// WITHOUT editing the gated retriever; injects each hit's source. ADDITIVE (does NOT touch fc_emit).
5// Path from basename: runtime/<name> then runtime/_hdl_build/<name>. Own rg_* file helpers.
6// usage: nx_forge_rag augment <taskfile> <basepack> <store> <port> <k> <outpack>
7// license_tier: ORIGINAL expect_exit: 0
8import "nx_code_index.nx"
9import "nx_lib_std.nx"
10import "nx_syscalls.nx"
11const RG_MAGIC_1024: i64 = 1024
12const RG_MAGIC_1000000: i64 = 1000000
13
14const RG_SRCCAP: i64 = 4096
15const RG_TASKCAP: i64 = 16384
16const RG_PACKCAP: i64 = 262144
17const RG_KMAX: i64 = 8
18
19func rg_read(path: *u8, buf: *u8, cap: i64) -> i64 {
20 let fd: i64 = sys_openat_rd(path)
21 if fd < 0 { return 0 - 1 }
22 var total: i64 = 0
23 var going: i64 = 1
24 while going == 1 {
25 let room: i64 = cap - 1 - total
26 if room <= 0 { going = 0 }
27 if going == 1 {
28 let p: *u8 = buf + total
29 let n: i64 = sys_read(fd, p, room)
30 if n <= 0 { going = 0 }
31 if n > 0 { total = total + n }
32 }
33 }
34 sys_close(fd)
35 buf[total] = 0 as u8
36 return total
37}
38
39func rg_wb(fd: i64, p: *u8, n: i64) -> i64 {
40 var off: i64 = 0
41 while off < n {
42 let q: *u8 = p + off
43 let rem: i64 = n - off
44 let w: i64 = sys_write(fd, q, rem)
45 if w <= 0 { return 0 - 1 }
46 off = off + w
47 }
48 return 0
49}
50
51func rg_ws(fd: i64, s: *u8) -> i64 {
52 let n: i64 = std_slen(s)
53 let r: i64 = rg_wb(fd, s, n)
54 return r
55}
56
57// append organ <name> source (runtime/<name> || runtime/_hdl_build/<name>) as an exemplar; ret srcbytes
58func rg_inject(fd: i64, name: *u8, pm: i64, rank: i64) -> i64 {
59 let pathb: *u8 = sys_mmap(RG_MAGIC_1024) as *u8
60 var po: i64 = 0
61 let d1: *u8 = "runtime/" as *u8
62 var di: i64 = 0
63 while d1[di] != (0 as u8) { pathb[po] = d1[di]; po = po + 1; di = di + 1 }
64 var ni: i64 = 0
65 while name[ni] != (0 as u8) { pathb[po] = name[ni]; po = po + 1; ni = ni + 1 }
66 pathb[po] = 0 as u8
67 let srcb: *u8 = sys_mmap(RG_SRCCAP) as *u8
68 var sn: i64 = rg_read(pathb, srcb, RG_SRCCAP)
69 if sn <= 0 {
70 po = 0
71 let d2: *u8 = "runtime/_hdl_build/" as *u8
72 di = 0
73 while d2[di] != (0 as u8) { pathb[po] = d2[di]; po = po + 1; di = di + 1 }
74 ni = 0
75 while name[ni] != (0 as u8) { pathb[po] = name[ni]; po = po + 1; ni = ni + 1 }
76 pathb[po] = 0 as u8
77 sn = rg_read(pathb, srcb, RG_SRCCAP)
78 }
79 rg_ws(fd, "\n\nRELATED VERIFIED EXEMPLAR #" as *u8)
80 let numb: *u8 = sys_mmap(16) as *u8
81 let nl: i64 = std_itoa(rank, numb)
82 rg_wb(fd, numb, nl)
83 rg_ws(fd, " (semantic match, cosine-permille=" as *u8)
84 let pmb: *u8 = sys_mmap(16) as *u8
85 let pl: i64 = std_itoa(pm, pmb)
86 rg_wb(fd, pmb, pl)
87 rg_ws(fd, ") -- " as *u8)
88 rg_ws(fd, name)
89 rg_ws(fd, "\n" as *u8)
90 if sn > 0 { rg_wb(fd, srcb, sn) }
91 rg_ws(fd, "\n" as *u8)
92 return sn
93}
94
95func main(argc: i64, argv: *i64) -> i64 {
96 if argc < 8 {
97 ci_ws("usage: nx_forge_rag augment <taskfile> <basepack> <store> <port> <k> <outpack>\n" as *u8)
98 sys_exit(2)
99 return 2
100 }
101 let a1: i64 = argv[1]
102 let verb: *u8 = a1 as *u8
103 if std_streq(verb, "augment" as *u8) == 0 {
104 ci_ws("unknown verb (only: augment)\n" as *u8)
105 sys_exit(2)
106 return 2
107 }
108 let a2: i64 = argv[2]
109 let a3: i64 = argv[3]
110 let a4: i64 = argv[4]
111 let a5: i64 = argv[5]
112 let a6: i64 = argv[6]
113 let a7: i64 = argv[7]
114 let taskf: *u8 = a2 as *u8
115 let basep: *u8 = a3 as *u8
116 let store: *u8 = a4 as *u8
117 let port: i64 = std_atoi(a5 as *u8)
118 var k: i64 = std_atoi(a6 as *u8)
119 let outp: *u8 = a7 as *u8
120 if k < 1 { k = 1 }
121 if k > RG_KMAX { k = RG_KMAX }
122
123 let taskb: *u8 = sys_mmap(RG_TASKCAP) as *u8
124 let tn: i64 = rg_read(taskf, taskb, RG_TASKCAP)
125 if tn <= 0 { ci_ws("[rag] task read fail\n" as *u8); sys_exit(1); return 1 }
126
127 let qv: *i64 = sys_mmap(CI_NE * 8) as *i64
128 let nt: i64 = ci_embed(port, taskb, std_slen(taskb), 1, qv)
129 if nt < 1 { ci_ws("[rag] embed fail\n" as *u8); sys_exit(1); return 1 }
130
131 let bo: *i64 = sys_mmap(8) as *i64
132 let sbytes: i64 = ci_store_load(store, bo)
133 if sbytes < 8 { ci_ws("[rag] store load fail\n" as *u8); sys_exit(1); return 1 }
134 let bi: i64 = bo[0]
135 let b: *u8 = bi as *u8
136
137 let kpm: *i64 = sys_mmap(RG_KMAX * 8) as *i64
138 let knb: i64 = (sys_mmap(RG_KMAX * CI_NAMECAP)) as i64
139 var kcount: i64 = 0
140 var ini: i64 = 0
141 while ini < k { kpm[ini] = 0 - RG_MAGIC_1000000; ini = ini + 1 }
142
143 var off: i64 = 8
144 var scanning: i64 = 1
145 while scanning == 1 {
146 if off + 16 > sbytes { scanning = 0 } else {
147 let hp: i64 = bi + off
148 let pl: *i64 = hp as *i64
149 let nlen: i64 = pl[0]
150 if nlen < 1 { scanning = 0 } else {
151 if nlen > CI_NAMECAP { scanning = 0 } else {
152 let veccells: i64 = CI_NE * 8
153 let rec_end: i64 = off + 8 + nlen + 8 + veccells
154 if rec_end > sbytes { scanning = 0 } else {
155 let vp_i: i64 = bi + off + 8 + nlen + 8
156 let vp: *i64 = vp_i as *i64
157 let pm: i64 = ci_cos_pm(qv, vp)
158 let klast: i64 = k - 1
159 if pm > kpm[klast] {
160 var pos: i64 = klast
161 var placing: i64 = 1
162 while placing == 1 {
163 if pos == 0 { placing = 0 } else {
164 let prev: i64 = pos - 1
165 if kpm[prev] >= pm { placing = 0 } else {
166 kpm[pos] = kpm[prev]
167 let dstrow: i64 = knb + pos * CI_NAMECAP
168 let srcrow: i64 = knb + prev * CI_NAMECAP
169 var cc: i64 = 0
170 while cc < CI_NAMECAP {
171 let dp: *u8 = (dstrow + cc) as *u8
172 let sp: *u8 = (srcrow + cc) as *u8
173 dp[0] = sp[0]
174 cc = cc + 1
175 }
176 pos = prev
177 }
178 }
179 }
180 kpm[pos] = pm
181 let myrow: i64 = knb + pos * CI_NAMECAP
182 let nameoff: i64 = off + 8
183 var kk: i64 = 0
184 while kk < nlen {
185 let dp2: *u8 = (myrow + kk) as *u8
186 let srcb2: i64 = bi + nameoff + kk
187 let sp2: *u8 = srcb2 as *u8
188 dp2[0] = sp2[0]
189 kk = kk + 1
190 }
191 let term: *u8 = (myrow + nlen) as *u8
192 term[0] = 0 as u8
193 if kcount < k { kcount = kcount + 1 }
194 }
195 off = rec_end
196 }
197 } }
198 }
199 }
200
201 let packb: *u8 = sys_mmap(RG_PACKCAP) as *u8
202 let pn: i64 = rg_read(basep, packb, RG_PACKCAP)
203 if pn <= 0 { ci_ws("[rag] basepack read fail\n" as *u8); sys_exit(1); return 1 }
204
205 let fd: i64 = sys_openat_wr(outp, 420)
206 if fd < 0 { ci_ws("[rag] outpack open fail\n" as *u8); sys_exit(1); return 1 }
207 let w0: i64 = rg_wb(fd, packb, pn)
208 var r: i64 = 0
209 while r < kcount {
210 let rowi: i64 = knb + r * CI_NAMECAP
211 let nmp: *u8 = rowi as *u8
212 let injd: i64 = rg_inject(fd, nmp, kpm[r], r + 1)
213 r = r + 1
214 }
215 sys_close(fd)
216
217 ci_ws("[rag] augment done k=" as *u8)
218 std_pdec(kcount)
219 ci_ws(" top1=" as *u8)
220 let top1p: *u8 = knb as *u8
221 ci_ws(top1p)
222 ci_ws(" pm=" as *u8)
223 std_pdec(kpm[0])
224 ci_ws(" packbytes=" as *u8)
225 std_pdec(pn)
226 ci_ws("\n" as *u8)
227 sys_exit(0)
228 return 0
229}