@bongos/core 1.24.7 → 1.24.9

package/modules/market-watch/routes/rules.js

@@ -0,0 +1,202 @@
+'use strict';
+
+// modules/market-watch/routes/rules.js — the rules page's server half (task 1004941,
+// goal 1000137): read the watch rules in plain words, propose a change, decide it.
+//
+//   GET  /market-watch/rules                 any signed-in member: the page model
+//                                             (rules-view.js), plus who may decide
+//   POST /market-watch/rules/proposals       any signed-in member: file a change to one
+//                                             step, with a reason (rules-logic.checkChange)
+//   POST /market-watch/proposals/:id/decide  the PROJECT OWNER only (the founding builder,
+//                                             the doorway's getFoundingBuilder), checked
+//                                             here on the server: approve or decline ANY
+//                                             open proposal, including the item page's and
+//                                             the weekly ask's (tasks 1004939, 1004940)
+//   POST /market-watch/proposals/:id/vote    put an open proposal to the government's vote
+//
+// WHO DECIDES. With no government module, or a government whose Rules building is
+// decided as today, the owner approves or declines alone. Where the project's decision
+// table hands Rules to a sitting, the decide route's act-alone gate (the doorway's,
+// naming the Rules building) refuses one person acting alone (409 decided_by_sitting) and the proposal goes to a vote: the
+// vote route files a Rules matter through the government PORT (resolved optionally, so a
+// project without a government still works), and the passed matter approves it through
+// matter-acts.js. The government's own wall for opening a matter, the board.item.open
+// atom, gates the vote route.
+//
+// Member text (reasons, names, queries) is stored as typed and escaped where it is shown
+// (the hall page); it reaches the weekly run's prompt only fenced as untrusted data
+// (research.js).
+
+const express = require('express');
+const api = require('../../../src/module-api');
+const proposals = require('../proposals');
+const view = require('../rules-view');
+const research = require('../research');
+const { projectKey } = require('../seed');
+
+const log = api.logger('market-watch');
+
+// Seams the test replaces: the project key, the owner, the transaction runner.
+const deps = {
+  project: () => projectKey(api.branding().domains.publicOrigin),
+  owner: () => api.getFoundingBuilder(),
+  pool: () => api.pool,
+  withTx: (fn) => api.withTx(fn, { pool: api.pool }),
+  government: () => (typeof api.resolveOptional === 'function' ? api.resolveOptional('government') : null),
+};
+
+async function isOwner(builderId) {
+  const owner = await deps.owner();
+  return !!owner && builderId != null && String(owner.id) === String(builderId);
+}
+
+// How decisions are made right now, for this viewer. Read per request, never cached.
+async function decideMode(viewerId) {
+  const owner = await isOwner(viewerId).catch(() => false);
+  const gov = deps.government();
+  if (!gov || typeof gov.checkActAlone !== 'function') {
+    return { mode: 'owner', viewer_is_owner: owner, viewer_may_decide: owner, may_put_to_vote: false };
+  }
+  try {
+    const out = await gov.checkActAlone('rules', viewerId);
+    if (out && out.ok === true) {
+      return { mode: 'owner', viewer_is_owner: owner, viewer_may_decide: owner, may_put_to_vote: false };
+    }
+    return {
+      mode: out && out.open_with ? 'vote' : 'vacant',
+      viewer_is_owner: owner,
+      viewer_may_decide: false,
+      may_put_to_vote: !!(out && out.open_with) && typeof gov.openMatter === 'function',
+      who: (out && out.who) || null,
+      what_this_means: (out && out.what_this_means) || null,
+    };
+  } catch (err) {
+    log.warn(`[market-watch] who decides at rules could not be read: ${err && err.message}`);
+    return { mode: 'unknown', viewer_is_owner: owner, viewer_may_decide: false, may_put_to_vote: false };
+  }
+}
+
+function noProject(res) {
+  return res.fail('no_project', { status: 503, message: 'this project has no public address set, so its watch has no key' });
+}
+
+const DECIDE_REFUSALS = Object.freeze({
+  not_found: [404, 'There is no such proposal on this project.'],
+  not_open: [409, 'That proposal was already decided.'],
+  no_active_rules: [409, 'This project has no rules in use yet.'],
+  no_longer_applies: [409, 'The rules changed since this was proposed, so it no longer fits. Decline it and propose again.'],
+  bad_payload: [409, 'This proposal does not name anything to add.'],
+  item_gone: [409, 'That item is no longer on this project.'],
+});
+
+module.exports = function buildMarketWatchRulesRouter() {
+  require('../matter-acts').contributeMarketWatchMatterActs();
+  const router = express.Router();
+
+  // rank: any-builder — every member reads the rules (the task); the read grants nothing.
+  router.get('/market-watch/rules', api.requireBuilder, async (req, res) => {
+    const project = deps.project();
+    if (!project) return noProject(res);
+    try {
+      const decide = await decideMode(req.builder.id);
+      const out = await view.readView(deps.pool(), { project, decide, pricing: api.llmPricing, model: research.MODEL });
+      res.json(out);
+    } catch (err) {
+      log.error('[market-watch] GET /market-watch/rules', err);
+      res.fail('rules_unreadable', { status: 503, message: 'could not read the watch rules' });
+    }
+  });
+
+  // Any signed-in member may propose (the task: "every member can read the page and can
+  // propose"). The change's own fields are checked in rules-logic.checkChange.
+  // rank: any-builder — any member may propose; filing decides nothing.
+  router.post('/market-watch/rules/proposals', api.requireBuilder, async (req, res) => {
+    if (api.validateOrRespond(req, res, {
+      step: { required: true, type: 'string', maxLength: 16 },
+      change: { required: true, type: 'object' },
+      reason: { required: true, type: 'string', maxLength: 500 },
+    })) return;
+    const project = deps.project();
+    if (!project) return noProject(res);
+    try {
+      const out = await proposals.createProposal(deps.pool(), {
+        project, step: req.body.step, change: req.body.change, reason: req.body.reason, proposedBy: req.builder.id,
+      });
+      if (!out.ok) {
+        const status = out.reason === 'too_many_open' ? 429
+          : (out.reason === 'no_active_rules' || out.reason === 'already_proposed') ? 409 : 400;
+        return res.fail(out.reason, status, out.field ? { field: out.field } : undefined);
+      }
+      res.status(201).json({ ok: true, proposal: out.proposal });
+    } catch (err) {
+      log.error('[market-watch] POST /market-watch/rules/proposals', err);
+      res.fail('proposal_failed', { status: 500, message: 'could not file the proposal' });
+    }
+  });
+
+  // THE OWNER'S DECISION. The Rules act-alone gate first, so a project whose government
+  // hands Rules to a sitting refuses this before anything else (the vote decides there);
+  // then the owner check, server-side, per request: anyone else gets 403.
+  // rank: any-builder — signed in to reach it; the owner check below is the wall (403).
+  router.post('/market-watch/proposals/:id/decide', api.requireBuilder, api.requireActAlone('rules'), async (req, res) => {
+    const id = api.parseId(req, res, { positiveInt: true });
+    if (id == null) return;
+    if (api.validateOrRespond(req, res, { decision: { required: true, type: 'string', enum: ['approve', 'decline'] } })) return;
+    const project = deps.project();
+    if (!project) return noProject(res);
+    try {
+      if (!(await isOwner(req.builder.id))) {
+        return res.fail('owner_only', { status: 403, message: 'Only the project owner approves or declines proposals.' });
+      }
+      const out = await proposals.decideProposal({ project, id, decision: req.body.decision, decidedBy: req.builder.id, withTx: deps.withTx });
+      if (!out.ok) {
+        const [status, message] = DECIDE_REFUSALS[out.reason] || [409, 'That proposal could not be decided.'];
+        return res.fail(out.reason, { status, message });
+      }
+      res.json(out);
+    } catch (err) {
+      log.error('[market-watch] POST /market-watch/proposals/:id/decide', err);
+      res.fail('decide_failed', { status: 500, message: 'could not decide the proposal' });
+    }
+  });
+
+  // PUT TO A VOTE. Only where the government hands Rules to a sitting; the matter's act
+  // (matter-acts.js) approves the proposal if it passes.
+  router.post('/market-watch/proposals/:id/vote', api.requireBuilder, api.requirePermission('board.item.open'), async (req, res) => {
+    const id = api.parseId(req, res, { positiveInt: true });
+    if (id == null) return;
+    const project = deps.project();
+    if (!project) return noProject(res);
+    const gov = deps.government();
+    if (!gov || typeof gov.openMatter !== 'function') {
+      return res.fail('no_government', { status: 409, message: 'This project has no government to vote on it; the owner decides.' });
+    }
+    try {
+      const p = await proposals.getOpen(deps.pool(), { project, id });
+      if (!p) return res.fail('not_open', { status: 409, message: 'That proposal is not open.' });
+      if (p.payload && p.payload.matter_id) return res.fail('already_at_vote', { status: 409, message: 'That proposal is already at a vote.' });
+      const summary = String((p.payload && p.payload.summary) || p.kind).slice(0, 150);
+      const out = await gov.openMatter({
+        area: 'rules',
+        title: `Market Watch: ${summary}`,
+        // the reason is a member's words; the matter shows it as their proposal, quoted
+        detailMd: `A member proposed this change to the Market Watch rules.\n\n> ${String(p.reason || '').replace(/\s+/g, ' ').slice(0, 500)}`,
+        action: { type: 'market_watch_proposal', proposal_id: id },
+        proposedBy: req.builder.id,
+      });
+      if (!out || !out.ok) {
+        return res.fail((out && out.reason) || 'matter_refused', { status: 409, message: (out && out.what_this_means) || 'The government did not take the vote.' });
+      }
+      await proposals.markAtVote(deps.pool(), { project, id, matterId: out.matter && out.matter.id });
+      res.status(201).json({ ok: true, matter_id: out.matter ? String(out.matter.id) : null, item_id: out.item ? String(out.item.id) : null });
+    } catch (err) {
+      log.error('[market-watch] POST /market-watch/proposals/:id/vote', err);
+      res.fail('vote_failed', { status: 500, message: 'could not put the proposal to a vote' });
+    }
+  });
+
+  return router;
+};
+
+module.exports.deps = deps;
+module.exports.decideMode = decideMode;

