antcolony

31.0 KB

1. // report.hl — `report <file> [--post]`: validate a worker's JSON report (docs/scheduler-agent.md §4)
2. // and, with --post, file it.
3. //
4. // VALIDATION (prints every problem, one line each, with its JSON path):
5. // the file is one JSON object; exactly the keys ticket, session, result, complete, test, done, verified, open, issues,
6. // questions, running, refused — all present (lists may be empty), no others;
7. // (mission 026) complete = true | false: true only if the ticket's goal is reached AND what the creator should test is
8. // really in place (e.g. copied into the app, not only a work copy);
9. // (mission 023, README "Ticket texts are written for the creator") result = ONE plain sentence, one line,
10. // ≤ 200 characters; test = 1–4 steps, each one line ≤ 200 characters — they ARE the ticket comment;
11. // ticket = "<project>#<n>"; session a non-empty string; done/open/questions/refused lists of
12. // non-empty strings; verified[] = { claim, command, output } all non-empty strings (no output →
13. // refused); issues[] = { project, subject, repro, observed, expected: non-empty strings, blocks:
14. // boolean }; running[] = { what: non-empty, url, log: strings, pid: number }; no unknown keys
15. // anywhere. An issues[].project that is not in the registry is NOT a refusal: it is reported
16. // and becomes a creator question on --post (concept: "else → creator's inbox").
17. //
18. // --post (idempotent per report; the key is the session, the report's sha256 proves "the same"):
19. // 1. the ticket must exist; if it already has a comment carrying `colony-report: <session> ·`
20. // with the SAME sha → the comment and the state are not touched again; a DIFFERENT sha →
21. // refused (one session, one report);
22. // 2. every issue → a ticket in its project (source `colony-report:<session>:issue:<i>`, so a
23. // re-post answers the existing ticket and writes nothing), summary links back;
24. // an unknown project → a creator question (project antcolony, `awaiting creator`, source
25. // `colony-report:<session>:question:<i>`);
26. // 3. ONE short comment on the ticket (mission 023): result · **Test:** steps · ≤ 3 detail bullets (questions,
27. // filed problems, not done, running, refused — what matters most first) · ONE machine line
28. // `colony-report: <session> · sha256 <12 hex>[ · controller pass]`; the full report stays in runs/<session>/;
29. // 2b. (mission 022) an issue with `blocks: true` → the ticket gets it as a blocker (`blocked-by`, once);
30. // every `questions` entry → its own ticket in the TICKET's project, `awaiting creator`, parent = the
31. // ticket (source `colony-report:<session>:questions:<i>`); the comment links them;
32. // 4. the ticket → `awaiting creator` (never `confirmed`), only when the comment was new in this
33. // run and the ticket is not already there / closed.
34. // (mission 027) result ≤ 120 characters; test = 2–4 steps of ≤ 90 characters, no work copy (`.scratch`), on a project with
35. // `live` no local address; questions ≤ 3, each ≤ 3 lines / 300 characters; `decided` (optional key, one line ≤ 120 each)
36. // = small choices the worker made itself → ONE detail bullet "Decided: …". The Test steps are a numbered list.
37. // DEPLOY GATE: a complete report on a project with `live` → "Built — goes live with the next deploy." + marker
38. // `· ready to deploy`, the ticket stays `in progress` (deploy.hl: `./colony ready`, `./colony deployed`).
39. // (mission 026) `complete: false` = HALF DONE: the comment is "Half done: <result>; the next worker continues." + what is
40. // still open (no Test steps; machine line ends `· half done`), and the ticket goes back to `open` (only from
41. // `in progress`, i.e. the lease) — never `awaiting creator`. Questions / issues are filed as usual.
42. import { sha256 } from 'hl:crypto'
43. import { loadRegistry } from './registry.hl'
44. import { getJson, postJson, readToken, ticketPath, pageUrl, fileQuestion, fileQuestionIn } from './tickets.hl'
45. import { NL, readJson, fromCwd, isList, isObject, isString, nonEmpty, positionals } from './util.hl'
47. static TOP = ['ticket' 'session' 'result' 'complete' 'test' 'done' 'verified' 'open' 'issues' 'questions' 'decided' 'running' 'refused']
48. // mission 027: `decided` may be missing (reports written before it) — it counts as []
49. static OPTIONAL = ['decided']
50. // mission 027 (first live batch: run-on test lines, work-copy paths, too many / too long questions)
51. static RESULT_MAX = 120
52. static STEP_MAX = 90
53. static TEST_MIN = 2
54. static TEST_MAX = 4
55. static DECIDED_MAX = 120
56. static QUESTION_LINES = 3
57. static QUESTION_CHARS = 300
58. static QUESTION_TITLE_MAX = 80
59. static STRING_LISTS = ['done' 'open' 'questions' 'decided' 'refused']
60. static VERIFIED = ['claim' 'command' 'output']
61. static ISSUE = ['project' 'subject' 'repro' 'observed' 'expected' 'blocks']
62. static ISSUE_TEXT = ['project' 'subject' 'repro' 'observed' 'expected']
63. static RUNNING = ['what' 'url' 'pid' 'log']
65. static typeOf = (v) => {
66. if (v == null) { return 'null' }
67. if (isList(v)) { return 'list' }
68. if (isObject(v)) { return 'object' }
69. return hlTypeName(v).toLowerCase()
70. }
72. // "<project>#<n>" → { project, number } or null
73. static parseRef = (s) => {
74. let h = s.indexOf('#')
75. if (h <= 0 || h == s.length - 1) { return null }
76. let p = s.slice(0, h)
77. let n = s.slice(h + 1)
78. let i = 0
79. while (i < n.length) {
80. let c = n.charCodeAt(i)
81. if (c < 48 || c > 57) { return null }
82. i = i + 1
83. }
84. if (n.startsWith('0')) { return null }
85. return { project = p number = n }
86. }
88. // unknown keys of an object entry → problems
89. static unknownKeys = (obj, allowed, path, problems) => {
90. for (k of obj.keys()) {
91. if (!allowed.includes(k)) { problems.push(path + ": unknown field '" + k + "' (allowed: " + allowed.join(', ') + ')') }
92. }
93. }
95. // a one-line text for the creator (at most `max` characters) → the problem or null
96. static lineProblem = (v, max) => {
97. if (!isString(v)) { return 'must be a string, not a ' + typeOf(v) }
98. if (v.trim() == '') { return 'must not be empty' }
99. if (v.includes(NL)) { return 'must be ONE line (no line breaks)' }
100. if (v.length > max) { return 'is ' + v.length + ' characters long, at most ' + max }
101. return null
102. }
104. // mission 027: the registry entry of the report's project (null when unknown / no ticket)
105. static projectOf = (report, reg) => {
106. if (!isString(report.ticket)) { return null }
107. let pr = parseRef(report.ticket)
108. if (pr == null) { return null }
109. return reg.projects[pr.project]
110. }
112. // mission 027: a test step is for the creator on the REAL thing — never a work copy; on a project with a live site
113. // never a local address → the problem or null
114. static stepPlaceProblem = (v, m) => {
115. let low = v.toLowerCase()
116. if (low.includes('.scratch')) { return 'names a work copy (.scratch) — the creator tests the real thing' + (m != null && m.live != null && m.live.url != null ? ' on ' + m.live.url : '') }
117. if (m != null && m.live != null && (low.includes('localhost') || low.includes('127.0.0.1') || low.includes('0.0.0.0'))) { return 'names a local address — write the step for the live site ' + (m.live.url != null ? m.live.url : '') + ' (the creator tests after the deploy)' }
118. return null
119. }
121. // → { problems: [text], notes: [text], report }
122. static validate = (report, reg) => {
123. let problems = []
124. let notes = []
125. if (!isObject(report)) {
126. problems.push('the report must be one JSON object, not a ' + typeOf(report))
127. return { problems = problems notes = notes }
128. }
129. unknownKeys(report, TOP, '(top)', problems)
130. for (k of TOP) {
131. if (report.keys().includes(k) == false) { if (!OPTIONAL.includes(k)) { problems.push("(top): field '" + k + "' is missing (every field is required; use [] for an empty list)") } }
132. else if (report[k] == null) { problems.push(k + ': must not be null' + (k == 'ticket' || k == 'session' ? '' : ' (use [] for an empty list)')) }
133. }
134. // ticket, session
135. if (report.ticket != null) {
136. if (!isString(report.ticket)) { problems.push('ticket: must be a string "<project>#<number>", not a ' + typeOf(report.ticket)) }
137. else if (parseRef(report.ticket) == null) { problems.push('ticket: "' + report.ticket + '" is not "<project>#<number>" (e.g. "tickets.worldapi.org#9")') }
138. }
139. if (report.session != null && !nonEmpty(report.session)) { problems.push('session: must be a non-empty string') }
140. // mission 026: finished or not
141. if (report.complete != null && hlTypeName(report.complete) != 'Boolean') { problems.push('complete: must be true or false, not a ' + typeOf(report.complete) + ' (true only if the goal is reached AND what the creator should test is really in place)') }
142. // mission 023: result + test are what the creator reads — short, plain, one line each
143. // mission 027: result ≤ 120 characters; test = 2–4 steps of ≤ 90 characters each, for the creator on the live site
144. if (report.result != null) {
145. let lp = lineProblem(report.result, RESULT_MAX)
146. if (lp != null) { problems.push('result: ' + lp + ' (ONE plain sentence: what is done)') }
147. }
148. let pm = projectOf(report, reg)
149. let tst = report.test
150. if (tst != null) {
151. if (!isList(tst)) { problems.push('test: must be a list of ' + TEST_MIN + '–' + TEST_MAX + ' short steps, not a ' + typeOf(tst)) }
152. else if (tst.length < TEST_MIN || tst.length > TEST_MAX) { problems.push('test: must have ' + TEST_MIN + '–' + TEST_MAX + ' steps, has ' + tst.length) }
153. else {
154. let ti = 0
155. while (ti < tst.length) {
156. let tp = lineProblem(tst[ti], STEP_MAX)
157. if (tp == null) { tp = stepPlaceProblem(tst[ti], pm) }
158. if (tp != null) { problems.push('test[' + ti + ']: ' + tp) }
159. ti = ti + 1
160. }
161. }
162. }
163. // mission 027: short questions (antcolony#24: no count limit — the check after the job rules on each); small choices go to `decided` (one line each)
164. let qv = report.questions
165. if (qv != null && isList(qv)) {
166. let qi = 0
167. while (qi < qv.length) {
168. // antcolony#23: an entry is { title, text } (title = the short subject the worker writes); a plain string (old reports) still counts as the text
169. let qe = qv[qi]
170. let qx = qe
171. if (isObject(qe)) {
172. unknownKeys(qe, ['title' 'text'], 'questions[' + qi + ']', problems)
173. qx = qe.text
174. if (!nonEmpty(qe.title)) { problems.push('questions[' + qi + ']: title must be a non-empty string (a short subject, e.g. "how long should a login last?")') }
175. else {
176. let tp = lineProblem(qe.title, QUESTION_TITLE_MAX)
177. if (tp != null) { problems.push('questions[' + qi + '].title: ' + tp) }
178. }
179. }
180. if (nonEmpty(qx)) {
181. let nl = 0
182. for (l of qx.trim().split(NL)) { if (l.trim() != '') { nl = nl + 1 } }
183. if (nl > QUESTION_LINES) { problems.push('questions[' + qi + ']: has ' + nl + ' lines, at most ' + QUESTION_LINES + ' (the question, then the options)') }
184. if (qx.length > QUESTION_CHARS) { problems.push('questions[' + qi + ']: is ' + qx.length + ' characters long, at most ' + QUESTION_CHARS) }
185. } else if (isObject(qe)) { problems.push('questions[' + qi + ']: text must be a non-empty string') }
186. qi = qi + 1
187. }
188. }
189. let dv = report.decided
190. if (dv != null && isList(dv)) {
191. let di = 0
192. while (di < dv.length) {
193. if (isString(dv[di]) && dv[di].trim() != '') {
194. let dp = lineProblem(dv[di], DECIDED_MAX)
195. if (dp != null) { problems.push('decided[' + di + ']: ' + dp) }
196. }
197. di = di + 1
198. }
199. }
200. // lists of strings
201. for (k of STRING_LISTS) {
202. let v = report[k]
203. if (v != null) {
204. if (!isList(v)) { problems.push(k + ': must be a list of strings, not a ' + typeOf(v)) } else {
205. let i = 0
206. while (i < v.length) {
207. if (k == 'questions' && isObject(v[i])) { } else if (!nonEmpty(v[i])) { problems.push(k + '[' + i + ']: must be a non-empty string, not ' + (isString(v[i]) ? 'an empty one' : 'a ' + typeOf(v[i]))) }
208. i = i + 1
209. }
210. }
211. }
212. }
213. // verified
214. let v = report.verified
215. if (v != null) {
216. if (!isList(v)) { problems.push('verified: must be a list of { claim, command, output }, not a ' + typeOf(v)) } else {
217. let i = 0
218. while (i < v.length) {
219. let e = v[i]
220. let at = 'verified[' + i + ']'
221. if (!isObject(e)) { problems.push(at + ': must be an object { claim, command, output }, not a ' + typeOf(e)) } else {
222. unknownKeys(e, VERIFIED, at, problems)
223. for (f of VERIFIED) {
224. if (e[f] == null) { problems.push(at + ": '" + f + "' is missing" + (f == 'claim' ? '' : ' (every verified entry needs command AND output)')) }
225. else if (!isString(e[f])) { problems.push(at + ": '" + f + "' must be a string, not a " + typeOf(e[f])) }
226. else if (e[f].trim() == '') { problems.push(at + ": '" + f + "' is empty" + (f == 'claim' ? '' : ' (every verified entry needs command AND output)')) }
227. }
228. }
229. i = i + 1
230. }
231. }
232. }
233. // issues
234. let is = report.issues
235. if (is != null) {
236. if (!isList(is)) { problems.push('issues: must be a list of { project, subject, repro, observed, expected, blocks }, not a ' + typeOf(is)) } else {
237. let i = 0
238. while (i < is.length) {
239. let e = is[i]
240. let at = 'issues[' + i + ']'
241. if (!isObject(e)) { problems.push(at + ': must be an object, not a ' + typeOf(e)) } else {
242. unknownKeys(e, ISSUE, at, problems)
243. for (f of ISSUE_TEXT) {
244. if (e[f] == null) { problems.push(at + ": '" + f + "' is missing") }
245. else if (!isString(e[f])) { problems.push(at + ": '" + f + "' must be a string, not a " + typeOf(e[f])) }
246. else if (e[f].trim() == '') { problems.push(at + ": '" + f + "' is empty") }
247. }
248. if (e.blocks == null) { problems.push(at + ": 'blocks' is missing (true or false)") }
249. else if (hlTypeName(e.blocks) != 'Boolean') { problems.push(at + ": 'blocks' must be true or false, not a " + typeOf(e.blocks)) }
250. if (nonEmpty(e.project) && reg.projects[e.project] == null) {
251. notes.push(at + ": project '" + e.project + "' is not in the registry (" + reg.names.join(', ') + ') → becomes a creator question on --post')
252. }
253. }
254. i = i + 1
255. }
256. }
257. }
258. // running
259. let rn = report.running
260. if (rn != null) {
261. if (!isList(rn)) { problems.push('running: must be a list of { what, url, pid, log }, not a ' + typeOf(rn)) } else {
262. let i = 0
263. while (i < rn.length) {
264. let e = rn[i]
265. let at = 'running[' + i + ']'
266. if (!isObject(e)) { problems.push(at + ': must be an object, not a ' + typeOf(e)) } else {
267. unknownKeys(e, RUNNING, at, problems)
268. if (e.what == null) { problems.push(at + ": 'what' is missing") } else if (!nonEmpty(e.what)) { problems.push(at + ": 'what' must be a non-empty string") }
269. for (f of ['url' 'log']) {
270. if (e[f] == null) { problems.push(at + ": '" + f + "' is missing (\"\" when there is none)") } else if (!isString(e[f])) { problems.push(at + ": '" + f + "' must be a string, not a " + typeOf(e[f])) }
271. }
272. if (e.pid == null) { problems.push(at + ": 'pid' is missing") } else if (hlTypeName(e.pid) != 'Number') { problems.push(at + ": 'pid' must be a number, not a " + typeOf(e.pid)) }
273. }
274. i = i + 1
275. }
276. }
277. }
278. return { problems = problems notes = notes }
279. }
281. // ---- the texts for the creator (mission 023, README "Ticket texts are written for the creator") ----------
282. // the first line of a text, at most n characters
283. static oneLine = (s, n) => {
284. let t = s.trim()
285. let nl = t.indexOf(NL)
286. if (nl > 0) { t = t.slice(0, nl).trim() }
287. if (t.length > n) { t = t.slice(0, n - 1).trim() + '…' }
288. return t
289. }
291. // `alpha#3` → `alpha #3` (the way tickets shows a ticket, mission 023: one link style everywhere)
292. static refLabel = (ref) => { return ref.replaceAll('#', ' #') }
294. // a ticket row → `[alpha #7](url)`
295. static linkOf = (t) => { return '[' + t.project + ' ' + t.ref + '](' + pageUrl(t) + ')' }
297. // the report comment: result · **Test:** steps · ≤ 3 detail bullets · the machine line (hash null → none).
298. // filed = [{ link, blocks, unknown }] (the report's issues, filed), asked = [link] (the question tickets),
299. // note = text for the end of the machine line (e.g. 'controller pass') or null
300. // (mission 026) a HALF DONE report (`complete: false`): "Half done: <result>; the next worker continues." + what is still
301. // open first, no Test steps (nothing is ready to test), machine line ending `· half done`
302. static isHalfDone = (r) => { return r.complete == false }
303. static withoutDot = (s) => {
304. let t = s.trim()
305. while (t.endsWith('.')) { t = t.slice(0, t.length - 1).trim() }
306. return t
307. }
308. // mission 027: the small choices the worker made itself (`decided`, may be missing in older reports)
309. static decidedOf = (r) => { return r.decided == null ? [] : r.decided }
311. // mission 027: the Test steps as a numbered Markdown list (was one run-on line "1) … 2) …")
312. static testLines = (r) => {
313. let o = ['**Test:**']
314. let i = 0
315. while (i < r.test.length) {
316. o.push((i + 1) + '. ' + r.test[i].trim())
317. i = i + 1
318. }
319. return o
320. }
322. // the detail bullets, what matters most first (the caller keeps ≤ 3): [half: still open] · questions · problems filed
323. // elsewhere · (mission 027) "Decided: …" · [not half: not done] · still running · refused
324. static detailsOf = (r, filed, asked, half) => {
325. let d = []
326. if (half && r.open.length > 0) { d.push('Still open: ' + oneLine(r.open[0], 90) + (r.open.length > 1 ? ' (and ' + (r.open.length - 1) + ' more)' : '')) }
327. if (asked.length > 0) { d.push((asked.length == 1 ? 'A question for you: ' : 'Questions for you: ') + asked.join(', ')) }
328. if (filed.length > 0) {
329. let parts = []
330. for (f of filed) { parts.push(f.link + (f.blocks ? ' (blocks this ticket)' : '') + (f.unknown ? ' (where should it go?)' : '')) }
331. d.push((filed.length == 1 ? 'A problem found elsewhere: ' : 'Problems found elsewhere: ') + parts.join(', '))
332. }
333. let dc = decidedOf(r)
334. if (dc.length > 0) {
335. let ds = []
336. for (x of dc) { ds.push(withoutDot(oneLine(x, 120))) }
337. d.push(oneLine('Decided: ' + ds.join('; ') + '.', 200))
338. }
339. if (!half && r.open.length > 0) { d.push('Not done: ' + oneLine(r.open[0], 90) + (r.open.length > 1 ? ' (and ' + (r.open.length - 1) + ' more)' : '')) }
340. for (x of r.running) { d.push('Still running: ' + oneLine(x.what, 60) + (x.url != '' ? ' — ' + x.url : '')) }
341. if (r.refused.length > 0) { d.push('The safety check refused ' + r.refused.length + ' action' + (r.refused.length == 1 ? '' : 's') + '.') }
342. return d
343. }
345. static pushDetails = (o, d) => {
346. if (d.length == 0) { return o }
347. o.push('')
348. let k = 0
349. while (k < d.length && k < 3) {
350. o.push('- ' + d[k])
351. k = k + 1
352. }
353. return o
354. }
356. static commentOf = (r, filed, asked, hash, note) => {
357. let o = []
358. let half = isHalfDone(r)
359. if (half) {
360. o.push('Half done: ' + withoutDot(r.result) + '; the next worker continues.')
361. } else {
362. o.push(r.result.trim())
363. o.push('')
364. for (l of testLines(r)) { o.push(l) }
365. }
366. pushDetails(o, detailsOf(r, filed, asked, half))
367. if (hash != null) {
368. o.push('')
369. o.push('colony-report: ' + r.session + ' · sha256 ' + hash + (note == null ? '' : ' · ' + note) + (half ? ' · half done' : ''))
370. }
371. return o.join(NL)
372. }
374. // ---- mission 027: the deploy gate ---------------------------------------------------------------------------------
375. // A project whose registry entry has `live` is tested by the creator ON THE LIVE SITE, so a complete + passed report is
376. // not "ready for you to test" before the deploy: ONE line "Built — goes live with the next deploy." + the machine line
377. // (marker ` · ready to deploy`), the ticket stays `in progress` (out of `next`; lease.hl readyOf: never expires).
378. // `./colony ready` lists them; `./colony deployed <project> <n>` (deploy.hl) posts the readable comment (deployedCommentOf)
379. // and sets `awaiting creator`. Projects without `live` (e.g. research tickets) → `awaiting creator` at once, as before.
380. static READY_NOTE = 'ready to deploy'
381. static deployGate = (r, reg) => {
382. if (isHalfDone(r)) { return false }
383. let m = projectOf(r, reg)
384. return m != null && m.live != null
385. }
386. static readyCommentOf = (r, hash, note) => {
387. return 'Built — goes live with the next deploy.' + NL + NL + 'colony-report: ' + r.session + ' · sha256 ' + hash + (note == null ? '' : ' · ' + note) + ' · ' + READY_NOTE
388. }
389. // the site's name for the creator: `https://ident.worldapi.org/x` → `ident.worldapi.org`
390. static siteName = (url) => {
391. let u = url
392. let i = u.indexOf('://')
393. if (i >= 0) { u = u.slice(i + 3) }
394. let j = u.indexOf('/')
395. if (j >= 0) { u = u.slice(0, j) }
396. return u
397. }
398. // after the deploy: "Now live on <site> — <result>" · **Test:** 1. … · ≤ 3 details · `colony-deployed: S · sha256 H`
399. static deployedCommentOf = (r, filed, asked, site, hash) => {
400. let o = []
401. o.push('Now live on ' + site + ' — ' + r.result.trim())
402. o.push('')
403. for (l of testLines(r)) { o.push(l) }
404. pushDetails(o, detailsOf(r, filed, asked, false))
405. o.push('')
406. o.push('colony-deployed: ' + r.session + ' · sha256 ' + hash)
407. return o.join(NL)
408. }
410. // an issue filed in another project
411. static issueSummary = (e, ticketRef, ticketUrl) => {
412. let o = []
413. o.push('Found while working on [' + refLabel(ticketRef) + '](' + ticketUrl + ')' + (e.blocks ? ' — it blocks that ticket.' : '.'))
414. o.push('')
415. o.push('**Repro:** ' + e.repro.trim())
416. o.push('')
417. o.push('**Observed:** ' + e.observed.trim())
418. o.push('')
419. o.push('**Expected:** ' + e.expected.trim())
420. return o.join(NL)
421. }
423. // a creator question's subject: `Question (alpha#3): <its first line, ≤ 100 characters>`
424. // antcolony#23: the worker's own short title (`{ title, text }`); an old plain-string entry falls back to its first line
425. static questionSubject = (ticketRef, q) => {
426. if (isObject(q)) { return 'Question (' + ticketRef + '): ' + oneLine(q.title, 100) }
427. return 'Question (' + ticketRef + '): ' + oneLine(q, 100)
428. }
429. static questionText = (q) => {
430. return isObject(q) ? q.text : q
431. }
433. static questionSummary = (q, r, ticketUrl) => {
434. return q.trim() + NL + NL + 'Asked while working on [' + refLabel(r.ticket) + '](' + ticketUrl + '). **Answer** with a comment here — the next worker reads it.'
435. }
437. // ---- the command ----------------------------------------------------------------------------
438. static runReport = (argv) => {
439. let pos = positionals(argv)
440. if (pos.length != 2) {
441. console.log('usage: report <file> [--post]')
442. return false
443. }
444. return reportFile(fromCwd(pos[1]), argv.includes('--post'), null).valid
445. }
447. // validate (and with `post` file) one report file — shared by `report` and `work`.
448. // `expect` = { ticket, session } (from `work`: the report must be for THAT ticket and session) or null.
449. // → { valid, posted, problems } (posted: --post ran to POSTED)
450. static reportFile = (file, post, expect) => {
451. let reg = loadRegistry()
452. for (e of reg.errors) { console.log('registry: ' + e) }
453. let rj = readJson(file)
454. if (rj.error != null) {
455. console.log('REPORT REFUSED — ' + rj.error)
456. return { valid = false posted = false problems = [rj.error] }
457. }
458. let r = rj.value
459. let v = validate(r, reg)
460. if (expect != null && v.problems.length == 0) {
461. if (r.ticket != expect.ticket) { v.problems.push('ticket: "' + r.ticket + '" but this session works on ' + expect.ticket) }
462. if (r.session != expect.session) { v.problems.push('session: "' + r.session + '" but this session is ' + expect.session) }
463. }
464. for (n of v.notes) { console.log('note: ' + n) }
465. if (v.problems.length > 0) {
466. console.log('REPORT REFUSED — ' + v.problems.length + ' problem' + (v.problems.length == 1 ? '' : 's') + ':')
467. for (p of v.problems) { console.log(' ' + p) }
468. return { valid = false posted = false problems = v.problems }
469. }
470. console.log('REPORT OK — ' + r.ticket + ', session ' + r.session + ': ' + (r.complete ? 'complete' : 'NOT complete (half done)') + ', ' + r.test.length + ' test steps, ' + r.done.length + ' done, ' + r.verified.length + ' verified, ' + r.open.length + ' open, ' + r.issues.length + ' issues, ' + r.questions.length + ' questions, ' + decidedOf(r).length + ' decided')
471. if (!post) { return { valid = true posted = false problems = [] } }
472. let ok = postReport(r, reg, null)
473. return { valid = true posted = ok problems = [] }
474. }
476. // --post of a VALID report → true when POSTED. `note` = text for the end of the machine line ('controller pass',
477. // missions 019/023) or null
478. static postReport = (r, reg, note) => {
480. // ---- --post
481. let tk = readToken()
482. if (tk.error != null) {
483. console.log('POST REFUSED — ' + tk.error)
484. return false
485. }
486. let token = tk.token
487. let ref = parseRef(r.ticket)
488. let got = getJson(ticketPath(ref.project, ref.number))
489. if (got.status != 200) {
490. console.log('POST REFUSED — ticket ' + r.ticket + ' → ' + got.status)
491. return false
492. }
493. let ticket = got.json.ticket
494. let ticketUrl = pageUrl(ticket)
495. // the marker carries 12 hex of the report's sha256 (mission 023: one short line); an older comment with all
496. // 64 starts with the same 12, so it still counts as "the same report"
497. let hash = sha256(JSON.stringify(r)).slice(0, 12)
498. let marker = 'colony-report: ' + r.session + ' · sha256 '
499. let posted = false
500. for (e of got.json.events) {
501. if (e.kind == 'comment' && e.text != null && e.text.includes(marker)) {
502. if (e.text.includes(marker + hash)) { posted = true } else {
503. console.log('POST REFUSED — session ' + r.session + ' already has a DIFFERENT report on ' + r.ticket + ' (event ' + e.seq + '); one session, one report. Nothing written.')
504. return false
505. }
506. }
507. }
508. // relations (tickets#4): the ticket's current blockers — null-safe for a tickets without relations
509. let hasRel = ticket.keys().includes('children')
510. let blockedKeys = []
511. if (hasRel) { for (b of ticket.blockedBy) { blockedKeys.push(b.key) } }
512. // issues → tickets / creator questions (idempotent by source)
513. let filed = []
514. let i = 0
515. while (i < r.issues.length) {
516. let e = r.issues[i]
517. let src = 'colony-report:' + r.session + ':issue:' + i
518. if (reg.projects[e.project] != null) {
519. let res = postJson('/api/projects/' + e.project + '/tickets', { subject = e.subject summary = issueSummary(e, r.ticket, ticketUrl) source = src }, token)
520. if (res.status == 201 || res.status == 200) {
521. let t = res.json.ticket
522. console.log((res.status == 201 ? ' FILED ' : ' HAVE ') + 'issue ' + i + ' → ' + t.project + t.ref + ' ' + pageUrl(t))
523. filed.push({ link = linkOf(t) blocks = e.blocks unknown = false })
524. // mission 022: `blocks: true` → the ticket is blocked by the issue (tickets#4; the scheduler authored the
525. // issue, so it may link) — once: a blocker already there is not added again
526. if (e.blocks && hasRel) {
527. let key = t.project + '#' + t.number
528. if (blockedKeys.includes(key)) { console.log(' HAVE ' + r.ticket + ' blocked by ' + key) } else {
529. let bl = postJson(ticketPath(ref.project, ref.number) + '/blocked-by', { add = key }, token)
530. if (bl.status != 201) {
531. console.log('POST FAILED — marking ' + r.ticket + ' blocked by ' + key + ': ' + bl.status + ' ' + bl.text + ' — re-run to continue (idempotent)')
532. return false
533. }
534. blockedKeys.push(key)
535. console.log(' LINKED ' + r.ticket + ' blocked by ' + key)
536. }
537. }
538. } else {
539. console.log('POST FAILED — issue ' + i + ' (' + e.project + '): ' + res.status + ' ' + res.text + ' — re-run to continue (idempotent)')
540. return false
541. }
542. } else {
543. let uq = 'A problem found while working on [' + refLabel(r.ticket) + '](' + ticketUrl + ') belongs to "' + e.project + '", a project the colony does not know.' + NL + NL + '**Answer:** which project should get it (or "drop it")?' + NL + NL + '**Repro:** ' + e.repro.trim() + NL + NL + '**Observed:** ' + e.observed.trim() + NL + NL + '**Expected:** ' + e.expected.trim()
544. let q = fileQuestion(token, 'colony-report:' + r.session + ':question:' + i, 'Question (' + r.ticket + '): where should "' + oneLine(e.subject, 60) + '" go?', uq, r.ticket)
545. if (q.error != null) {
546. console.log('POST FAILED — issue ' + i + ' (unknown project ' + e.project + '): ' + q.error + ' — re-run to continue (idempotent)')
547. return false
548. }
549. let t = q.ticket
550. console.log((q.created ? ' FILED ' : ' HAVE ') + 'issue ' + i + ' (unknown project ' + e.project + ') → creator question ' + t.project + t.ref + ' ' + pageUrl(t))
551. filed.push({ link = linkOf(t) blocks = false unknown = true })
552. }
553. i = i + 1
554. }
555. // mission 022 "Creator questions are tickets": every `questions` entry → its own ticket in the ticket's project,
556. // `awaiting creator`, parent = the ticket; idempotent by source `colony-report:<session>:questions:<i>`
557. let asked = []
558. i = 0
559. while (i < r.questions.length) {
560. let qt = r.questions[i]
561. let q = fileQuestionIn(token, ref.project, 'colony-report:' + r.session + ':questions:' + i, questionSubject(r.ticket, qt), questionSummary(questionText(qt), r, ticketUrl), r.ticket)
562. if (q.error != null) {
563. console.log('POST FAILED — question ' + i + ': ' + q.error + ' — re-run to continue (idempotent)')
564. return false
565. }
566. let t = q.ticket
567. console.log((q.created ? ' FILED ' : ' HAVE ') + 'question ' + i + ' → ' + t.project + t.ref + ' (awaiting creator, parent ' + r.ticket + ') ' + pageUrl(t))
568. asked.push(linkOf(t))
569. i = i + 1
570. }
571. if (posted) {
572. console.log(' HAVE the report comment on ' + r.ticket + ' (same session, same sha256) — comment and state untouched')
573. console.log('POSTED — nothing new (report already filed)')
574. return true
575. }
576. // mission 027: the deploy gate — a project with a live site: "Built — goes live with the next deploy." and the ticket
577. // stays `in progress` (out of `next`) until `./colony deployed <project> <n>` posts the readable comment
578. let gate = deployGate(r, reg)
579. let c = postJson(ticketPath(ref.project, ref.number) + '/comments', { text = gate ? readyCommentOf(r, hash, note) : commentOf(r, filed, asked, hash, note) }, token)
580. if (c.status != 201) {
581. console.log('POST FAILED — comment on ' + r.ticket + ': ' + c.status + ' ' + c.text)
582. return false
583. }
584. console.log(' POSTED the report comment on ' + r.ticket + ' ' + ticketUrl)
585. let st = c.json.ticket.state
586. if (gate) {
587. if (st == 'open' || st == 'rejected') {
588. let s = postJson(ticketPath(ref.project, ref.number) + '/state', { state = 'in progress' text = 'Built — waiting for the next deploy.' }, token)
589. if (s.status != 201) {
590. console.log('POST FAILED — state of ' + r.ticket + ': ' + s.status + ' ' + s.text)
591. return false
592. }
593. console.log(' STATE ' + r.ticket + ': ' + st + ' → in progress (built, waiting for the deploy)')
594. } else {
595. console.log(' STATE left as "' + st + '"')
596. }
597. console.log(' READY ' + r.ticket + ': built — goes live with the next deploy (list: ./colony ready; after the deploy: ./colony deployed ' + ref.project + ' ' + ref.number + ')')
598. } else if (isHalfDone(r)) {
599. // mission 026: half done → back to open (only from the lease), never "awaiting creator"
600. if (st != 'in progress') {
601. console.log(' STATE left as "' + st + '" (half done)')
602. } else {
603. let s = postJson(ticketPath(ref.project, ref.number) + '/state', { state = 'open' text = 'Back to open: half done — the next worker continues.' }, token)
604. if (s.status != 201) {
605. console.log('POST FAILED — state of ' + r.ticket + ': ' + s.status + ' ' + s.text)
606. return false
607. }
608. console.log(' STATE ' + r.ticket + ': ' + st + ' → open (half done — the next worker continues)')
609. }
610. } else if (st == 'awaiting creator' || st == 'confirmed' || st == 'rejected') {
611. console.log(' STATE left as "' + st + '"')
612. } else {
613. let s = postJson(ticketPath(ref.project, ref.number) + '/state', { state = 'awaiting creator' text = 'Ready for you to test — see the last comment.' }, token)
614. if (s.status != 201) {
615. console.log('POST FAILED — state of ' + r.ticket + ': ' + s.status + ' ' + s.text)
616. return false
617. }
618. console.log(' STATE ' + r.ticket + ': ' + st + ' → awaiting creator')
619. }
620. console.log('POSTED')
621. return true
622. }