atris 3.69.0 → 3.71.0

package/lib/campaign-reading.js

@@ -0,0 +1,147 @@
+// Graded judge readings: a number from 0 to 1 pulled from a judge's output,
+// so a campaign learns "3 of 5 tests pass" instead of only "failed". Pure, no
+// I/O. The reading rides on judge_ran as data.reading (lib/campaign-schema.js
+// already allows it); traces use it as the reward signal
+// (atris/features/campaign/traces.md).
+//
+// Formats, first match wins:
+//   reading: 0.6                       a judge that states its own reading
+//   3 of 5 live  /  3/5 ok             the judge's final line
+//   node --test   ℹ pass 3 / ℹ fail 2  (also TAP "# pass 3", and "pass 3, fail 2")
+//   jest/vitest   Tests: 1 failed, 4 passed, 5 total  /  Tests  1 failed | 4 passed (5)
+//   pytest        1 failed, 4 passed in 0.12s
+//   mocha         4 passing / 1 failing
+// Output with no counts gives null: a reading is never invented.
+
+'use strict';
+
+function round(value) {
+  return Math.round(Math.min(1, Math.max(0, value)) * 10000) / 10000;
+}
+
+function ratio(good, total) {
+  return total > 0 ? round(good / total) : null;
+}
+
+function count(line, word) {
+  const match = line.match(new RegExp(`(\\d+)\\s+${word}\\b`, 'i'));
+  return match ? Number(match[1]) : 0;
+}
+
+function stated(lines) {
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const match = lines[i].match(/^reading\s*[:=]\s*(\d*\.?\d+)\s*$/i);
+    if (match) return round(Number(match[1]));
+  }
+  return null;
+}
+
+function finalOf(lines) {
+  const last = lines[lines.length - 1] || '';
+  const match = last.match(/^(\d+)\s*(?:of|\/)\s*(\d+)\b/i);
+  if (!match || Number(match[1]) > Number(match[2])) return null;
+  return ratio(Number(match[1]), Number(match[2]));
+}
+
+// node --test prints one summary block per run; a judge that chains runs
+// (a && b) gets the sum of every block.
+function nodeCounts(text) {
+  const tokens = /(?:^|,)[ \t]*(?:ℹ|#)?[ \t]*(pass|fail|cancelled)[ \t]+(\d+)[ \t]*(?=,|$)/gim;
+  const sums = { pass: 0, fail: 0, cancelled: 0 };
+  let seen = false;
+  for (const match of text.matchAll(tokens)) {
+    sums[match[1].toLowerCase()] += Number(match[2]);
+    seen = true;
+  }
+  return seen ? ratio(sums.pass, sums.pass + sums.fail + sums.cancelled) : null;
+}
+
+function lastLine(lines, pattern) {
+  for (let i = lines.length - 1; i >= 0; i--) if (pattern.test(lines[i])) return lines[i];
+  return null;
+}
+
+function jestCounts(lines) {
+  const line = lastLine(lines, /^Tests:?\s+.*\d+\s+(passed|failed)/i);
+  if (!line) return null;
+  return ratio(count(line, 'passed'), count(line, 'passed') + count(line, 'failed'));
+}
+
+function pytestCounts(lines) {
+  const line = lastLine(lines, /\d+\s+(passed|failed)\b/i);
+  if (!line) return null;
+  const errors = count(line, 'errors') || count(line, 'error');
+  return ratio(count(line, 'passed'), count(line, 'passed') + count(line, 'failed') + errors);
+}
+
+function mochaCounts(lines) {
+  const passing = lastLine(lines, /^\d+\s+passing\b/i);
+  if (!passing) return null;
+  const failing = lastLine(lines, /^\d+\s+failing\b/i);
+  const good = count(passing, 'passing');
+  return ratio(good, good + (failing ? count(failing, 'failing') : 0));
+}
+
+// The reading in [0, 1], or null when the output has no counts.
+function judgeReading(output) {
+  const text = String(output || '').replace(/\r/g, '');
+  // Strip color codes so a colored reporter reads the same as a piped one.
+  const plain = text.replace(/\x1b\[[0-9;]*m/g, '');
+  const lines = plain.split('\n').map((line) => line.trim()).filter(Boolean);
+  if (!lines.length) return null;
+  for (const read of [stated, finalOf]) {
+    const value = read(lines);
+    if (value !== null) return value;
+  }
+  const node = nodeCounts(lines.join('\n'));
+  if (node !== null) return node;
+  for (const read of [jestCounts, pytestCounts, mochaCounts]) {
+    const value = read(lines);
+    if (value !== null) return value;
+  }
+  return null;
+}
+
+const TAIL_LINES = 40;
+const TAIL_BYTES = 4096;
+
+// The end of the judge's output, so the planner sees more than one line:
+// the last 40 lines, at most 4 KB, color codes removed.
+function outputTail(output) {
+  const lines = String(output || '').replace(/\r/g, '').replace(/\x1b\[[0-9;]*m/g, '').split('\n');
+  while (lines.length && !lines[lines.length - 1].trim()) lines.pop();
+  let tail = lines.slice(-TAIL_LINES).join('\n');
+  const bytes = Buffer.from(tail, 'utf8');
+  if (bytes.length > TAIL_BYTES) {
+    // Cut on a character boundary: drop continuation bytes at the cut.
+    let start = bytes.length - TAIL_BYTES;
+    while (start < bytes.length && (bytes[start] & 0xc0) === 0x80) start++;
+    tail = bytes.subarray(start).toString('utf8');
+  }
+  return tail;
+}
+
+// The data a judge_ran event carries for one run of the judge command.
+// A judge that prints no pass/fail counts still said something; its last line
+// beats a bare exit code.
+function lastSaidLine(text) {
+  const lines = String(text || '').split('\n').map((line) => line.trim()).filter(Boolean);
+  return lines.length ? lines[lines.length - 1].slice(0, 200) : '';
+}
+
+function judgeRanData(result) {
+  const data = { passed: result.passed, summary: result.summary || lastSaidLine(result.output_tail) || `exit ${result.exit}`, seconds: result.seconds };
+  if (typeof result.reading === 'number' && Number.isFinite(result.reading)) data.reading = result.reading;
+  if (typeof result.output_tail === 'string' && result.output_tail) data.output_tail = result.output_tail;
+  return data;
+}
+
+// The output_tail of the latest judge run in fold order, or null.
+function latestJudgeOutput(events) {
+  const { compareEvents } = require('./campaign-core');
+  const runs = (events || []).filter((e) => e.type === 'judge_ran').sort(compareEvents);
+  const last = runs[runs.length - 1];
+  return last && typeof last.data.output_tail === 'string' && last.data.output_tail ? last.data.output_tail : null;
+}
+
+module.exports = { judgeReading, judgeRanData, latestJudgeOutput, outputTail };

package/lib/campaign-schema.js

@@ -0,0 +1,196 @@
+// Campaign schema: the struct, event types, and actions shared by every
+// surface (CLI, backend, desktop, web, terrace). Pure, no I/O.
+//
+// The fold rules that turn events into state live in
+// test/fixtures/campaign/README.md, which is the cross-surface contract.
+// Spec: atris/features/campaign/idea.md.
+
+'use strict';
+
+// idea.md "Events" list, plus two the spec's actions need but never named:
+// add_budget writes budget_added, veto writes mission_vetoed, and judge_set
+// changes the judge (found running real campaigns: a judge is not forever).
+const EVENT_TYPES = Object.freeze([
+  'campaign_started', 'seat_filled', 'bet_set', 'attached',
+  'mission_proposed', 'mission_claimed', 'mission_started', 'step', 'kept', 'reverted', 'mission_ended',
+  'mission_vetoed',
+  'judge_ran', 'ask_opened', 'ask_answered',
+  'budget_reserved', 'budget_released', 'budget_added',
+  'paused', 'resumed', 'stopped', 'home_moved', 'done',
+  'judge_set',
+]);
+
+const ACTIONS = Object.freeze([
+  'start', 'pause', 'resume', 'answer_ask', 'change_bet', 'add_budget', 'fill_seat', 'veto', 'stop',
+]);
+
+const CONFIDENCE = Object.freeze(['open', 'leaning', 'stronger', 'answered']);
+
+const STATES = Object.freeze([
+  'running', 'needs_you', 'resting', 'queued', 'done', 'out_of_budget', 'paused',
+]);
+
+const STOP_REASONS = Object.freeze(['judge_passed', 'stopped', 'done_by_human', 'budget_spent']);
+
+const MISSION_OUTCOMES = Object.freeze(['kept', 'reverted', 'failed']);
+
+// What a person or agent writes. Everything else is folded from events.
+const CAMPAIGN_FIELDS = Object.freeze({
+  title: { required: true, type: 'string' },
+  judge: { required: true, type: 'string' },
+  budget: { required: true, type: 'number' },
+  owner: { required: false, type: 'string' },
+  seats: { required: false, type: 'array' },
+  bet: { required: false, type: 'string' },
+  standing: { required: false, type: 'boolean' },
+  parent: { required: false, type: 'string' },
+});
+
+const CAMPAIGN_ID = /^cmp-[a-z0-9][a-z0-9-]{0,63}$/;
+const EVENT_ID = /^[\x21-\x7e]{1,128}$/;
+const ORIGIN = /^[A-Za-z0-9._:-]{1,64}$/;
+// RFC 3339 with a zone: no surface may read a timestamp in its own timezone.
+const TIMESTAMP = /^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2})(?:\.(\d{1,9}))?(Z|[+-]\d{2}:\d{2})$/;
+
+function isObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function nonEmpty(value) {
+  return typeof value === 'string' && value.trim().length > 0;
+}
+
+function positiveNumber(value) {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0;
+}
+
+function nonNegativeNumber(value) {
+  return typeof value === 'number' && Number.isFinite(value) && value >= 0;
+}
+
+// A seat is "member" (role comes from the member's own job) or { member, role }.
+function seatErrors(seats) {
+  if (!Array.isArray(seats)) return ['seats_not_list'];
+  const errors = [];
+  for (const seat of seats) {
+    if (nonEmpty(seat)) continue;
+    if (isObject(seat) && nonEmpty(seat.member) && (seat.role === undefined || seat.role === null || nonEmpty(seat.role))) continue;
+    errors.push('bad_seat');
+  }
+  return errors;
+}
+
+// record: the hand-written struct. options.lookup(id) returns another
+// campaign record (or null) so the one-level nesting rule can be checked.
+function validateCampaign(record, options = {}) {
+  const errors = [];
+  if (!isObject(record)) return { ok: false, errors: ['not_object'] };
+  for (const key of Object.keys(record)) {
+    if (!Object.prototype.hasOwnProperty.call(CAMPAIGN_FIELDS, key)) errors.push(`unknown_field:${key}`);
+  }
+  if (!nonEmpty(record.title)) errors.push('missing_title');
+  if (!nonEmpty(record.judge)) errors.push('missing_judge');
+  if (!positiveNumber(record.budget)) errors.push('bad_budget');
+  if (record.owner !== undefined && !nonEmpty(record.owner)) errors.push('bad_owner');
+  if (record.bet !== undefined && !nonEmpty(record.bet)) errors.push('bad_bet');
+  if (record.standing !== undefined && typeof record.standing !== 'boolean') errors.push('bad_standing');
+  if (record.seats !== undefined) errors.push(...seatErrors(record.seats));
+  if (record.parent !== undefined) {
+    if (!nonEmpty(record.parent)) {
+      errors.push('bad_parent');
+    } else if (typeof options.lookup === 'function') {
+      const parent = options.lookup(record.parent);
+      if (!parent) errors.push('unknown_parent');
+      else if (parent.parent) errors.push('nested_parent');
+    }
+  }
+  return { ok: errors.length === 0, errors };
+}
+
+// Fields each event type must carry in its data.
+const EVENT_DATA_RULES = Object.freeze({
+  campaign_started: (d) => [
+    nonEmpty(d.title) ? null : 'missing_title',
+    nonEmpty(d.judge) ? null : 'missing_judge',
+    positiveNumber(d.budget) ? null : 'bad_budget',
+    d.seats === undefined ? null : (seatErrors(d.seats)[0] || null),
+    d.standing === undefined || typeof d.standing === 'boolean' ? null : 'bad_standing',
+  ],
+  seat_filled: (d) => [nonEmpty(d.member) ? null : 'missing_member', nonEmpty(d.role) ? null : 'missing_role'],
+  bet_set: (d) => [nonEmpty(d.bet) ? null : 'missing_bet'],
+  judge_set: (d) => [nonEmpty(d.judge) ? null : 'missing_judge'],
+  attached: (d) => [nonEmpty(d.parent_id) ? null : 'missing_parent_id'],
+  mission_proposed: (d) => [nonEmpty(d.mission_id) ? null : 'missing_mission_id'],
+  mission_claimed: (d) => [
+    nonEmpty(d.mission_id) ? null : 'missing_mission_id',
+    nonEmpty(d.claim_key) ? null : 'missing_claim_key',
+  ],
+  mission_started: (d) => [
+    nonEmpty(d.mission_id) ? null : 'missing_mission_id',
+    nonEmpty(d.member) ? null : 'missing_member',
+  ],
+  step: (d) => [nonEmpty(d.mission_id) ? null : 'missing_mission_id'],
+  kept: (d) => [nonEmpty(d.mission_id) ? null : 'missing_mission_id'],
+  reverted: (d) => [nonEmpty(d.mission_id) ? null : 'missing_mission_id'],
+  // Every mission reports its cost (idea.md review rule 1).
+  mission_ended: (d) => [
+    nonEmpty(d.mission_id) ? null : 'missing_mission_id',
+    MISSION_OUTCOMES.includes(d.outcome) ? null : 'bad_outcome',
+    nonNegativeNumber(d.cost_usd) ? null : 'missing_cost',
+  ],
+  mission_vetoed: (d) => [nonEmpty(d.mission_id) ? null : 'missing_mission_id'],
+  judge_ran: (d) => [
+    typeof d.passed === 'boolean' ? null : 'missing_passed',
+    d.reading === undefined || (typeof d.reading === 'number' && Number.isFinite(d.reading)) ? null : 'bad_reading',
+    d.confidence === undefined || ['open', 'leaning', 'stronger'].includes(d.confidence) ? null : 'bad_confidence',
+  ],
+  ask_opened: (d) => [nonEmpty(d.ask_id) ? null : 'missing_ask_id', nonEmpty(d.question) ? null : 'missing_question'],
+  ask_answered: (d) => [nonEmpty(d.ask_id) ? null : 'missing_ask_id', nonEmpty(d.answer) ? null : 'missing_answer'],
+  budget_reserved: (d) => [
+    nonEmpty(d.mission_id) ? null : 'missing_mission_id',
+    positiveNumber(d.amount_usd) ? null : 'bad_amount',
+  ],
+  budget_released: (d) => [nonEmpty(d.mission_id) ? null : 'missing_mission_id'],
+  budget_added: (d) => [positiveNumber(d.amount_usd) ? null : 'bad_amount'],
+  paused: () => [],
+  resumed: () => [],
+  stopped: () => [],
+  home_moved: (d) => [nonEmpty(d.to) ? null : 'missing_to'],
+  done: () => [],
+});
+
+function validateEvent(event) {
+  if (!isObject(event)) return { ok: false, errors: ['not_object'] };
+  const errors = [];
+  if (typeof event.id !== 'string' || !EVENT_ID.test(event.id)) errors.push('bad_id');
+  if (typeof event.campaign_id !== 'string' || !CAMPAIGN_ID.test(event.campaign_id)) errors.push('bad_campaign_id');
+  if (!EVENT_TYPES.includes(event.type)) errors.push('unknown_type');
+  if (typeof event.at !== 'string' || !TIMESTAMP.test(event.at) || Number.isNaN(Date.parse(event.at))) errors.push('bad_at');
+  if (typeof event.origin !== 'string' || !ORIGIN.test(event.origin)) errors.push('bad_origin');
+  if (!Number.isInteger(event.seq) || event.seq < 1) errors.push('bad_seq');
+  if (!nonEmpty(event.actor)) errors.push('missing_actor');
+  if (!isObject(event.data)) errors.push('bad_data');
+  if (errors.length === 0) {
+    for (const code of EVENT_DATA_RULES[event.type](event.data)) if (code) errors.push(code);
+  }
+  return { ok: errors.length === 0, errors };
+}
+
+function isHumanActor(actor) {
+  return typeof actor === 'string' && actor.startsWith('human:');
+}
+
+module.exports = {
+  ACTIONS,
+  CAMPAIGN_FIELDS,
+  CAMPAIGN_ID,
+  CONFIDENCE,
+  EVENT_TYPES,
+  TIMESTAMP,
+  MISSION_OUTCOMES,
+  STATES,
+  STOP_REASONS,
+  isHumanActor,
+  validateCampaign,
+  validateEvent,
+};