story-theme-mcp 1.0.0

package/src/build/recipe.js

@@ -0,0 +1,47 @@
+import { sectionFromPreset, blockFromPreset, collectIds } from './scaffold.js';
+
+const clone = (value) => JSON.parse(JSON.stringify(value));
+
+function findContainer(node, type) {
+  for (const id of node.block_order || []) {
+    const block = node.blocks?.[id];
+    if (!block) continue;
+    if (block.type === type) return block;
+    const inner = findContainer(block, type);
+    if (inner) return inner;
+  }
+  return null;
+}
+
+function readableId(type, taken) {
+  const base = type.replace(/[^A-Za-z0-9]+/g, '_');
+  let id = base;
+  for (let index = 2; taken.has(id); index++) id = `${base}_${index}`;
+  return id;
+}
+
+// Composes a template from a recipe. Returns the data and, per section, what its content must say.
+export function buildFromRecipe(catalog, recipe, { language = 'fr', base = null } = {}) {
+  const data = base ? clone(base) : { sections: {}, order: [] };
+  const taken = collectIds(data);
+  const roles = [];
+  for (const step of recipe.steps) {
+    const { id, section } = sectionFromPreset(catalog, step.type, { preset: step.preset, language, taken, id: readableId(step.type, taken) });
+    if (step.settings) section.settings = { ...(section.settings || {}), ...step.settings };
+    for (const extra of step.blocks || []) {
+      const container = extra.into ? findContainer(section, extra.into) : section;
+      if (!container) throw new Error(`recette ${recipe.id} : conteneur « ${extra.into} » introuvable dans ${step.type}`);
+      const { id: blockId, block } = blockFromPreset(catalog, extra.type, { preset: extra.preset, language, taken, settings: extra.settings });
+      container.blocks = container.blocks || {};
+      container.blocks[blockId] = block;
+      const order = container.block_order || [];
+      const anchor = extra.after ? order.findIndex((candidate) => container.blocks[candidate]?.type === extra.after) : -1;
+      order.splice(anchor === -1 ? order.length : anchor + 1, 0, blockId);
+      container.block_order = order;
+    }
+    data.sections[id] = section;
+    data.order.push(id);
+    roles.push({ section: id, type: step.type, preset: step.preset, role: step.role });
+  }
+  return { data, roles };
+}

package/src/build/scaffold.js

