@bongos/core 1.19.300 → 1.19.302

package/tests/idea_spark_hall.mjs

@@ -0,0 +1,263 @@
+// tests/idea_spark_hall.mjs
+//
+// task 1002930 (BV1.R154, goal 1000062) — the spark handoff in the hall,
+// exercised at RUNTIME rather than over the source.
+//
+// The done-when this file owns: "starting development from the queue leads into
+// the R152 authoring surface pre-filled with the spark". So it boots ideas.js
+// twice against a stub DOM — once plainly, once as ?develop=<id> — and asserts
+// what a builder would actually get: the queue rows and where they point, the
+// spark's own words carried into the composer, a title that is shown but NOT
+// editable, and the file going to the develop route with no title or grade on it.
+//
+// (The author-only mark control is the other half of R154 and lives with the page
+// it renders on — tests/idea_detail_page.mjs.)
+//
+// Pure vm + file read.
+//
+// Run:  node tests/idea_spark_hall.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HALL = path.join(ROOT, 'modules/hall-ui/public');
+const SRC = fs.readFileSync(path.join(HALL, 'ideas.js'), 'utf8');
+
+const { BASE_TEMPLATE } = require('../modules/ideas/templates.js');
+const TEMPLATE = {
+  key: BASE_TEMPLATE.key,
+  label: BASE_TEMPLATE.label,
+  fields: BASE_TEMPLATE.fields.map((f) => ({ key: f.key, label: f.label, required: !!f.required, substance_min: f.substanceMin || 0 })),
+};
+
+const SPARK = {
+  id: '77', title: 'Let a builder mute one channel', status: 'open', grade: 'spark',
+  body_md: 'I muted the whole server and then missed a ship.',
+  captured_by: '9', captured_at: '2026-08-01T00:00:00Z', filed_by_login: 'thinker',
+  field_values: null, completeness_score: null, template_key: null,
+};
+
+const QUEUE = [
+  SPARK,
+  { id: '78', title: 'A shared changelog', status: 'open', grade: 'spark', captured_at: '2026-07-30T00:00:00Z', filed_by_login: null },
+];
+
+function boot({ search = '', sparks = QUEUE, count = null, idea = SPARK, ideaOk = true, store = {} } = {}) {
+  const els = new Map();
+  const makeEl = () => ({
+    dataset: {}, style: {}, textContent: '', value: '', hidden: false, disabled: false,
+    readOnly: false, tabIndex: 0, _html: '', _handlers: {},
+    classList: { add() {}, remove() {} },
+    setAttribute() {}, getAttribute() { return null; },
+    addEventListener(t, fn) { this._handlers[t] = fn; },
+    querySelector() { return makeEl(); }, querySelectorAll() { return []; }, appendChild() {},
+    set innerHTML(v) { this._html = String(v); }, get innerHTML() { return this._html; },
+  });
+
+  const documentObj = {
+    title: '', body: { dataset: { page: 'ideas' } },
+    documentElement: { dataset: {}, style: {}, classList: { add() {}, remove() {} } },
+    getElementById(id) { if (!els.has(id)) els.set(id, makeEl()); return els.get(id); },
+    querySelector(sel) { return this.getElementById(String(sel).replace(/^#/, '')); },
+    querySelectorAll() { return []; },
+    createElement() { return makeEl(); },
+    addEventListener() {},
+  };
+
+  const calls = [];
+  const client = {
+    inbox: {
+      getInboxTemplate: async () => ({ status: 200, ok: true, data: { template: TEMPLATE } }),
+      getInboxSparks: async () => { calls.push(['sparks', null]); return { status: 200, ok: true, data: { sparks, count: count == null ? sparks.length : count } }; },
+      getInboxId: async (a) => { calls.push(['idea', a]); return { status: ideaOk ? 200 : 404, ok: ideaOk, data: ideaOk ? { idea } : null }; },
+      postInboxScore: async (a) => { calls.push(['score', a]); return { status: 200, ok: true, data: { score: 60, fields: TEMPLATE.fields.map((f) => ({ key: f.key, substance: 24, floor: 40, ratio: 0.6 })) } }; },
+      postInbox: async (a) => { calls.push(['capture', a]); return { status: 201, ok: true, data: { idea: { id: '900', grade: 'full', completeness_score: 80 } } }; },
+      postInboxIdDevelop: async (a) => { calls.push(['develop', a]); return { status: 200, ok: true, data: { idea: { ...idea, grade: 'full', completeness_score: 80, ideator_credit: 5 } } }; },
+    },
+  };
+
+  const toasts = [];
+  const windowObj = {
+    __BRANDING__: {}, __MODULES__: { enabled: {} },
+    BongosClient: { createClient: () => client },
+    OTB: {
+      escapeHtml: (s) => String(s == null ? '' : s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c])),
+      $: (sel) => documentObj.querySelector(sel),
+      toast: (m) => toasts.push(m),
+    },
+    localStorage: {
+      getItem: (k) => (Object.prototype.hasOwnProperty.call(store, k) ? store[k] : null),
+      setItem: (k, v) => { store[k] = String(v); },
+      removeItem: (k) => { delete store[k]; },
+    },
+    location: { hostname: 'builders.cloudbongos.com', pathname: '/ideas', search, assign() {} },
+    addEventListener() {},
+  };
+
+  const sandbox = { window: windowObj, document: documentObj, location: windowObj.location, console, setTimeout, clearTimeout, Date };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(SRC, sandbox, { filename: 'ideas.js' });
+
+  const el = (id) => documentObj.getElementById(id);
+  return {
+    calls, toasts, store, el,
+    queueHtml: () => el('fi-queue').innerHTML,
+    fill: () => { for (const f of TEMPLATE.fields) el(`fi-f-${f.key}`).value = `an answer for ${f.key} long enough to count`; },
+    submit: () => el('fi-form')._handlers.submit({ preventDefault() {} }),
+  };
+}
+
+const settle = () => new Promise((r) => setTimeout(r, 0));
+
+let passed = 0;
+let failed = 0;
+async function test(name, fn) {
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.error(`  FAIL ${name}\n    ${err.message}`); }
+}
+
+// --- the queue -----------------------------------------------------------
+
+await test('the queue lists each waiting spark, naming who had the thought', async () => {
+  const r = boot();
+  await settle(); await settle();
+  const html = r.queueHtml();
+  assert.ok(html.includes('Let a builder mute one channel'));
+  assert.ok(html.includes('A shared changelog'));
+  assert.match(html, /@thinker/);
+  assert.match(html, /an unnamed builder/, 'a missing login degrades, it does not print @null');
+  assert.doesNotMatch(html, /undefined|null</);
+});
+
+await test('each row links to the idea PAGE and offers a develop link', async () => {
+  const r = boot();
+  await settle(); await settle();
+  const html = r.queueHtml();
+  assert.match(html, /href="\/idea\/77"/, 'the title links at the R153 page');
+  assert.match(html, /href="\?develop=77"/, 'and the action enters develop mode');
+});
+
+await test('an empty queue says how one gets filled', async () => {
+  const r = boot({ sparks: [] });
+  await settle(); await settle();
+  assert.match(r.queueHtml(), /Nothing is waiting/);
+  assert.match(r.queueHtml(), /author offers a quick idea up/);
+});
+
+await test('a truncated queue says so', async () => {
+  const r = boot({ count: 9 });
+  await settle(); await settle();
+  assert.match(r.queueHtml(), /Showing 2 of 9/);
+});
+
+// --- develop mode: pre-filled with the spark -----------------------------
+
+await test('develop mode carries the spark\'s own words into the composer', async () => {
+  const r = boot({ search: '?develop=77' });
+  await settle(); await settle(); await settle();
+  assert.equal(r.el('fi-develop').hidden, false);
+  assert.equal(r.el('fi-develop-title').textContent, SPARK.title);
+  assert.equal(r.el('fi-develop-body').textContent, SPARK.body_md);
+  assert.match(r.el('fi-develop-who').textContent, /@thinker/);
+  assert.match(r.el('fi-develop-who').textContent, /keep the credit/);
+});
+
+await test('the title is carried but NOT editable — developing must not rename it', async () => {
+  const r = boot({ search: '?develop=77' });
+  await settle(); await settle(); await settle();
+  assert.equal(r.el('fi-title').value, SPARK.title, 'the title is present');
+  assert.equal(r.el('fi-title').readOnly, true);
+  assert.equal(r.el('fi-title').hidden, true, 'and shown as a fact in the block above, not as a field');
+  assert.equal(r.el('fi-title-label').hidden, true);
+});
+
+await test('the action says what it does', async () => {
+  const r = boot({ search: '?develop=77' });
+  await settle(); await settle(); await settle();
+  assert.equal(r.el('fi-submit').textContent, 'Develop this idea');
+});
+
+await test('filing in develop mode calls the DEVELOP route with no title and no grade', async () => {
+  const r = boot({ search: '?develop=77' });
+  await settle(); await settle(); await settle();
+  r.fill();
+  await r.submit();
+  await settle();
+  const call = r.calls.find((c) => c[0] === 'develop');
+  assert.ok(call, 'POST /inbox/:id/develop was called');
+  assert.equal(call[1].id, '77');
+  assert.ok(call[1].body.field_values, 'it carries the five answers');
+  assert.ok(!('title' in call[1].body), 'and no title');
+  assert.ok(!('grade' in call[1].body), 'and no grade');
+  assert.ok(!r.calls.some((c) => c[0] === 'capture'), 'and never files a second idea');
+});
+
+await test('the developer is told about the split', async () => {
+  const r = boot({ search: '?develop=77' });
+  await settle(); await settle(); await settle();
+  r.fill();
+  await r.submit();
+  await settle();
+  assert.ok(r.toasts.some((t) => /split with its author/.test(t)), `toasts: ${JSON.stringify(r.toasts)}`);
+});
+
+await test('the develop draft is stored under its OWN key', async () => {
+  const store = {};
+  const r = boot({ search: '?develop=77', store });
+  await settle(); await settle(); await settle();
+  r.fill();
+  // The draft write is debounced behind an input event; call the saver's trigger.
+  r.el('fi-f-purpose')._handlers.input();
+  await new Promise((res) => setTimeout(res, 600));
+  const keys = Object.keys(store);
+  assert.ok(keys.length >= 1, `something was stored (${JSON.stringify(keys)})`);
+  assert.ok(keys.every((k) => k.includes('develop:77')), `keyed per idea: ${JSON.stringify(keys)}`);
+});
+
+// --- develop mode refuses what the server would refuse -------------------
+
+await test('a non-spark cannot be developed from this surface', async () => {
+  for (const [grade, expect] of [['full', /already been developed/], ['quick', /not a Big Idea Spark/]]) {
+    const r = boot({ search: '?develop=77', idea: { ...SPARK, grade } });
+    await settle(); await settle(); await settle();
+    assert.match(r.el('fi-sub').textContent, expect, grade);
+    assert.equal(r.el('fi-form').hidden, true, 'and the form is not offered');
+  }
+});
+
+await test('an unloadable idea says so instead of showing an empty form', async () => {
+  const r = boot({ search: '?develop=77', ideaOk: false });
+  await settle(); await settle(); await settle();
+  assert.match(r.el('fi-sub').textContent, /Could not load idea 77/);
+  assert.equal(r.el('fi-form').hidden, true);
+});
+
+await test('the plain composer is unaffected — develop mode is never entered', async () => {
+  const r = boot();
+  await settle(); await settle();
+  // Asserted as "develop mode never ran" rather than "#fi-develop is hidden":
+  // the stub DOM does not parse the markup, so the element's `hidden` default is
+  // false here regardless. The block ships with the `hidden` attribute, which
+  // tests/idea_hall_composer.mjs pins over the HTML source; what matters at
+  // runtime is that nothing reveals it, and the tell is that no idea was fetched.
+  assert.ok(!r.calls.some((c) => c[0] === 'idea'), 'no idea is loaded without ?develop=');
+  assert.equal(r.el('fi-title').readOnly, false, 'the title stays editable');
+  r.el('fi-title').value = 'a new idea';
+  r.fill();
+  await r.submit();
+  await settle();
+  const call = r.calls.find((c) => c[0] === 'capture');
+  assert.ok(call, 'it still files through POST /inbox');
+  assert.equal(call[1].body.grade, 'full');
+  assert.equal(call[1].body.title, 'a new idea');
+});
+
+console.log(`\nidea_spark_hall: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);

package/tests/idea_triage_grade.mjs

@@ -0,0 +1,167 @@
+// tests/idea_triage_grade.mjs
+//
+// task 1002924 (BV1.R148, goal 1000062) — the grade on the triage surfaces, and
+// the ordering.
+//
+// The done-when has three clauses and the THIRD is the one with a trap in it:
+//   1. each idea in triage shows its grade at a glance;
+//   2. full ideas sort by completeness;
+//   3. quick ideas and sparks remain visible rather than being buried under
+//      scored ideas.
+//
+// (2) and (3) cannot both be satisfied by one list sorted on completeness: every
+// unscored idea lands after every scored one, so in a long inbox nobody reaches
+// them. The answer is two ordered groups, and that is what these assertions pin —
+// including that the group split is on GRADE and not on "has a score", which
+// would misfile an unscored Full Idea.
+//
+// Pure require of the two exported helpers; no session, no network.
+//
+// Run:  node tests/idea_triage_grade.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const { gradeLabel, partition } = require('../scripts/gds/render-ideas.js');
+
+const open = (o) => ({ status: 'open', captured_at: '2026-08-01T00:00:00Z', ...o });
+
+let passed = 0;
+let failed = 0;
+function test(name, fn) {
+  try { fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.error(`  FAIL ${name}\n    ${err.message}`); }
+}
+
+// --- (1) the grade at a glance ------------------------------------------
+
+test('a Full Idea shows its grade AND its score', () => {
+  assert.equal(gradeLabel({ grade: 'full', completeness_score: 88 }), 'FULL 88/100');
+});
+
+test('a Full Idea with no score says unscored rather than implying zero', () => {
+  // R142 returns null for anything it cannot score, and that is a legal stored
+  // state — "unscorable" and "not yet scored" deliberately look the same.
+  assert.equal(gradeLabel({ grade: 'full', completeness_score: null }), 'FULL (unscored)');
+  assert.doesNotMatch(gradeLabel({ grade: 'full', completeness_score: null }), /0/);
+});
+
+test('a spark says what it is waiting for', () => {
+  assert.match(gradeLabel({ grade: 'spark' }), /awaiting development/);
+});
+
+test('a missing grade reads as quick — the R140 absence-is-quick design', () => {
+  // Not a gap to hide: an idea with no ideas_grades row IS quick.
+  assert.equal(gradeLabel({}), 'quick');
+  assert.equal(gradeLabel({ grade: null }), 'quick');
+});
+
+// --- (2) full ideas sort by completeness --------------------------------
+
+test('Full Ideas are ordered best-formed first', () => {
+  const g = partition([
+    open({ id: 1, grade: 'full', completeness_score: 40 }),
+    open({ id: 2, grade: 'full', completeness_score: 95 }),
+    open({ id: 3, grade: 'full', completeness_score: 70 }),
+  ]);
+  assert.deepEqual(g.openFull.map((i) => i.id), [2, 3, 1]);
+});
+
+test('ties among Full Ideas fall back to recency, so the order is stable', () => {
+  const g = partition([
+    open({ id: 1, grade: 'full', completeness_score: 70, captured_at: '2026-07-01T00:00:00Z' }),
+    open({ id: 2, grade: 'full', completeness_score: 70, captured_at: '2026-08-01T00:00:00Z' }),
+  ]);
+  assert.deepEqual(g.openFull.map((i) => i.id), [2, 1]);
+});
+
+test('an UNSCORED Full Idea sorts last among full ideas, but stays a full idea', () => {
+  // The split is on GRADE, not on "has a score" — filing it with the quick ideas
+  // would hide a five-field idea from the group a triager reads for five-field
+  // ideas, purely because the scorer could not score it.
+  const g = partition([
+    open({ id: 1, grade: 'full', completeness_score: null }),
+    open({ id: 2, grade: 'full', completeness_score: 10 }),
+  ]);
+  assert.deepEqual(g.openFull.map((i) => i.id), [2, 1]);
+  assert.equal(g.openRest.length, 0);
+});
+
+// --- (3) quick ideas and sparks are NOT buried --------------------------
+
+test('quick ideas and sparks get their OWN group, newest first', () => {
+  const g = partition([
+    open({ id: 1, grade: 'quick', captured_at: '2026-07-01T00:00:00Z' }),
+    open({ id: 2, grade: 'spark', captured_at: '2026-08-10T00:00:00Z' }),
+    open({ id: 3, captured_at: '2026-08-05T00:00:00Z' }),
+  ]);
+  assert.deepEqual(g.openRest.map((i) => i.id), [2, 3, 1]);
+  assert.equal(g.openFull.length, 0);
+});
+
+test('a quick idea is NEVER pushed behind scored ideas — it has its own top', () => {
+  // The trap the done-when names. With one score-sorted list, id 99 would be
+  // 50th; in its own group it is first.
+  const many = Array.from({ length: 49 }, (_, i) => open({ id: i + 1, grade: 'full', completeness_score: 50 + (i % 40) }));
+  const g = partition([...many, open({ id: 99, grade: 'quick', captured_at: '2026-08-20T00:00:00Z' })]);
+  assert.equal(g.openRest[0].id, 99, 'first in its own group, not last in a merged one');
+  assert.equal(g.openFull.length, 49);
+});
+
+test('every open idea lands in exactly one group — none is dropped', () => {
+  const ideas = [
+    open({ id: 1, grade: 'full', completeness_score: 80 }),
+    open({ id: 2, grade: 'spark' }),
+    open({ id: 3, grade: 'quick' }),
+    open({ id: 4 }),
+    open({ id: 5, grade: 'full', completeness_score: null }),
+  ];
+  const g = partition(ideas);
+  const seen = [...g.openFull, ...g.openRest].map((i) => i.id).sort((a, b) => a - b);
+  assert.deepEqual(seen, [1, 2, 3, 4, 5]);
+  assert.equal(g.open.length, 5, 'the undivided open list is still returned for the count');
+});
+
+test('a non-open idea is not in either open group', () => {
+  const g = partition([
+    open({ id: 1, grade: 'full', completeness_score: 90 }),
+    { id: 2, status: 'discarded', grade: 'full', completeness_score: 99, captured_at: new Date().toISOString() },
+  ]);
+  assert.deepEqual(g.openFull.map((i) => i.id), [1]);
+  assert.ok(!g.openRest.some((i) => i.id === 2));
+});
+
+// --- the surfaces agree --------------------------------------------------
+
+test('the interactive walk and the generated file share ONE grade label', () => {
+  // Two triage surfaces describing the same idea differently defeats the point of
+  // a grade at a glance, so triage.js imports the label rather than restating it.
+  const triage = fs.readFileSync(path.join(ROOT, 'scripts/gds/triage.js'), 'utf8');
+  assert.match(triage, /require\('\.\/render-ideas'\)/, 'triage.js imports the shared helpers');
+  assert.match(triage, /gradeLabel\(idea\)/, 'and prints the shared label on each card');
+  assert.ok(!/FULL \$\{|SPARK —/.test(triage), 'triage.js does not restate the label text');
+});
+
+test('the walk is ordered by the shared partition, not re-sorted locally', () => {
+  const triage = fs.readFileSync(path.join(ROOT, 'scripts/gds/triage.js'), 'utf8');
+  assert.match(triage, /partition\(ideas\)/);
+  assert.match(triage, /openFull\.concat\(grouped\.openRest\)/, 'full ideas first, then the rest');
+});
+
+test('the skill documents the grade and the two-group walk', () => {
+  const skill = fs.readFileSync(path.join(ROOT, '.claude/skills/idea-triage/SKILL.md'), 'utf8');
+  assert.match(skill, /completeness_score/);
+  assert.match(skill, /Full Ideas first, best-formed first/);
+  // And it must carry the REASON, not just the instruction — the next person to
+  // "simplify" this into one sorted list needs to know why it is two.
+  assert.match(skill, /nobody reaches them/);
+  assert.match(skill, /Do not auto-convert/, 'and R149\'s rule for a Full Idea');
+});
+
+console.log(`\nidea_triage_grade: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);