@myrtilleio/redline 0.1.0

package/src/taste.js

@@ -0,0 +1,80 @@
+// The taste ledger: every judgment the reviewer makes, kept across rounds.
+//
+// A review produces more than fixes. Each green mark, each accepted fix, each
+// redo and each approval sent back says something about what this reviewer
+// wants. Redline keeps those judgments in .redline/taste.json (never pruned by
+// `redline clear`) and renders them as TASTE.md for the agent: keep what was
+// approved, lean toward what was accepted, and don't try again what was rejected.
+
+const cut = (s, n) => {
+  const t = String(s || '').replace(/\s+/g, ' ').trim();
+  return t.length > n ? t.slice(0, n - 1) + '…' : t;
+};
+
+/** One judgment about item `a`: keep | accepted | redo | sent-back | new-look | reading. */
+export function tasteEntry(kind, a, extra = {}) {
+  if (!a) return null;
+  const e = {
+    kind,
+    at: new Date().toISOString(),
+    round: a.round,
+    page: a.page,
+    selector: a.target && a.target.selector,
+    text: a.target && cut(a.target.text, 80),
+    comment: cut(a.comment, 300),
+    resolution: cut(a.resolution, 300),
+  };
+  if (extra.reply) e.reply = cut(extra.reply, 300);
+  if (Array.isArray(extra.diff) && extra.diff.length) e.diff = extra.diff.slice(0, 6);
+  for (const k of Object.keys(e)) if (e[k] === undefined || e[k] === '') delete e[k];
+  return e;
+}
+
+const where = (e) => `${e.page && e.page !== '/' ? `\`${e.page}\` ` : ''}\`${e.selector || 'page'}\`${e.text ? ` “${cut(e.text, 50)}”` : ''}`;
+
+/** The latest judgment per element, so a later decision replaces an earlier one. */
+function latest(entries, kinds) {
+  const by = new Map();
+  for (const e of entries) if (kinds.includes(e.kind)) by.set(`${e.page}|${e.selector}|${e.kind}`, e);
+  return [...by.values()];
+}
+
+/** Render the ledger as Markdown for the agent. */
+export function renderTaste(entries, rounds = []) {
+  const keep = latest(entries, ['keep', 'new-look']);
+  const accepted = latest(entries, ['accepted']);
+  const rejected = entries.filter((e) => e.kind === 'redo').slice(-30);
+  const sentBack = entries.filter((e) => e.kind === 'sent-back').slice(-20);
+  const reading = entries.filter((e) => e.kind === 'reading').at(-1);
+  const judged = rounds.filter((r) => (r.accepted || 0) + (r.redone || 0) > 0);
+
+  const out = [
+    '# What this reviewer approved and rejected',
+    '',
+    'Kept by Redline across every round (it survives `redline clear`). Read it before you change the design:',
+    'keep what was approved, lean toward what was accepted, and never try again what was rejected.',
+  ];
+  if (judged.length) {
+    const rate = (r) => `${Math.round((100 * (r.accepted || 0)) / ((r.accepted || 0) + (r.redone || 0)))}%`;
+    out.push('', `**Accepted first time:** ${judged.map((r) => `round ${r.n} ${rate(r)}`).join(' → ')}`);
+  }
+  if (reading) out.push('', '## What the page is for', '', `In the reviewer's words: “${reading.reply}”`);
+  if (keep.length) {
+    out.push('', '## Keep exactly as it is', '');
+    for (const e of keep) out.push(`- ${where(e)}${e.comment ? `: ${e.comment}` : ''}${e.kind === 'new-look' ? ' (its current look was approved)' : ''}`);
+  }
+  if (accepted.length) {
+    out.push('', '## Accepted: the direction they like', '');
+    for (const e of accepted) out.push(`- ${where(e)}: asked “${e.comment || 'a change'}”, accepted “${e.resolution || 'the fix'}”`);
+  }
+  if (rejected.length) {
+    out.push('', "## Rejected: don't try these again", '');
+    for (const e of rejected) out.push(`- ${where(e)}: “${e.resolution || 'the fix'}” was not it${e.reply ? `. The reviewer said: “${e.reply}”` : ''}`);
+  }
+  if (sentBack.length) {
+    out.push('', '## Broke an approval (sent back)', '');
+    for (const e of sentBack) out.push(`- ${where(e)} changed after it was approved${e.diff ? `: ${e.diff.join('; ')}` : ''}`);
+  }
+  if (!keep.length && !accepted.length && !rejected.length && !sentBack.length && !reading) out.push('', 'Nothing yet.');
+  return out.join('\n') + '\n';
+}