@@ -0,0 +1,130 @@
+import crypto from 'node:crypto';
+import { isSafeId } from '../validate/template.js';
+
+export function createIdFactory(taken = new Set(), random = () => crypto.randomBytes(4).toString('base64url').replace(/[^A-Za-z0-9]/g, '').slice(0, 6).padEnd(6, 'x')) {
+  return (type) => {
+    const base = String(type).replace(/^_+/, '').replace(/[^A-Za-z0-9]+/g, '_').slice(0, 24) || 'block';
+    let id;
+    do id = `${base}_${random()}`;
+    while (taken.has(id));
+    taken.add(id);
+    return id;
+  };
+}
+
+// Every id already used in a template, so new ones never collide.
+export function collectIds(data) {
+  const ids = new Set();
+  const walk = (node) => {
+    for (const [id, block] of Object.entries(node?.blocks || {})) {
+      ids.add(id);
+      walk(block);
+    }
+  };
+  for (const [id, section] of Object.entries(data?.sections || {})) {
+    ids.add(id);
+    walk(section);
+  }
+  return ids;
+}
+
+// Converts a preset block list (array, or object + block_order) to the template shape.
+function convertBlocks(catalog, list, language, nextId) {
+  const entries = Array.isArray(list)
+    ? list.map((block) => [block.id, block])
+    : Object.entries(list || {}).map(([id, block]) => [id, block]);
+  const blocks = {};
+  const order = [];
+  const mapping = {};
+  for (const [presetId, block] of entries) {
+    if (!block?.type) continue;
+    const id = block.static ? presetId : isSafeId(presetId) && !Object.hasOwn(blocks, presetId) ? nextId.reserve(presetId, { rename: true }) : nextId(block.type);
+    if (presetId) mapping[presetId] = id;
+    const out = { type: block.type };
+    if (block.static) out.static = true;
+    const settings = catalog.translateDeep(block.settings || {}, language);
+    out.settings = settings;
+    if (block.blocks && (Array.isArray(block.blocks) ? block.blocks.length : Object.keys(block.blocks).length)) {
+      const child = convertBlocks(catalog, block.blocks, language, nextId);
+      out.blocks = child.blocks;
+      out.block_order = orderFrom(block, child);
+    }
+    blocks[id] = out;
+    if (!block.static) order.push(id);
+  }
+  return { blocks, order, mapping };
+}
+
+function orderFrom(preset, converted) {
+  // An object-shaped preset may carry its own block_order, written with the preset's ids.
+  if (!Array.isArray(preset.blocks) && Array.isArray(preset.block_order)) {
+    return preset.block_order.map((id) => converted.mapping[id]).filter((id) => id && !converted.blocks[id].static);
+  }
+  return converted.order;
+}
+
+function idFactoryWithReserve(taken) {
+  const next = createIdFactory(taken);
+  // Preset ids may be renamed on collision; an id asked for explicitly may not.
+  next.reserve = (id, { rename = false } = {}) => {
+    if (!isSafeId(id)) throw new Error(`identifiant « ${id} » invalide (lettres, chiffres, - et _ ; pas de nom réservé)`);
+    if (taken.has(id)) {
+      if (!rename) throw new Error(`l'identifiant « ${id} » est déjà utilisé dans ce fichier`);
+      return next(id.replace(/_[A-Za-z0-9]{6}$/, ''));
+    }
+    taken.add(id);
+    return id;
+  };
+  return next;
+}
+
+export function sectionFromPreset(catalog, type, { preset, language = 'fr', taken = new Set(), id = null } = {}) {
+  const entry = catalog.section(type);
+  if (!entry?.schema) throw new Error(`section « ${type} » inconnue`);
+  const found = catalog.findPreset(entry.schema, preset, language);
+  if (preset !== undefined && preset !== null && preset !== '' && !found.preset) {
+    const names = catalog.presetNames(entry.schema, language);
+    throw new Error(`preset « ${preset} » introuvable pour ${type}${names.length ? ` (presets : ${names.join(' ; ')})` : ' (cette section n’a pas de preset)'}`);
+  }
+  const nextId = idFactoryWithReserve(taken);
+  const sectionId = id ? nextId.reserve(id) : nextId(type);
+  const section = { type };
+  const source = found.preset;
+  if (source) {
+    const converted = convertBlocks(catalog, source.blocks, language, nextId);
+    if (Object.keys(converted.blocks).length) {
+      section.blocks = converted.blocks;
+      section.block_order = orderFrom(source, converted);
+    }
+    section.settings = catalog.translateDeep(source.settings || {}, language);
+  } else {
+    section.settings = {};
+  }
+  return { id: sectionId, section, preset: source ? catalog.t(source.name, language) : null };
+}
+
+export function blockFromPreset(catalog, type, { preset, language = 'fr', taken = new Set(), id = null, settings = null } = {}) {
+  const entry = catalog.block(type);
+  if (!entry?.schema) throw new Error(`bloc « ${type} » inconnu`);
+  const found = catalog.findPreset(entry.schema, preset, language);
+  if (preset !== undefined && preset !== null && preset !== '' && !found.preset) {
+    const names = catalog.presetNames(entry.schema, language);
+    throw new Error(`preset « ${preset} » introuvable pour le bloc ${type}${names.length ? ` (presets : ${names.join(' ; ')})` : ''}`);
+  }
+  const nextId = idFactoryWithReserve(taken);
+  const blockId = id ? nextId.reserve(id) : nextId(type);
+  const block = { type, settings: {} };
+  const source = found.preset;
+  if (source) {
+    block.settings = catalog.translateDeep(source.settings || {}, language);
+    if (source.blocks) {
+      const converted = convertBlocks(catalog, source.blocks, language, nextId);
+      if (Object.keys(converted.blocks).length) {
+        block.blocks = converted.blocks;
+        block.block_order = orderFrom(source, converted);
+      }
+    }
+  }
+  if (settings) Object.assign(block.settings, settings);
+  return { id: blockId, block };
+}