package/modules/market-watch/rules-logic.js

@@ -0,0 +1,264 @@
+'use strict';
+
+// modules/market-watch/rules-logic.js — the rules page's arithmetic, with no database
+// (task 1004941, goal 1000137). The page is the pipeline map of
+// docs/design/mocks/market-watch/rules.html (option C): searches, then sources, then
+// names, then scoring, then the brief. Everything the page shows about a rules version,
+// and every change a member may propose to one, is decided here, so the route, the
+// approval and the tests all read one definition.
+//
+// A CHANGE IS A SMALL, CLOSED DELTA, never a whole new rules object. A member proposes
+// one step's change ("add this search", "count this score double", "rewrite the brief"),
+// with a reason. Approving it applies the delta to the version IN USE at that moment, so
+// a proposal made against v6 and approved after v7 still lands on v7 and loses nothing
+// v7 added. A delta that no longer applies (the search it removes is already gone) is
+// refused at approval with `no_longer_applies`, never applied half-way.
+//
+//   searches  { op: 'add' | 'remove', text }
+//   sources   { op: 'add' | 'remove', text }
+//   scoring   { op: 'weight', kind, key, weight }       weight 0..3 (0 = not counted)
+//             { op: 'define', kind, key, definition }   what a 0 and a 10 mean
+//   brief     { op: 'set', text }                        the AI instructions
+//   names     { op: 'add', name, url, kind, why }        → an add_item proposal
+//             { op: 'remove', item_id }                  → a remove_item proposal
+//
+// The names step changes WHO is watched, not the rules, so its two ops become item
+// proposals (the kinds the item page and the weekly ask also file) rather than rules
+// versions. Every other step's change becomes, once approved, a new rules version.
+
+const STEPS = Object.freeze([
+  Object.freeze({ key: 'searches', label: 'searches', title: 'what we search for' }),
+  Object.freeze({ key: 'sources', label: 'sources', title: 'what we read' }),
+  Object.freeze({ key: 'names', label: 'names', title: 'who we watch' }),
+  Object.freeze({ key: 'scoring', label: 'scoring', title: 'how we score' }),
+  Object.freeze({ key: 'brief', label: 'brief', title: 'what we ask the AI to write' }),
+]);
+const STEP_KEYS = Object.freeze(STEPS.map((s) => s.key));
+const RULE_STEPS = Object.freeze(['searches', 'sources', 'scoring', 'brief']);
+const ITEM_KINDS = Object.freeze(['competitor', 'partner', 'topic']);
+
+const LIMITS = Object.freeze({ text: 300, brief: 4000, name: 200, url: 500, why: 500, reason: 500, maxWeight: 3, maxList: 40 });
+
+const clean = (s) => String(s == null ? '' : s).replace(/\s+/g, ' ').trim();
+const same = (a, b) => clean(a).toLowerCase() === clean(b).toLowerCase();
+const isHttp = (u) => /^https?:\/\/[^\s<>"']+$/i.test(u);
+const fail = (reason, field) => ({ ok: false, reason, ...(field ? { field } : {}) });
+
+// The rules fields a version carries, normalised (a row from the database, or a
+// version built here).
+function fieldsOf(v) {
+  const r = v || {};
+  return {
+    search_queries: Array.isArray(r.search_queries) ? r.search_queries.map(String) : [],
+    sources: Array.isArray(r.sources) ? r.sources.map(String) : [],
+    rubric: r.rubric && typeof r.rubric === 'object' ? JSON.parse(JSON.stringify(r.rubric)) : {},
+    instructions: typeof r.instructions === 'string' ? r.instructions : '',
+  };
+}
+
+// checkReason(text) → { ok, reason } — every proposal says why, in one line.
+function checkReason(text) {
+  const r = clean(text);
+  if (!r) return fail('reason_required', 'reason');
+  if (r.length > LIMITS.reason) return fail('reason_too_long', 'reason');
+  return { ok: true, reason: r };
+}
+
+// checkChange(step, change, rules) → { ok: true, step, change, kind } | { ok: false, reason, field }
+// `kind` is the proposal kind it files as: rule_change, add_item or remove_item. The
+// change is rebuilt from known fields only, so nothing a caller adds rides along.
+function checkChange(step, change, rules) {
+  if (!STEP_KEYS.includes(step)) return fail('unknown_step', 'step');
+  const c = change && typeof change === 'object' && !Array.isArray(change) ? change : null;
+  if (!c) return fail('bad_change', 'change');
+  const f = fieldsOf(rules);
+  if (step === 'searches' || step === 'sources') {
+    const list = step === 'searches' ? f.search_queries : f.sources;
+    const text = clean(c.text);
+    if (!text) return fail('text_required', 'change.text');
+    if (text.length > LIMITS.text) return fail('text_too_long', 'change.text');
+    if (c.op === 'add') {
+      if (list.some((x) => same(x, text))) return fail('already_there', 'change.text');
+      if (list.length >= LIMITS.maxList) return fail('list_full', 'change.text');
+    } else if (c.op === 'remove') {
+      if (!list.some((x) => same(x, text))) return fail('not_there', 'change.text');
+    } else return fail('bad_op', 'change.op');
+    return { ok: true, step, kind: 'rule_change', change: { op: c.op, text } };
+  }
+  if (step === 'scoring') {
+    const dims = Array.isArray(f.rubric[c.kind]) ? f.rubric[c.kind] : null;
+    if (!dims) return fail('unknown_kind', 'change.kind');
+    const dim = dims.find((d) => d && d.key === c.key);
+    if (!dim) return fail('unknown_dimension', 'change.key');
+    if (c.op === 'weight') {
+      const w = Number(c.weight);
+      if (!Number.isInteger(w) || w < 0 || w > LIMITS.maxWeight) return fail('bad_weight', 'change.weight');
+      if (w === weightOf(dim)) return fail('no_change', 'change.weight');
+      return { ok: true, step, kind: 'rule_change', change: { op: 'weight', kind: c.kind, key: c.key, weight: w } };
+    }
+    if (c.op === 'define') {
+      const d = clean(c.definition);
+      if (!d) return fail('text_required', 'change.definition');
+      if (d.length > LIMITS.text) return fail('text_too_long', 'change.definition');
+      if (same(d, dim.definition)) return fail('no_change', 'change.definition');
+      return { ok: true, step, kind: 'rule_change', change: { op: 'define', kind: c.kind, key: c.key, definition: d } };
+    }
+    return fail('bad_op', 'change.op');
+  }
+  if (step === 'brief') {
+    if (c.op !== 'set') return fail('bad_op', 'change.op');
+    const text = String(c.text == null ? '' : c.text).trim();
+    if (!text) return fail('text_required', 'change.text');
+    if (text.length > LIMITS.brief) return fail('text_too_long', 'change.text');
+    if (same(text, f.instructions)) return fail('no_change', 'change.text');
+    return { ok: true, step, kind: 'rule_change', change: { op: 'set', text } };
+  }
+  // names
+  if (c.op === 'add') {
+    const name = clean(c.name);
+    if (!name) return fail('name_required', 'change.name');
+    if (name.length > LIMITS.name) return fail('name_too_long', 'change.name');
+    const kind = ITEM_KINDS.includes(c.kind) ? c.kind : null;
+    if (!kind) return fail('unknown_kind', 'change.kind');
+    const url = clean(c.url);
+    if (url && (url.length > LIMITS.url || !isHttp(url))) return fail('bad_url', 'change.url');
+    if (!url && kind !== 'topic') return fail('url_required', 'change.url');
+    const why = clean(c.why).slice(0, LIMITS.why);
+    return { ok: true, step, kind: 'add_item', change: { op: 'add', name, url, kind, why } };
+  }
+  if (c.op === 'remove') {
+    const id = Number(c.item_id);
+    if (!Number.isSafeInteger(id) || id <= 0) return fail('bad_item', 'change.item_id');
+    return { ok: true, step, kind: 'remove_item', change: { op: 'remove', item_id: id } };
+  }
+  return fail('bad_op', 'change.op');
+}
+
+const weightOf = (d) => (d && Number.isInteger(d.weight) ? d.weight : 1);
+
+// applyChange(rules, step, change) → { ok: true, fields } | { ok: false, reason }.
+// Re-checks the change against THESE rules first (they may be newer than the ones it was
+// proposed against), so an approval never writes a version the change does not fit.
+function applyChange(rules, step, change) {
+  if (!RULE_STEPS.includes(step)) return fail('not_a_rule_change');
+  const check = checkChange(step, change, rules);
+  if (!check.ok) return { ok: false, reason: 'no_longer_applies', why: check.reason };
+  const f = fieldsOf(rules);
+  const c = check.change;
+  if (step === 'searches' || step === 'sources') {
+    const field = step === 'searches' ? 'search_queries' : 'sources';
+    f[field] = c.op === 'add' ? [...f[field], c.text] : f[field].filter((x) => !same(x, c.text));
+  } else if (step === 'scoring') {
+    f.rubric[c.kind] = f.rubric[c.kind].map((d) => (d.key !== c.key ? d
+      : (c.op === 'weight' ? { ...d, weight: c.weight } : { ...d, definition: c.definition })));
+  } else {
+    f.instructions = c.text;
+  }
+  return { ok: true, fields: f };
+}
+
+const short = (s, n = 48) => { const t = clean(s); return t.length > n ? `${t.slice(0, n - 1)}…` : t; };
+function dimLabel(rules, kind, key) {
+  const d = (fieldsOf(rules).rubric[kind] || []).find((x) => x.key === key);
+  return d ? (d.label || d.key) : key;
+}
+
+// summarize(step, change, rules) → the slider's one line ("+ GitHub releases as a source").
+function summarize(step, change, rules) {
+  const c = change || {};
+  switch (step) {
+    case 'searches': return c.op === 'add' ? `+ "${short(c.text)}" as a search` : `dropped the "${short(c.text)}" search`;
+    case 'sources': return c.op === 'add' ? `+ ${short(c.text)} as a source` : `stopped reading ${short(c.text)}`;
+    case 'scoring': return c.op === 'weight'
+      ? `"${dimLabel(rules, c.kind, c.key)}" counts ×${c.weight}`
+      : `"${dimLabel(rules, c.kind, c.key)}" redefined`;
+    case 'brief': return 'brief rewritten';
+    case 'names': return c.op === 'add' ? `+ ${short(c.name)} watched` : 'stop watching a name';
+    default: return 'rules changed';
+  }
+}
+
+// changedSteps(prev, next) → the steps whose rules differ between two versions: the
+// slider marks those nodes when it lands on `next`.
+function changedSteps(prev, next) {
+  if (!prev) return [];
+  const a = fieldsOf(prev);
+  const b = fieldsOf(next);
+  const out = [];
+  if (JSON.stringify(a.search_queries) !== JSON.stringify(b.search_queries)) out.push('searches');
+  if (JSON.stringify(a.sources) !== JSON.stringify(b.sources)) out.push('sources');
+  if (JSON.stringify(a.rubric) !== JSON.stringify(b.rubric)) out.push('scoring');
+  if (a.instructions !== b.instructions) out.push('brief');
+  return out;
+}
+
+// proposedNext(active, openRuleProposals) → the slider's "v8?": the version in use with
+// every open rule change applied in the order they were made. A change that would not
+// apply on top of the others is left out and counted, so the preview never lies about
+// what approving all of them would give.
+function proposedNext(active, open) {
+  if (!active) return null;
+  let fields = fieldsOf(active);
+  let applied = 0;
+  let skipped = 0;
+  const list = [...(open || [])].sort((x, y) => Number(x.id) - Number(y.id));
+  for (const p of list) {
+    const payload = p.payload || {};
+    const out = applyChange(fields, payload.step, payload.change);
+    if (out.ok) { fields = out.fields; applied += 1; } else skipped += 1;
+  }
+  if (!applied) return null;
+  return { version: Number(active.version) + 1, ...fields, applied, skipped, changed: changedSteps(active, fields) };
+}
+
+// ---- the cost of one run, by step -------------------------------------------------
+//
+// The weekly run makes ONE Messages API call per tracked item (research.js): the
+// searches, the page reads, the scoring and the written lines all happen in that call,
+// and the API bills them as searches plus tokens in and out. So no stored number says
+// what each step cost. The SPLIT is always an estimate, from ADR 0394's per-item figure
+// (2 searches; about 25k tokens of search and page content read; about 2k tokens out,
+// shared here evenly between the scores with their reasons and the written takeaways).
+// The TOTAL is real when a run has finished with a cost (market_watch_run_items, the
+// accounting the cap sums, and its cost_log mirror), and the page says which.
+const EXPECTED_PER_ITEM = Object.freeze({ searches: 2, inputTokens: 25000, outputTokens: 2000 });
+
+function estimatePerItem(pricing, model) {
+  const searches = pricing.priceWebSearches(EXPECTED_PER_ITEM.searches);
+  const reading = pricing.priceUsage(model, { input_tokens: EXPECTED_PER_ITEM.inputTokens }).usd;
+  const output = pricing.priceUsage(model, { output_tokens: EXPECTED_PER_ITEM.outputTokens }).usd;
+  return { read: searches + reading, score: output / 2, brief: output / 2 };
+}
+
+const cents = (n) => Math.round(n * 100) / 100;
+
+// costByStep({ items, lastRun, pricing, model }) →
+//   { basis: 'run' | 'estimate', total, run: {n, items, cost_log_usd} | null,
+//     rows: [{ step, label, usd }], split: 'estimate' }
+// lastRun: { n, items, cost_usd, cost_log_usd } of the newest run that ran with a cost.
+function costByStep({ items, lastRun = null, pricing, model }) {
+  const per = estimatePerItem(pricing, model);
+  const perTotal = per.read + per.score + per.brief;
+  const count = Math.max(0, Number(items) || 0);
+  const real = lastRun && Number(lastRun.cost_usd) > 0 ? lastRun : null;
+  const scoredNames = real ? Number(real.items) || count : count;
+  const total = real ? Number(real.cost_usd) : perTotal * count;
+  const share = (part) => (perTotal > 0 ? total * (part / perTotal) : 0);
+  return {
+    basis: real ? 'run' : 'estimate',
+    split: 'estimate',
+    total: cents(total),
+    run: real ? { n: real.n, items: scoredNames, cost_log_usd: real.cost_log_usd == null ? null : cents(Number(real.cost_log_usd)) } : null,
+    rows: [
+      { step: 'read', label: 'searches + reading pages', usd: cents(share(per.read)) },
+      { step: 'score', label: `scoring ${scoredNames} names`, usd: cents(share(per.score)) },
+      { step: 'brief', label: 'writing the brief', usd: cents(share(per.brief)) },
+    ],
+  };
+}
+
+module.exports = {
+  STEPS, STEP_KEYS, RULE_STEPS, ITEM_KINDS,
+  checkReason, checkChange, applyChange, summarize, changedSteps, proposedNext,
+  costByStep, fieldsOf, weightOf,
+};

package/modules/market-watch/rules-view.js

@@ -0,0 +1,165 @@
+'use strict';
+
+// modules/market-watch/rules-view.js — everything the rules page shows, in one read
+// (task 1004941, goal 1000137). The page is the pipeline map
+// (docs/design/mocks/market-watch/rules.html, option C): five steps with their counts,
+// each step's rules in plain words, the open proposals on each step, the version slider
+// (v1 to the version in use, plus the proposed next one) and the cost of one run by step.
+//
+// The view is built by the PURE `buildView` from rows the route reads, so the test can
+// hand it rows and read the page model without a database. Who may decide is passed in
+// (the route asks the owner check and the government port), never worked out here.
+
+const logic = require('./rules-logic');
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+const LAST_RUN_COST_SQL = `-- mw:last-run-cost
+  SELECT r.id, r.created_at,
+         COALESCE(sum(ri.cost_usd), 0) AS cost_usd,
+         (count(ri.item_id) FILTER (WHERE ri.status = 'done'))::int AS items,
+         (SELECT sum(c.amount_usd) FROM cost_log c WHERE c.source = 'market-watch:' || r.id) AS cost_log_usd
+    FROM market_watch_runs r
+    JOIN market_watch_run_items ri ON ri.run_id = r.id
+   WHERE r.project = $1 AND r.status IN ('done', 'partial') AND r.trigger <> 'seed'
+   GROUP BY r.id
+  HAVING COALESCE(sum(ri.cost_usd), 0) > 0
+   ORDER BY r.created_at DESC, r.id DESC
+   LIMIT 1`;
+
+const NAMES_SQL = `-- mw:builder-names
+  SELECT id, github_login, display_name FROM builders WHERE id = ANY($1::bigint[])`;
+
+// One person, as the page shows them: a login, never an email or an id alone.
+const who = (names, id) => {
+  if (id == null) return null;
+  const b = names.get(String(id));
+  return b ? (b.display_name || b.github_login || `builder ${id}`) : `builder ${id}`;
+};
+
+// The step a proposal is shown on. A rule change names its own; every item proposal
+// (added or removed here, or the item page's and weekly ask's kinds) is about who we
+// watch, so the owner decides all of them on the names step.
+function stepOf(p) {
+  if (p.kind === 'rule_change') return (p.payload && p.payload.step) || null;
+  return 'names';
+}
+
+// The words a step's panel shows: the rules themselves, in plain words.
+function stepRules(step, fields, items) {
+  switch (step) {
+    case 'searches': return { list: fields.search_queries };
+    case 'sources': return { list: fields.sources };
+    case 'names': return {
+      top: items.filter((i) => i.status === 'active')
+        .slice().sort((a, b) => (b.overall ?? -1) - (a.overall ?? -1) || a.name.localeCompare(b.name))
+        .slice(0, 6)
+        .map((i) => ({ id: i.id, name: i.name, kind: i.kind, overall: i.overall })),
+    };
+    case 'scoring': return {
+      kinds: Object.keys(fields.rubric).sort().map((kind) => ({
+        kind,
+        dims: (fields.rubric[kind] || []).map((d) => ({ key: d.key, label: d.label || d.key, definition: d.definition || '', weight: logic.weightOf(d) })),
+      })),
+    };
+    case 'brief': return { text: fields.instructions };
+    default: return {};
+  }
+}
+
+// buildView({ versions, items, proposals, lastRun, names, decide, now, pricing, model })
+function buildView({ versions = [], items = [], proposals = [], lastRun = null, names = new Map(), decide = {}, now = new Date(), pricing, model }) {
+  const ordered = versions.filter((v) => v.status === 'active' || v.status === 'superseded')
+    .slice().sort((a, b) => a.version - b.version);
+  const active = ordered.find((v) => v.status === 'active') || null;
+  const fields = logic.fieldsOf(active);
+  const live = items.filter((i) => i.status === 'active');
+  const weekAgo = new Date(new Date(now).getTime() - 7 * DAY_MS);
+  const openRule = proposals.filter((p) => p.status === 'open' && p.kind === 'rule_change');
+  const next = logic.proposedNext(active, openRule);
+
+  const open = proposals.filter((p) => p.status === 'open').map((p) => ({
+    id: p.id,
+    kind: p.kind,
+    origin: p.origin,
+    step: stepOf(p),
+    summary: (p.payload && p.payload.summary) || logic.summarize(stepOf(p), p.payload && p.payload.change, active) || p.kind,
+    reason: p.reason || '',
+    by: who(names, p.proposed_by),
+    created_at: p.created_at,
+    change: p.payload && p.payload.change ? p.payload.change : null,
+    at_vote: !!(p.payload && p.payload.matter_id),
+    name: p.kind === 'add_item' && p.payload ? (p.payload.name || (p.payload.change && p.payload.change.name) || null) : null,
+  }));
+
+  const countBy = (step) => open.filter((p) => p.step === step).length;
+  const dims = Object.values(fields.rubric).reduce((n, d) => Math.max(n, Array.isArray(d) ? d.length : 0), 0);
+  const briefLines = fields.instructions ? fields.instructions.split(/(?<=[.!?])\s+/).filter(Boolean).length : 0;
+  const steps = logic.STEPS.map((s) => {
+    const base = { key: s.key, label: s.label, title: s.title, open: countBy(s.key), rules: stepRules(s.key, fields, items) };
+    if (s.key === 'searches') return { ...base, value: fields.search_queries.length, sub: 'queries a run' };
+    if (s.key === 'sources') return { ...base, value: fields.sources.length, sub: 'kinds of page' };
+    if (s.key === 'names') {
+      // new = added this week by a proposal or a member, never the seeded research
+      const fresh = live.filter((i) => i.added_via !== 'seed' && i.created_at && new Date(i.created_at) >= weekAgo).length;
+      return { ...base, value: live.length, sub: fresh ? `${fresh} new this week` : 'being watched' };
+    }
+    if (s.key === 'scoring') return { ...base, value: dims, sub: 'things, 0–10' };
+    return { ...base, value: briefLines, sub: briefLines === 1 ? 'line of instructions' : 'lines of instructions' };
+  });
+
+  const history = ordered.map((v, i) => ({
+    version: v.version,
+    status: v.status,
+    summary: v.summary || '',
+    reason: v.reason || '',
+    by: who(names, v.author_id),
+    approved_by: who(names, v.approved_by),
+    approved_at: v.approved_at || null,
+    changed: logic.changedSteps(i ? ordered[i - 1] : null, v),
+    rules: logic.fieldsOf(v),
+  }));
+
+  return {
+    steps,
+    active: active ? { id: active.id, version: active.version } : null,
+    history,
+    next: next ? {
+      version: next.version,
+      applied: next.applied,
+      skipped: next.skipped,
+      changed: next.changed,
+      rules: { search_queries: next.search_queries, sources: next.sources, rubric: next.rubric, instructions: next.instructions },
+    } : null,
+    proposals: open,
+    cost: logic.costByStep({ items: live.length, lastRun, pricing, model }),
+    decide,
+  };
+}
+
+// readView(pool, { project, now, decide, pricing, model }) — the rows, then buildView.
+async function readView(pool, { project, now = new Date(), decide = {}, pricing, model, db = require('./db') }) {
+  const [rules, items, proposals, { rows: [last] }] = await Promise.all([
+    db.rules(pool, { project }),
+    db.listItems(pool, { project }),
+    db.proposals(pool, { project, status: 'open', limit: 200 }),
+    pool.query(LAST_RUN_COST_SQL, [project]),
+  ]);
+  let lastRun = null;
+  if (last) {
+    const runs = await db.numberedRuns(pool, { project });
+    const n = (runs.find((r) => String(r.id) === String(last.id)) || {}).n || null;
+    lastRun = { n, items: last.items, cost_usd: Number(last.cost_usd), cost_log_usd: last.cost_log_usd == null ? null : Number(last.cost_log_usd) };
+  }
+  const ids = new Set();
+  for (const v of rules.versions) { if (v.author_id) ids.add(String(v.author_id)); if (v.approved_by) ids.add(String(v.approved_by)); }
+  for (const p of proposals) if (p.proposed_by) ids.add(String(p.proposed_by));
+  const names = new Map();
+  if (ids.size) {
+    const { rows } = await pool.query(NAMES_SQL, [[...ids]]);
+    for (const b of rows) names.set(String(b.id), b);
+  }
+  return buildView({ versions: rules.versions, items, proposals, lastRun, names, decide, now, pricing, model });
+}
+
+module.exports = { buildView, readView };

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.24.7",
+  "version": "1.24.9",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.24.7",
+      "version": "1.24.9",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.24.7",
+  "version": "1.24.9",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",