package/src/verify.js

@@ -0,0 +1,71 @@
+// Checking approvals on demand: photograph each one again, now, and compare it with
+// how it was approved, at every width it's guarded at. Nothing is recorded: this is
+// for the agent before it closes a round (catch your own regressions before the
+// reviewer does) and for CI (`redline verify`), not the reviewer's record.
+import { combineChecks, diffFingerprints, isGuarded, MOBILE } from './guards.js';
+import { createRedlineServer } from './server.js';
+import { ShotService } from './shots.js';
+
+/**
+ * Results per approval: { a, status: held | changed | missing | no-baseline, diff }.
+ * `shots` is a ShotService that can load the site (see openVerifier).
+ */
+export async function verifyApprovals({ store, shots }) {
+  const results = [];
+  for (const a of (await store.all()).filter(isGuarded)) {
+    const g = a.guard || {};
+    if (!g.base) {
+      results.push({ a, status: 'no-baseline', diff: [] });
+      continue;
+    }
+    const check = async (key, base) => {
+      const found = await shots.capture(a.id, key, '', { dry: true }).catch(() => null);
+      const fp = found && found.fp;
+      const diff = diffFingerprints(base.fp, fp, { ignore: a.guardIgnore });
+      return { status: !fp ? 'missing' : diff.length ? 'changed' : 'held', diff, at: new Date().toISOString() };
+    };
+    const now = { base: g.base, check: await check('guard-now', g.base) };
+    if (g.mobile && g.mobile.base) now.mobile = { base: g.mobile.base, check: await check(`guard-now@${MOBILE}`, g.mobile.base) };
+    const { status, diff } = combineChecks(now);
+    results.push({ a, status, diff, baseShot: g.base.shot });
+  }
+  return results;
+}
+
+/** A private server on a free port, just to photograph the site with: a folder (`root`) or a dev server (`target`). */
+export async function openVerifier({ root, target, storeDir }) {
+  const server = createRedlineServer({ ...(root ? { root } : { target }), storeDir, shots: false });
+  await new Promise((ok, fail) => {
+    server.once('error', fail);
+    server.listen(0, '127.0.0.1', ok);
+  });
+  const shots = new ShotService({ store: server.store, baseUrl: () => `http://127.0.0.1:${server.address().port}` });
+  return {
+    store: server.store,
+    shots,
+    async close() {
+      await shots.close();
+      await new Promise((ok) => server.close(ok));
+    },
+  };
+}
+
+/** The results in words, for a terminal or a model. */
+export function describeVerify(results, { storeDir = '.redline', color = false } = {}) {
+  const c = (code, s) => (color ? `\x1b[${code}m${s}\x1b[0m` : s);
+  const count = (s) => results.filter((r) => r.status === s).length;
+  const lines = [];
+  for (const r of results) {
+    const name = `#${r.a.n} ${c(2, (r.a.target && r.a.target.selector) || r.a.page)}`;
+    if (r.status === 'held') lines.push(`  ${c(32, '✓')} ${name}  held`);
+    else if (r.status === 'no-baseline') lines.push(`  ○ ${name}  no baseline yet (it's taken while the review is open)`);
+    else {
+      lines.push(`  ${c(31, '✗')} ${name}  ${r.status === 'missing' ? 'is gone from the page' : 'changed'}`);
+      for (const d of r.diff) lines.push(`      ${d.replace(/`/g, '')}`);
+      lines.push(`      restore it as approved${r.baseShot ? ` (${storeDir}/${r.baseShot})` : ''}, without undoing other fixes`);
+    }
+  }
+  const summary = [`${count('held')} held`, count('changed') && `${count('changed')} changed`, count('missing') && `${count('missing')} gone`,
+    count('no-baseline') && `${count('no-baseline')} without a baseline`].filter(Boolean).join(' · ');
+  return { lines, summary, bad: count('changed') + count('missing') };
+}