@struq/skill 0.4.3 → 0.5.0

package/skills/struq/scripts/gate.mjs

@@ -0,0 +1,146 @@
+// Struq's one stop, held by the scripts instead of by advice. Nothing goes into a project before its treatment passes
+// the plan check (film-check.mjs planCheck, the same rules as check.mjs --plan) and the user's reply to it is logged in
+// STRUQ-LOG.md. blocks.mjs add and canon.mjs palette and type call these before they touch a file; blocks.mjs add also
+// installs only what the storyboard names, in the site's language, and a page transition only once there are routes.
+//
+// A refusal is two lines: the reason, then exactly what to do next. The caller prints them and exits 1.
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { planCheck, readTreatment, resolveBlock } from "./film-check.mjs";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const CATALOG = JSON.parse(readFileSync(join(here, "..", "blocks", "catalog.json"), "utf8")).blocks;
+const BY_SLUG = new Map(CATALOG.map((b) => [b.slug, b]));
+
+const CHECK_CMD = `node "${join(here, "check.mjs")}" --plan`;
+const LOG_CMD = `node "${join(here, "log.mjs")}"`;
+
+/** The approval entry check.mjs asks for too: a Step 2 Approval heading with the user's words on a Reply: line. */
+export function hasApproval(log) {
+  const entry = String(log ?? "").match(/^## Step 2 Approval[^\n]*\n([\s\S]*?)(?=^## |(?![\s\S]))/m);
+  return Boolean(entry && /^Reply:\s*["“‘'].+["”’']\s*$/m.test(entry[1]));
+}
+
+/** The page files under app/ (or src/app/): one per route. */
+export function routeCount(root) {
+  const app = ["app", join("src", "app")].map((d) => join(root, d)).find((d) => existsSync(d));
+  if (!app) return 0;
+  const walk = (dir) =>
+    readdirSync(dir).flatMap((name) => {
+      if (name === "node_modules" || name.startsWith(".")) return [];
+      const full = join(dir, name);
+      return statSync(full).isDirectory() ? walk(full) : /^page\.(tsx|jsx|js)$/.test(name) ? [full] : [];
+    });
+  return walk(app).length;
+}
+
+const read = (path) => (existsSync(path) ? readFileSync(path, "utf8") : "");
+
+/** null when STRUQ.md holds a plan that passes the plan check, else the refusal. */
+function planRefusal(root) {
+  const plan = read(join(root, "STRUQ.md"));
+  const next = `Write the treatment in STRUQ.md and run ${CHECK_CMD} until PLAN: PASS, then run this again.`;
+  if (!plan.trim()) return { reason: `No STRUQ.md in ${root}, so there is no treatment to build from.`, next };
+  const { findings } = planCheck({ plan, catalog: CATALOG, routes: Math.max(1, routeCount(root)) });
+  const failed = findings.filter((f) => f.severity === "fail");
+  if (!failed.length) return null;
+  return { reason: `The plan in STRUQ.md does not pass: ${failed.map((f) => `${f.id} (${f.detail.replace(/\.$/, "")})`).join("; ")}.`, next };
+}
+
+/** null when STRUQ-LOG.md carries the user's reply to the treatment, else the refusal. */
+function approvalRefusal(root) {
+  if (hasApproval(read(join(root, "STRUQ-LOG.md")))) return null;
+  return {
+    reason: "The treatment is not approved yet: STRUQ-LOG.md has no Step 2 Approval entry with the user's reply.",
+    next: `Send the treatment to the user and stop; when they reply, log it with ${LOG_CMD} "Step 2 Approval" "Asked: ..." "Reply: \\"<their words>\\"" and run this again.`,
+  };
+}
+
+/** The plan gate and the approval gate, in that order: null when both hold, else the first refusal. */
+export function stopRefusal(root) {
+  return planRefusal(root) ?? approvalRefusal(root);
+}
+
+const SLUG = /(?<![A-Za-z0-9-])([a-z0-9]+(?:-[a-z0-9]+)*)(?::([a-z0-9]+(?:-[a-z0-9]+)*))?(?![A-Za-z0-9-])/g;
+
+/** Every catalogue block the storyboard names, read as the plan check reads a line: after the (tone) tag, and after footer:. */
+export function namedBlocks(plan) {
+  const treatment = readTreatment(plan);
+  const named = [];
+  (treatment.storyboard ?? []).forEach((text, at) => {
+    const head = text.split("|")[0];
+    const tag = /\(([^)]*)\)/.exec(head);
+    const scene = `${at + 1} ${(tag ? head.slice(0, tag.index) : "").trim()}`.trim();
+    const zones = [tag ? head.slice(tag.index + tag[0].length) : head];
+    const footer = /\bfooter\s*:([^|]*)/i.exec(text);
+    if (footer) zones.push(footer[1]);
+    for (const zone of zones) {
+      for (const m of zone.matchAll(SLUG)) if (BY_SLUG.has(m[1])) named.push({ slug: m[1], variant: m[2] ?? null, scene });
+    }
+  });
+  if (treatment.centerpiece && BY_SLUG.has(treatment.centerpiece)) named.push({ slug: treatment.centerpiece, variant: null, scene: "Centerpiece" });
+  return { language: treatment.language, named };
+}
+
+/** The variant a block goes in: the one asked for, else the storyboard's, else the one of the site's language. */
+function chosenVariant(block, asked, named, language) {
+  if (asked) return asked;
+  const fromBoard = named.find((n) => n.slug === block.slug && n.variant)?.variant;
+  if (fromBoard) return fromBoard;
+  const own = block.variants.find((v) => resolveBlock(CATALOG, block.slug, v.id)?.home === language);
+  return own?.id ?? null;
+}
+
+/**
+ * The refusal for `blocks.mjs add`, or null when every requested block may go in. `requests` is [{ slug, variant }]
+ * with known slugs. Every refused slug is listed with its reason; nothing is installed when one is refused.
+ */
+export function addRefusal(root, requests) {
+  const stop = stopRefusal(root);
+  if (stop) return stop;
+  const { language, named } = namedBlocks(read(join(root, "STRUQ.md")));
+  const routes = routeCount(root);
+  const refused = [];
+  const unnamed = [];
+  const nexts = new Set();
+  for (const { slug, variant } of requests) {
+    const block = BY_SLUG.get(slug);
+    const chosen = chosenVariant(block, variant, named, language);
+    const film = resolveBlock(CATALOG, slug, chosen);
+    const shown = chosen ? `${slug}:${chosen}` : slug;
+    const reasons = [];
+    const exempt = slug === "header-bar" || (slug === "menu-curtain" && film.home === language);
+    if (!exempt && !named.some((n) => n.slug === slug)) {
+      reasons.push("the storyboard does not name it");
+      unnamed.push(slug);
+    }
+    if (film.home && film.home !== language) {
+      reasons.push(`it belongs to the ${film.home} language and the site's Language is ${language}`);
+      nexts.add(`Take the variant or block of the ${language} language (blocks.mjs list shows them).`);
+    }
+    if (block.kind === "page-transition" && routes < 2) {
+      reasons.push(`a page transition needs two routes and app/ holds ${routes} page.tsx`);
+      nexts.add("Leave the page transition out until app/ holds a second page.tsx.");
+    }
+    if (reasons.length) refused.push(`${shown} (${reasons.join("; ")})`);
+  }
+  if (!refused.length) return null;
+  if (unnamed.length) {
+    const asked = unnamed.join(" or ");
+    nexts.add(`Install only what the storyboard names; if the user asked for ${asked}, put it on a scene line in STRUQ.md first and run ${CHECK_CMD}.`);
+  }
+  const shown = named.filter((n, at) => n.scene !== "Centerpiece" || !named.slice(0, at).some((m) => m.slug === n.slug));
+  const board = shown.length ? shown.map((n) => `${n.scene}: ${n.variant ? `${n.slug}:${n.variant}` : n.slug}`).join(", ") : "nothing";
+  return {
+    reason: `Refused, nothing installed: ${refused.join("; ")}. The storyboard names ${board}.`,
+    next: `${[...nexts].reverse().join(" ")} Then run add again.`,
+  };
+}
+
+/** Print a refusal as its two lines and set exit code 1. */
+export function refuse(what, refusal) {
+  console.error(`FAIL ${what}: ${refusal.reason}`);
+  console.error(`Next: ${refusal.next}`);
+  process.exitCode = 1;
+}

package/skills/struq/scripts/packs.mjs

@@ -1,9 +1,10 @@
 // Struq beeldbank: which pack fits a brief, and which photos inside a pack fit this client.
 //
 // The pack rule mirrors Struq's MCP (public canon logic), in order:
-//   1. A sector word in the brief picks that sector's pack, matched as whole words (neighbouring
-//      words are also tried joined, so "e-bike" matches "ebike"). Most matches wins; table order
-//      breaks a tie.
+//   1. A sector word in the brief picks that sector's pack. A stem of four letters or more also
+//      matches its inflections and the compounds that hold it (architectenstudio, boetiekhotel);
+//      a shorter one only matches whole. Neighbouring words are also tried joined, so "e-bike"
+//      matches "ebike". Most matches wins; table order breaks a tie.
 //   2. No sector word, but the brief launches or sells a product: vitrine (product photography),
 //      and the hero scene carries the product.
 //   3. Anything else: halide, because a wrong photograph is worse than an abstract one.
@@ -24,9 +25,10 @@ export function normalize(text) {
 }
 
 export const PACK_SIGNALS = [
-  ["proof", ["restaurant", "restaurants", "visrestaurant", "bistro", "brasserie", "eetcafe", "horeca", "keuken", "chef", "kok", "koken", "kookt", "bakkerij", "bakker", "patisserie", "lunchroom", "koffiebar", "bakery", "cafe", "wine", "wijnbar", "pizzeria", "catering", "kitchen", "dining"]],
+  ["proof", ["restaurant", "restaurants", "visrestaurant", "bistro", "brasserie", "eetcafe", "horeca", "keuken", "chef", "kok", "koken", "kookt", "bakkerij", "bakker", "patisserie", "lunchroom", "koffiebar", "koffie", "bakery", "cafe", "wine", "wijnbar", "pizzeria", "catering", "kitchen", "dining"]],
   ["datum", ["architect", "architecten", "architectenbureau", "architectuur", "architectuurbureau", "woningbouw", "fabriekspand", "fabriekspanden", "stedenbouw", "vastgoed", "makelaar", "makelaardij", "projectontwikkelaar", "architects", "architecture", "realestate", "property"]],
-  ["mortar", ["bouw", "bouwbedrijf", "aannemer", "aannemersbedrijf", "renovatie", "verbouwing", "timmerman", "dakdekker", "loodgieter", "installateur", "installatiebedrijf", "elektricien", "construction", "contractor", "builder", "plumber", "renovation"]],
+  // No bare "bouw": nearly every brief opens with it as a verb ("Bouw een website voor ...").
+  ["mortar", ["bouwbedrijf", "aannemer", "aannemersbedrijf", "renovatie", "verbouwing", "timmerman", "dakdekker", "loodgieter", "installateur", "installatiebedrijf", "elektricien", "construction", "contractor", "builder", "plumber", "renovation"]],
   ["portico", ["hotel", "hotels", "resort", "vakantie", "vakantiehuis", "vakantiepark", "gastenverblijf", "reisbureau", "reizen", "travel", "holiday", "villa"]],
   ["transit", ["logistiek", "logistieke", "vracht", "vrachtvervoer", "distributie", "distributiecentrum", "transport", "transportbedrijf", "transporteur", "expeditie", "magazijn", "container", "containers", "depot", "pallets", "logistics", "freight", "warehouse", "haulage", "shipping"]],
   ["cadence", ["sport", "sportschool", "sportclub", "gym", "fitness", "crossfit", "boksen", "atletiek", "hardlopen", "wielrennen", "running", "boxing", "athletics"]],
@@ -48,14 +50,70 @@ export const PACK_SIGNALS = [
 
 export const PRODUCT_LAUNCH_WORDS = ["lancering", "lanceren", "lanceert", "gelanceerd", "productlancering", "launch", "launches", "launching", "introductie", "product", "producten", "products"];
 
+// Endings that only inflect a word (architect-en, verbouwing-en, renovatie-s, makelaar-s).
+const INFLECTIONS = new Set(["s", "e", "n", "en", "es", "er", "ers", "ing", "ingen", "ies"]);
+
+// Everyday words that hold a sector stem but do not name the sector: "zorgvuldig" (careful) reached the care pack
+// through "zorg", "natuurlijk" (natural) the nature pack through "natuur". A brief word that starts with one of these
+// never matches by stem, so each entry also covers its inflections (zorgvuldige, natuurlijke). Struq's MCP keeps the
+// same list, so both land a brief on the same pack.
+export const NOT_A_SECTOR = [
+  "zorgvuldig", "zorgeloos", "zorgeloze", "zorgelijk", "zorgen", "klantenzorg", "kwaliteitszorg",
+  "natuurlijk", "natuurkunde", "natuurkundig", "natuurgetrouw", "signatuur",
+  "kunstmatig", "kunststof", "kunstlicht",
+  "modern", "moderate", "moderator", "moderation",
+  "eventual", "operation",
+  "bedrijfscultuur", "organisatiecultuur", "werkcultuur", "teamcultuur", "agriculture",
+  "metaalachtig",
+  "verteler", "verhalenverteler",
+  "grondstof", "voedingsstof",
+  "praktijkgericht", "praktijkervaring", "praktijkvoorbeeld",
+  "whitelabel",
+];
+
+/**
+ * True when a brief word is a sector stem, an inflection of it or a compound that holds it.
+ * A stem under four letters only matches whole (so "art" never matches "smart"). A longer stem
+ * matches at the start of the word when the rest is an inflection or a word of its own (five
+ * letters or more: architect-enstudio, mode-label, keramiek-atelier, but not mode-rn), and at the
+ * end when a modifier of three letters or more comes before it (boetiek-hotel, tandarts-praktijk).
+ * A word that starts with an entry of NOT_A_SECTOR never matches by stem; a word equal to a sector
+ * word still matches whole.
+ */
+export function wordMatches(word, stem) {
+  if (word === stem) return true;
+  if (stem.length < 4) return false;
+  if (NOT_A_SECTOR.some((entry) => word.startsWith(entry))) return false;
+  if (word.startsWith(stem)) {
+    const rest = word.slice(stem.length);
+    return INFLECTIONS.has(rest) || rest.length >= 5;
+  }
+  return word.endsWith(stem) && word.length - stem.length >= 3;
+}
+
+/**
+ * A matcher for one brief: its words match by stem, neighbours joined only whole ("e bike" reads
+ * as "ebike", but "modern design" never reads as a compound of "mode").
+ */
+function briefMatcher(brief) {
+  const words = normalize(brief).split(" ").filter(Boolean);
+  const joined = new Set();
+  for (let i = 0; i < words.length - 1; i++) joined.add(`${words[i]}${words[i + 1]}`);
+  return (stem) => joined.has(stem) || words.some((w) => wordMatches(w, stem));
+}
+
+/** True when the brief says one of this pack's sector words (the pack shows the client's world). */
+export function packMatchesBrief(pack, brief) {
+  const says = briefMatcher(brief);
+  return (PACK_SIGNALS.find(([p]) => p === pack)?.[1] ?? []).some(says);
+}
+
 /** The pack a brief's own sector words point at, or null. */
 export function packSignalForBrief(brief) {
-  const words = normalize(brief).split(" ").filter(Boolean);
-  const tokens = new Set(words);
-  for (let i = 0; i < words.length - 1; i++) tokens.add(`${words[i]}${words[i + 1]}`);
+  const says = briefMatcher(brief);
   let best = null;
   for (const [pack, signals] of PACK_SIGNALS) {
-    const score = signals.filter((s) => tokens.has(s)).length;
+    const score = signals.filter(says).length;
     if (score > 0 && (!best || score > best.score)) best = { pack, score };
   }
   return best?.pack ?? null;
@@ -118,7 +176,7 @@ export function altFitsBrief(alt, brief) {
  * Keep the photos that fit this client, best fit first per slot.
  * images: [{ slot, alt, description, ... }]. Returns { keep, dropped, fit } in slot order.
  *
- * When the brief's own sector words point at this pack, its photos show the client's world and
+ * When the brief names one of this pack's sector words, its photos show the client's world and
  * only off-subject ones are left out (fit "full"). When they do not (a product launch handed
  * vitrine, a pack named by hand), a photo is kept only if its alt names something the brief is
  * about: the material, the city, the street. Otherwise none: an off-topic photo is worse than no
@@ -126,7 +184,10 @@ export function altFitsBrief(alt, brief) {
  */
 export function fitImages(pack, brief, images) {
   const b = words(brief);
-  const strict = packSignalForBrief(brief) !== pack;
+  const says = briefMatcher(brief);
+  // Strict only when the brief names none of this pack's sector words: a pack named by hand for
+  // an architect is the client's world even when another sector scores higher.
+  const strict = !packMatchesBrief(pack, brief);
   const rules = IMAGE_RULES[pack] ?? [];
   const keep = [];
   const dropped = [];
@@ -135,7 +196,7 @@ export function fitImages(pack, brief, images) {
     // Dutch compounds carry the subject inside them (meelsporen, broodkorst), so a term counts
     // when an alt word contains it; the brief's own words still have to match whole.
     const names = (t) => [...altWords].some((w) => w.includes(t));
-    const offSubject = rules.find((r) => r.terms.some(names) && !r.unless.some((u) => b.has(u)));
+    const offSubject = rules.find((r) => r.terms.some(names) && !r.unless.some(says));
     if (offSubject) dropped.push({ ...img, reason: `shows ${offSubject.subject}, which the brief does not name` });
     else if (strict && !altFitsBrief(img.alt, brief)) dropped.push({ ...img, reason: "shows nothing this brief is about" });
     else keep.push(img);