Mirror geo-retrofit-benchmark on HF (Zenodo concept DOI 10.5281/zenodo.21602375)

src/geo-retrofit.mjs

@@ -0,0 +1,319 @@
+#!/usr/bin/env node
+/**
+ * geo-retrofit.mjs - additive answer-first / FAQ retrofit engine (standalone,
+ * sanitized reproduction).
+ *
+ * This is the mutation half of the two-part engine (paired with
+ * ./audit-geo.mjs, the gate half). Given an article's HTML and a
+ * (already-generated) answer paragraph and/or FAQ Q&A pairs, it builds the
+ * two LOCKED markup fragments and injects them idempotently:
+ *   - an answer-first "lead" block, prepended as the literal first content
+ *   - a FAQ accordion block, appended as the literal last content
+ *
+ * Both fragments are additive-only: the engine never edits or deletes any
+ * pre-existing content. Idempotency is enforced two ways: (1) a data
+ * attribute marker skips re-injection on a second run, (2) a
+ * gate-compliance skip (needsLead/needsFaq re-use the SAME gate functions
+ * from ./audit-geo.mjs) so an article that already satisfies the gate on
+ * its own body is left untouched too.
+ *
+ * WHAT THIS REPO DELIBERATELY DOES NOT SHIP: the production version of this
+ * engine calls an on-prem LLM (Ollama) to GENERATE the answer paragraph and
+ * FAQ pairs, and reads/writes a project-specific manifest + content-tree
+ * layout. Both are stripped here - text generation is a pluggable concern
+ * (any LLM, or a human editor, can supply the `answer`/`pairs` inputs), and
+ * this repo demonstrates the transform + gate mechanics standalone, with
+ * zero project coupling and zero network calls. See RESULTS.md for the real
+ * production numbers this exact transform produced.
+ *
+ * CLI:
+ *   node src/geo-retrofit.mjs <before.html> --lead "..." --faq pairs.json
+ *
+ * Usage:
+ *   node src/geo-retrofit.mjs fixtures/sample-before.html
+ */
+
+import { readFileSync, writeFileSync } from 'node:fs';
+import { argv, exit } from 'node:process';
+
+import { stripPreCode, parseBlocks, checkAnswerFirst, countFaqPairs, wordCount, hasCiteSource, FAQ_MIN, FAQ_MAX, ANSWER_BLOCK_MIN_WORDS, ANSWER_BLOCK_MAX_WORDS } from './audit-geo.mjs';
+
+// Re-export the cross-imported gate primitives so a caller can import
+// everything it needs from this single module.
+export { stripPreCode, parseBlocks, checkAnswerFirst, countFaqPairs, wordCount, hasCiteSource };
+
+// --- HTML-escape helper (inlined, standalone - no project dependency) -----------
+
+/**
+ * escapeHtmlText - escapes the 5 XML/HTML special characters. ALWAYS applied
+ * to generated text (answer paragraph, FAQ questions/answers) before
+ * interpolation into the fragment markup - stored self-XSS mitigation.
+ */
+export function escapeHtmlText(value) {
+  return String(value ?? '')
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+// --- LOCKED markup constants (do not re-derive) ----------------------------------
+
+export const LEAD_HEADING = { it: 'Risposta diretta', en: 'Direct answer' };
+export const FAQ_HEADING = { it: 'Domande frequenti', en: 'Frequently asked questions' };
+
+const LEAD_MARKER = 'data-geo-retrofit="lead"';
+const FAQ_MARKER = 'data-geo-retrofit="faq"';
+// A pre-existing bare <section class="faq"> (no marker at all) is also
+// treated as "already has FAQ" - never stack a second block on top of one
+// the article already ships.
+const BARE_FAQ_SECTION_RE = /<section[^>]*\bclass=["'][^"']*\bfaq\b[^"']*["']/i;
+
+// --- Markup builders (exact LOCKED shape, escape ALL generated text) ------------
+
+/**
+ * buildLeadFragment - the answer-first lead block. `headingText` is always
+ * the LOCKED literal ("Risposta diretta"/"Direct answer"), never generated.
+ * `answerText` is externally-supplied (LLM or human) and MUST be escaped
+ * before interpolation.
+ */
+export function buildLeadFragment(headingText, answerText) {
+  return (
+    `<div class="geo-retrofit-lead" data-geo-retrofit="lead">\n` +
+    `  <h2>${escapeHtmlText(headingText)}</h2>\n` +
+    `  <p>${escapeHtmlText(answerText)}</p>\n` +
+    `</div>`
+  );
+}
+
+/**
+ * buildFaqFragment - the FAQ accordion block. `pairs` is an array of
+ * `{ question, answer }` - both externally-supplied and MUST be escaped
+ * before interpolation. The inner `<h3>` inside `<summary>` is what makes
+ * countFaqPairs() (./audit-geo.mjs) register each pair - the gate scans the
+ * raw tag sequence, `<details>/<summary>/<div>` wrappers are invisible to it.
+ */
+export function buildFaqFragment(headingText, pairs) {
+  const items = pairs
+    .map(
+      (pair) =>
+        `  <details class="geo-retrofit-faq-item">\n` +
+        `    <summary class="geo-retrofit-faq-question"><h3>${escapeHtmlText(pair.question)}</h3></summary>\n` +
+        `    <div class="geo-retrofit-faq-answer">\n` +
+        `      <p>${escapeHtmlText(pair.answer)}</p>\n` +
+        `    </div>\n` +
+        `  </details>`,
+    )
+    .join('\n');
+  return (
+    `<section class="faq geo-retrofit-faq" data-geo-retrofit="faq">\n` +
+    `  <h2>${escapeHtmlText(headingText)}</h2>\n` +
+    `${items}\n` +
+    `</section>`
+  );
+}
+
+// --- Idempotency (marker skip + gate-compliance skip) ----------------------------
+
+/**
+ * needsLead - false when the article already carries the lead marker, OR
+ * when its own pre-mutation body already opens with a valid answer-first
+ * structure (checkAnswerFirst present===true) - re-uses the gate's own
+ * function so the self-check and the acceptance gate agree by construction.
+ */
+export function needsLead(html) {
+  if (html.includes(LEAD_MARKER)) return false;
+  const blocks = parseBlocks(stripPreCode(html));
+  const { present } = checkAnswerFirst(blocks);
+  return !present;
+}
+
+/**
+ * needsFaq - false when the article already carries the FAQ marker, OR has
+ * ANY pre-existing bare `<section class="faq">`, OR its own pre-mutation
+ * body already has a gate-parseable FAQ pair count in [FAQ_MIN,FAQ_MAX].
+ */
+export function needsFaq(html) {
+  if (html.includes(FAQ_MARKER)) return false;
+  if (BARE_FAQ_SECTION_RE.test(html)) return false;
+  const blocks = parseBlocks(stripPreCode(html));
+  const count = countFaqPairs(blocks);
+  return !(count >= FAQ_MIN && count <= FAQ_MAX);
+}
+
+// --- Injection at fixed offsets (no <pre>/<code> collision risk - insertion
+// points are the literal file-start/file-end) ------------------------------------
+
+/** injectLead - prepends `leadHtml` as the literal FIRST content. */
+export function injectLead(html, leadHtml) {
+  return `${leadHtml}\n${html}`;
+}
+
+/** injectFaq - appends `faqHtml` as the literal LAST content. */
+export function injectFaq(html, faqHtml) {
+  return `${html}\n${faqHtml}`;
+}
+
+/**
+ * injectFragments - applies needsLead()/needsFaq() BEFORE injecting either
+ * fragment, so an idempotent re-run (or an already-gate-compliant article)
+ * yields byte-identical output. Never mutates in place.
+ *
+ * @param {string} html
+ * @param {{lead?: string|null, faq?: string|null}} [fragments]
+ * @returns {{html: string, leadInjected: boolean, faqInjected: boolean}}
+ */
+export function injectFragments(html, { lead = null, faq = null } = {}) {
+  let out = html;
+  let leadInjected = false;
+  let faqInjected = false;
+  if (lead && needsLead(html)) {
+    out = injectLead(out, lead);
+    leadInjected = true;
+  }
+  if (faq && needsFaq(html)) {
+    out = injectFaq(out, faq);
+    faqInjected = true;
+  }
+  return { html: out, leadInjected, faqInjected };
+}
+
+// --- Post-generation guards (defensive habit for ANY externally-supplied
+// text, whether it comes from an LLM or a human editor) --------------------------
+
+const CJK_RE = /[一-鿿぀-ヿ가-힣]/;
+const INSTRUCTION_ECHO_RE = /(40-60 word|direct answer|no em-dash)/i;
+const FENCE_RE = /^```[a-zA-Z]*\n?([\s\S]*?)\n?```$/;
+const LEADING_PREAMBLE_RE =
+  /^(here(?:'s|\s+is)\s+the\s+(?:answer|direct answer|faq)[:\s]*|sure[,!\s]+here(?:'s|\s+is)?[:\s]*|certainly[,!\s]+here(?:'s|\s+is)?[:\s]*|of\s+course[,!\s]+)/i;
+
+/**
+ * sanitizeGenerated - strips markdown fences/leading preamble a model
+ * sometimes adds despite instructions, THEN normalizes em/en-dash to a
+ * plain hyphen, THEN rejects (throws) output polluted with CJK characters
+ * or literal instruction-echo phrases. Applied BEFORE word-count/FAQ-count
+ * validation so counts are computed on final, cleaned text.
+ */
+export function sanitizeGenerated(text) {
+  let out = String(text ?? '').trim();
+  const fenceMatch = out.match(FENCE_RE);
+  if (fenceMatch) out = fenceMatch[1].trim();
+  for (let i = 0; i < 3; i++) {
+    const stripped = out.replace(LEADING_PREAMBLE_RE, '').trim();
+    if (stripped === out) break;
+    out = stripped;
+  }
+  // em-dash (U+2014) and en-dash (U+2013) - no fake polish, plain hyphen only.
+  out = out.replace(/[—–]/g, '-');
+  if (CJK_RE.test(out)) {
+    throw new Error('sanitizeGenerated: rejected CJK-polluted output');
+  }
+  if (INSTRUCTION_ECHO_RE.test(out)) {
+    throw new Error('sanitizeGenerated: rejected instruction-echo in output');
+  }
+  return out;
+}
+
+/** validateLead - lead paragraph word count must be self-counted, never trusted from the source. */
+export function validateLead(text) {
+  const count = wordCount(text);
+  return count >= ANSWER_BLOCK_MIN_WORDS && count <= ANSWER_BLOCK_MAX_WORDS;
+}
+
+/**
+ * validateFaq - pair count must be in [FAQ_MIN,FAQ_MAX] AND every question
+ * must end in a literal "?" with NOTHING after (a trailing parenthetical or
+ * entity after the "?" would silently fail countFaqPairs()).
+ */
+export function validateFaq(pairs) {
+  if (!Array.isArray(pairs) || pairs.length < FAQ_MIN || pairs.length > FAQ_MAX) return false;
+  return pairs.every((pair) => typeof pair?.question === 'string' && pair.question.trim().endsWith('?'));
+}
+
+/**
+ * assertParity - a bilingual-publishing requirement: every language variant
+ * of the same article must produce the SAME number of FAQ pairs. Returns
+ * false on mismatch rather than throwing, so callers can retry the shorter
+ * side before giving up on the pair.
+ */
+export function assertParity(itPairs, enPairs) {
+  return Array.isArray(itPairs) && Array.isArray(enPairs) && itPairs.length === enPairs.length;
+}
+
+// --- CLI entry point (demonstration only - reads a before.html + JSON lead/faq
+// payload, writes the retrofitted HTML to stdout) --------------------------------
+
+function parseArgs(args) {
+  const out = {};
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (!a.startsWith('--')) continue;
+    const key = a.slice(2);
+    const next = args[i + 1];
+    if (next !== undefined && !next.startsWith('--')) {
+      out[key] = next;
+      i += 1;
+    } else {
+      out[key] = true;
+    }
+  }
+  return out;
+}
+
+async function main() {
+  const positional = argv.slice(2).filter((a) => !a.startsWith('--'));
+  const args = parseArgs(argv.slice(2));
+
+  if (positional.length === 0) {
+    console.log(
+      'Usage: node src/geo-retrofit.mjs <before.html> [--lang it|en] [--payload payload.json] [--out out.html]',
+    );
+    console.log('  payload.json shape: { "answer": "...", "faqPairs": [{"question":"...","answer":"..."}] }');
+    exit(0);
+    return;
+  }
+
+  const lang = args.lang || 'en';
+  const html = readFileSync(positional[0], 'utf8');
+
+  let answer = null;
+  let faqPairs = null;
+  if (args.payload) {
+    const payload = JSON.parse(readFileSync(String(args.payload), 'utf8'));
+    answer = payload.answer ?? null;
+    faqPairs = payload.faqPairs ?? null;
+  }
+
+  let lead = null;
+  let faq = null;
+  if (answer && needsLead(html)) {
+    const cleaned = sanitizeGenerated(answer);
+    if (!validateLead(cleaned)) throw new Error(`lead word count ${wordCount(cleaned)} outside the answer-block window`);
+    lead = buildLeadFragment(LEAD_HEADING[lang] ?? LEAD_HEADING.en, cleaned);
+  }
+  if (faqPairs && needsFaq(html)) {
+    const cleanedPairs = faqPairs.map((p) => ({ question: sanitizeGenerated(p.question), answer: sanitizeGenerated(p.answer) }));
+    if (!validateFaq(cleanedPairs)) throw new Error('FAQ payload failed validation (count or question shape)');
+    faq = buildFaqFragment(FAQ_HEADING[lang] ?? FAQ_HEADING.en, cleanedPairs);
+  }
+
+  const { html: out, leadInjected, faqInjected } = injectFragments(html, { lead, faq });
+  console.error(`[geo-retrofit] leadInjected=${leadInjected} faqInjected=${faqInjected}`);
+
+  if (args.out) {
+    writeFileSync(String(args.out), out, 'utf8');
+    console.error(`[geo-retrofit] wrote ${args.out}`);
+  } else {
+    console.log(out);
+  }
+  exit(0);
+}
+
+const isDirectRun = argv[1] && import.meta.url === `file://${argv[1]}`;
+if (isDirectRun) {
+  main().catch((err) => {
+    console.error(`[geo-retrofit] fatal: ${err.stack || err.message}`);
+    exit(1);
+  });
+}