@thebattlearena/corner 0.9.1-beta.70 → 0.10.1-beta.78

package/ring/scripts/contract-preview.mjs

@@ -17,6 +17,8 @@
 // When a database model changes, the referee draws the change as an entity-relationship diagram
 // (references/db-diagram.md) in <bout dir>/db-diagram.html; the page shows it above the model
 // diff, which folds into a "Code diff" disclosure, and warns when a model file changed after it.
+// The endpoints get theirs the same way (references/api-diagram.md, <bout dir>/api-diagram.html):
+// shown above "What changes", whose diff folds under it, and stale when a spec file changed after.
 //
 // The diff runs in two places from one module (spec-diff.mjs): the page parses both specs (YAML
 // via js-yaml) and computes operations, schemas and error responses; the server computes the same
@@ -129,7 +131,7 @@ function worktreeFiles(worktree) {
 }
 
 /** The spec roots the config names: its plain paths, and the OpenAPI roots its globs match. */
-function specRoots(worktree, config) {
+export function specRoots(worktree, config) {
   const files = worktreeFiles(worktree);
   const head = (path) => {
     try {
@@ -241,6 +243,9 @@ function dbDiff(worktree, ref, config) {
 /** The referee's diagram of the model change, drawn per references/db-diagram.md. */
 export const DIAGRAM_FILE = 'db-diagram.html';
 
+/** The referee's diagram of the endpoints, drawn per references/api-diagram.md. */
+export const API_DIAGRAM_FILE = 'api-diagram.html';
+
 /**
  * When a changed model file was last written, in ms: its mtime, or for a deleted file the time of
  * the commit that deleted it. A deletion not committed yet has no date: `Infinity`, so it always
@@ -263,12 +268,12 @@ function writtenAt(worktree, path) {
 }
 
 /**
- * The diagram of the model change, or `null` when the referee has not drawn one: `stale` lists the
- * changed model files written (or deleted) after it, so the judge knows it may not match the diff
- * below.
+ * A diagram of the change (the models by default, or `API_DIAGRAM_FILE`), or `null` when the
+ * referee has not drawn it: `stale` lists the changed files written (or deleted) after it, so the
+ * judge knows it may not match the diff below.
  */
-export function diagramState(dir, worktree, files) {
-  const diagram = join(dir, DIAGRAM_FILE);
+export function diagramState(dir, worktree, files, file = DIAGRAM_FILE) {
+  const diagram = join(dir, file);
   if (!existsSync(diagram)) return null;
   const drawnAt = statSync(diagram).mtimeMs;
   const stale = files
@@ -319,7 +324,7 @@ export function page(specs, first = 0) {
   pre { overflow-x: auto; border: 1px solid var(--line); border-radius: 6px; padding: 8px; font-size: 12px; }
   pre span { display: block; white-space: pre; }
   #swagger { background: #fff; border-radius: 6px; }
-  #diagram { width: 100%; min-height: 320px; border: 1px solid var(--line); border-radius: 6px; background: #fff; }
+  .diagram { width: 100%; min-height: 320px; border: 1px solid var(--line); border-radius: 6px; background: #fff; }
   .warn { background: var(--chg); border-radius: 6px; padding: 8px; }
   details { margin-top: 12px; } summary { cursor: pointer; }
 </style></head>
@@ -364,7 +369,14 @@ export function page(specs, first = 0) {
     html += list('Spec files changed', specFiles.files.map((f) => f.status + '  ' + f.path), '') +
       (specFiles.diff ? '<details><summary>Spec text diff</summary><pre>' + specLines + '</pre></details>' : '');
   }
-  document.getElementById('changes').innerHTML = html || 'No API changes against the base.';
+  const apiStale = data.apiDiagram && data.apiDiagram.stale.length
+    ? '<p class="warn">Changed after the diagram was drawn: ' + esc(data.apiDiagram.stale.join(', ')) + '. Ask the referee to redraw it.</p>'
+    : '';
+  const changes = html || 'No API changes against the base.';
+  document.getElementById('changes').innerHTML = data.apiDiagram
+    ? apiStale + '<iframe class="diagram" src="/api-diagram" sandbox="allow-same-origin" title="Endpoints of the contract"></iframe>' +
+      '<details><summary>Code diff</summary>' + changes + '</details>'
+    : changes;
   const db = data.db;
   const lines = db.diff.split('\\n').map((l) => '<span class="' + (l.startsWith('+') ? 'add' : l.startsWith('-') ? 'del' : '') + '">' + esc(l) + '</span>').join('');
   const code = list('Files', db.files.map((f) => f.status + '  ' + f.path), '') +
@@ -374,13 +386,13 @@ export function page(specs, first = 0) {
     ? '<p class="warn">Changed after the diagram was drawn: ' + esc(db.diagram.stale.join(', ')) + '. Ask the referee to redraw it.</p>'
     : '';
   const drawn = db.diagram
-    ? stale + '<iframe id="diagram" src="/db-diagram" sandbox="allow-same-origin" title="Database model change"></iframe>' +
+    ? stale + '<iframe class="diagram" src="/db-diagram" sandbox="allow-same-origin" title="Database model change"></iframe>' +
       '<details><summary>Code diff</summary>' + code + '</details>'
     : code;
   const dbBox = document.getElementById('db');
   dbBox.innerHTML = db.files.length ? drawn : 'No database-model changes against the base.';
-  const frame = document.getElementById('diagram');
-  if (frame) frame.addEventListener('load', () => { frame.style.height = frame.contentDocument.documentElement.scrollHeight + 'px'; });
+  for (const frame of document.querySelectorAll('iframe.diagram'))
+    frame.addEventListener('load', () => { frame.style.height = frame.contentDocument.documentElement.scrollHeight + 'px'; });
 </script>
 </body></html>`;
 }
@@ -447,8 +459,11 @@ export function handler({ dir, worktree, base, config }) {
           : send(200, contentType(path), text);
       }
       if (url.pathname === '/favicon.ico') return send(204, 'text/plain', '');
-      if (url.pathname === '/db-diagram') {
-        const diagram = join(dir, DIAGRAM_FILE);
+      if (url.pathname === '/db-diagram' || url.pathname === '/api-diagram') {
+        const diagram = join(
+          dir,
+          url.pathname === '/db-diagram' ? DIAGRAM_FILE : API_DIAGRAM_FILE,
+        );
         return existsSync(diagram)
           ? send(200, 'text/html; charset=utf-8', readFileSync(diagram))
           : send(404, 'text/plain', 'not found');
@@ -467,6 +482,7 @@ export function handler({ dir, worktree, base, config }) {
           : send(200, contentType(spec), text);
       }
       if (url.pathname === '/diff.json') {
+        const specFiles = specFilesDiff(worktree, ref, config);
         const body = {
           spec,
           specs,
@@ -476,7 +492,11 @@ export function handler({ dir, worktree, base, config }) {
             ? serverSpecDiff(spec, atBase(spec), proposed(spec))
             : null,
           db: withDiagram(dbDiff(worktree, ref, config)),
-          specFiles: specFilesDiff(worktree, ref, config),
+          specFiles,
+          // Like the database's: no diagram without a spec change, so an old one never shows.
+          apiDiagram: specFiles.files.length
+            ? diagramState(dir, worktree, specFiles.files, API_DIAGRAM_FILE)
+            : null,
         };
         return send(
           200,

package/ring/scripts/fight.mjs

@@ -11,6 +11,7 @@ import { join } from 'node:path';
 import { commitEvents, localDay, localTime, score } from './chronicle.mjs';
 import { repoBouts, slugFromRemote } from './config.mjs';
 import { LIVE_LOG, SPARRING_FILE, sparringsHome } from './live.mjs';
+import { sparringFold } from './preparation.mjs';
 import {
   dedupe,
   feedEvents,
@@ -86,6 +87,29 @@ function option(argv, name) {
   return index === -1 ? null : argv[index + 1];
 }
 
+/**
+ * The bout's weigh-in with what `sparring.mjs promote` made for its repo: the deliverable PR
+ * (mainevent → release) and the sparring's draft and worktree it came from. PURE.
+ */
+export function withPromotion(weighIn, state, repo) {
+  const entry = (state.repos ?? []).find((item) => item.repo === repo);
+  if (!entry) return weighIn;
+  return {
+    ...weighIn,
+    promotion: {
+      ...weighIn.promotion,
+      repo,
+      mainevent: entry.mainevent ?? null,
+      sparring: {
+        branch: entry.branch,
+        pr: entry.pr ?? null,
+        url: entry.url ?? null,
+        worktree: entry.worktree,
+      },
+    },
+  };
+}
+
 /** Every bout opened `--from-sparring` this sparring, in the sparring's repos. */
 export function boutsOfSparring(state, env = process.env) {
   return (state.repos ?? []).flatMap((entry) =>
@@ -220,12 +244,15 @@ export function collectFight(slug, argv, { collectBout, readExtra }) {
     proof: state.proof,
     verdict: state.verdict ?? null,
     repos: (state.repos ?? []).map(({ repo, pr, url }) => ({ repo, pr, url })),
+    fold: sparringFold(state, bouts.length),
     bouts: bouts.map((bout) => ({
       repo: bout.repo,
       pr: bout.pr,
       boutDir: bout.boutDir,
       opened: bout.opened,
       copilotOnHead: bout.copilotOnHead,
+      weighIn: withPromotion(bout.weighIn, state, bout.repo),
+      interview: bout.interview,
     })),
     falls: sliced.falls,
     rounds: sliced.rounds,

package/ring/scripts/findings.mjs

@@ -1,8 +1,12 @@
 #!/usr/bin/env node
 // The ledger of every cornerman finding of a bout, and its audit. Zero-dependency.
 //
-//   node findings.mjs add <pr> --source range|concept|batch|final|copilot|human [--range <from>..<to>]
+//   node findings.mjs add <pr> --source range|concept|batch|final|copilot|human|contract [--range <from>..<to>]
+//                         (contract: the judge's «se mejora» on an endpoint, from judges-card page-verdicts)
 //                         (<text> | --file <report>)       one finding, or one per line of a report
+//                         [--rule <id>]  the referee's own rule for the lines that cite none (logged as theirs)
+//                         A reviewer's finding (range, concept, batch, final, human) cites a rule of the venue
+//                         in its second field (`<file:line> — R11 — …`); X0 when none covers it.
 //   node findings.mjs clean <pr> --range <from>..<to>      the cornerman found nothing in that range
 //   node findings.mjs applied <pr> F<n>[,F<m>…] <sha>      the wrestler applied it in that commit
 //   node findings.mjs discard <pr> F<n>[,…] --id D<k> --reason "<why>"
@@ -38,8 +42,16 @@ import {
   repoSlug,
 } from './config.mjs';
 import { record } from './live.mjs';
+import {
+  citedRules,
+  loadRules,
+  NO_RULE,
+  uncitedFindings,
+} from './rule-ids.mjs';
 
 export const LEDGER = 'findings.json';
+/** Sources whose findings come from a review against the rulebook, so each one cites a rule. */
+export const CITED_SOURCES = ['range', 'concept', 'batch', 'final', 'human'];
 export const SOURCES = [
   'range',
   'concept',
@@ -47,6 +59,7 @@ export const SOURCES = [
   'final',
   'copilot',
   'human',
+  'contract',
 ];
 /** States that need nothing more from the referee before a round-bell or a push. */
 const SETTLED = ['applied', 'discarded', 'ticket', 'escalated'];
@@ -377,19 +390,85 @@ function scorecard(dir, ledger, label) {
   });
 }
 
+/**
+ * The rule each finding line answers to: the one it cites, or the referee's `--rule` for a line
+ * that cites none. Throws listing every line without a valid one. PURE.
+ */
+export function ruledLines(texts, ids, rule) {
+  if (rule && rule !== NO_RULE && !ids.has(rule))
+    throw new Error(`--rule ${rule} is not a rule of this venue`);
+  const lines = texts.map((text) => ({
+    text,
+    by: citedRules(text) || !rule ? null : 'referee',
+  }));
+  const pending = lines.filter((line) => !line.by).map((line) => line.text);
+  const wrong = uncitedFindings(pending, ids);
+  if (wrong.length)
+    throw new Error(
+      `every finding cites a rule of the venue in its second field (\`<file:line> — R11 — …\`), or X0 when none covers it; rebound the report to the cornerman, or take the line as yours with --rule <id>:\n${wrong.map(({ line, reason }) => `  ${line}  (${reason})`).join('\n')}`,
+    );
+  return lines.map(({ text, by }) => (by ? { text, by, rule } : { text }));
+}
+
+/** The findings no rule covers, as proposals for the rulebook in the judges card. */
+function proposeRules(dir, findings) {
+  const card = join(dir, 'judges-card.md');
+  const uncovered = findings.filter(
+    (finding) =>
+      finding.rule === NO_RULE || citedRules(finding.text)?.includes(NO_RULE),
+  );
+  if (!uncovered.length || !existsSync(card)) return;
+  const text = uncovered.reduce(
+    (current, finding) =>
+      withSectionLine(
+        current,
+        'For the rulebook / precedents',
+        `- ${finding.id} (X0, no rule covers it): ${finding.text} — which rule is missing?`,
+      ),
+    readFileSync(card, 'utf8'),
+  );
+  writeFileSync(card, text);
+}
+
 function add([pr, ...argv]) {
   const { values, rest } = flags(argv);
   const { dir, state } = bout(pr);
   const texts = values.file
     ? reportLines(readFileSync(values.file, 'utf8'))
     : [rest.join(' ').trim()].filter(Boolean);
+  const cited = CITED_SOURCES.includes(values.source);
+  const ids = cited
+    ? loadRules(
+        loadConfig(projectDir(), {
+          contract: false,
+          venue: state.venue ?? 'backend',
+        }).config,
+      ).ids
+    : null;
+  const lines = cited
+    ? ruledLines(texts, ids, values.rule)
+    : texts.map((text) => ({ text }));
   const { ledger, added } = withFindings(readLedger(dir), {
     source: values.source,
     ...rangeOf(state, values.range),
-    texts,
+    texts: lines.map((line) => line.text),
     at: now(),
   });
-  scorecard(dir, writeLedger(dir, ledger), 'registró hallazgos');
+  const authored = new Map(added.map((finding, i) => [finding.id, lines[i]]));
+  const findings = ledger.findings.map((finding) =>
+    authored.get(finding.id)?.by
+      ? { ...finding, by: 'referee', rule: authored.get(finding.id).rule }
+      : finding,
+  );
+  scorecard(
+    dir,
+    writeLedger(dir, { ...ledger, findings }),
+    'registró hallazgos',
+  );
+  proposeRules(
+    dir,
+    findings.filter((finding) => authored.has(finding.id)),
+  );
   for (const finding of added) console.log(`${finding.id} · ${finding.text}`);
 }