package/src/build/texts.js

@@ -0,0 +1,43 @@
+import { normalizeText } from '../theme/catalog.js';
+import { lintTemplate, sampleTexts } from '../validate/design.js';
+import { plainText } from '../validate/richtext.js';
+
+const TEXT_TYPES = ['text', 'textarea', 'richtext', 'inline_richtext', 'url'];
+
+// Every text, rich text and link of a template or section group, with its exact target
+// ("section/block/…"), in reading order. `flag` is 'fix' when the review would flag it
+// (sample copy, English, an unverified claim), 'sample' for short generic theme labels that
+// may stay, null otherwise. The same list feeds list_texts and the automatic rewrite pass.
+export function collectTexts(catalog, rel, data, { language = 'fr' } = {}) {
+  const samples = sampleTexts(catalog);
+  const flagged = new Map(
+    lintTemplate(catalog, rel, data, { language })
+      .filter((finding) => finding.level === 'important')
+      .map((finding) => [finding.path, finding.message])
+  );
+  const out = [];
+  const visit = (kind, type, settings, target) => {
+    const schema = (kind === 'section' ? catalog.section(type) : catalog.block(type))?.schema;
+    for (const setting of schema?.settings || []) {
+      if (!setting.id || !TEXT_TYPES.includes(setting.type)) continue;
+      const value = settings?.[setting.id];
+      if (value === undefined || value === '') continue;
+      const issue = flagged.get(`${target}.${setting.id}`) || null;
+      const flag = issue ? 'fix' : setting.type !== 'url' && samples.has(normalizeText(plainText(value))) ? 'sample' : null;
+      out.push({ target, blockType: type, setting: setting.id, type: setting.type, value, flag, issue });
+    }
+  };
+  const walk = (node, target) => {
+    for (const [id, block] of Object.entries(node.blocks || {})) {
+      visit('block', block.type, block.settings, `${target}/${id}`);
+      walk(block, `${target}/${id}`);
+    }
+  };
+  for (const id of data.order || []) {
+    const section = data.sections?.[id];
+    if (!section) continue;
+    visit('section', section.type, section.settings, id);
+    walk(section, id);
+  }
+  return out;
+}

package/src/config.js

@@ -0,0 +1,28 @@
+import os from 'node:os';
+import path from 'node:path';
+import { VERSION } from './version.js';
+
+const expand = (value) => (value && value.startsWith('~') ? path.join(os.homedir(), value.slice(1)) : value);
+
+// L'espace membre Story Thème : d'où vient la dernière version publiée du thème.
+const DEFAULT_API = 'https://story-theme.com';
+
+export function loadConfig(env = process.env) {
+  const themeDir = env.STORY_THEME_DIR || '';
+  return {
+    version: VERSION,
+    // Jeton personnel du client (espace membre > MCP & Appli). Sans lui, pas de thème à distance :
+    // le MCP retombe sur son cache, puis sur un dossier local.
+    token: (env.STORY_MCP_TOKEN || '').trim(),
+    apiBase: (env.STORY_MCP_API || DEFAULT_API).trim(),
+    // `test` demande la version en test du thème : accordé par le serveur aux seuls testeurs.
+    canal: env.STORY_MCP_CANAL === 'test' ? 'test' : 'stable',
+    // Dossier de thème lu quand il est imposé (développement du thème lui-même). Explicite =
+    // posé dans l'environnement : il passe alors AVANT le thème publié.
+    themeDir: path.resolve(expand(themeDir || '~/Developer/story-theme-shopify')),
+    themeDirExplicit: Boolean(themeDir),
+    // Projets, instantanés, exports, et cache des versions du thème.
+    homeDir: path.resolve(expand(env.STORY_MCP_HOME || '~/Documents/Story Theme MCP')),
+    defaultLanguage: env.STORY_MCP_LANGUAGE || 'fr',
+  };
+}