@wix/agent-skills 1.33.0 → 1.34.0

package/skills/wix-headless-replatform/scripts/benchmark-extraction.mjs

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+import { performance } from "node:perf_hooks";
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+import { parseArgs, writeJson } from "./lib/common.mjs";
+import { classifyObservedUnit, planRecursiveUnitJobs } from "./lib/extraction-detectors.mjs";
+
+export const RELEASE_GATES = Object.freeze({
+  minimumFixtures: 20,
+  segmentationPrecision: 0.90,
+  segmentationRecall: 0.95,
+  componentPrecision: 0.95,
+  componentRecall: 0.85,
+  behaviorRecall: 0.90,
+  ownership: 1,
+  qaDefectRecall: 0.95,
+  qaFalsePositiveRate: 0.05,
+  p95ExtractionMs: 10 * 60 * 1000,
+  rawEvidenceBytes: 250 * 1024 * 1024,
+  frozenSpecBytes: 10 * 1024 * 1024,
+  agentDecisions: 30,
+  agentInputTokens: 50_000,
+});
+
+export async function benchmarkExtractionCorpus({ corpusPath }) {
+  const raw = await readFile(corpusPath);
+  const corpus = JSON.parse(raw);
+  const humanApproved = corpus.status === "human-approved"
+    && corpus.approval?.human === true
+    && Boolean(corpus.approval?.reviewerId)
+    && Boolean(corpus.approval?.reviewedAt);
+  const failures = [];
+  const measurements = [];
+  let boundaryTp = 0;
+  let boundaryFp = 0;
+  let boundaryFn = 0;
+  let componentTp = 0;
+  let componentFp = 0;
+  let componentFn = 0;
+  let behaviorExpected = 0;
+  let behaviorFound = 0;
+  let ownershipExpected = 0;
+  let ownershipAccounted = 0;
+  let qaExpected = 0;
+  let qaFound = 0;
+  let qaClean = 0;
+  let qaFalsePositive = 0;
+  let agentDecisions = 0;
+
+  for (const fixture of corpus.fixtures || []) {
+    const started = performance.now();
+    const sections = fixture.sections || [];
+    const plan = planRecursiveUnitJobs(sections.map((section) => ({ id: section.id, ...section.observed })));
+    ownershipExpected += plan.jobs.length;
+    ownershipAccounted += plan.ownership.length;
+    if (plan.conflicts.length) failures.push({ fixture: fixture.id, metric: "ownership", details: plan.conflicts });
+    const expectedQa = new Set(fixture.expectedQaDefects || []);
+    const actualQa = new Set();
+    for (const section of sections) {
+      const classification = classifyObservedUnit(section.observed, { unitKind: "section", evidenceRef: `${fixture.id}#${section.id}` });
+      const predictedBoundary = classification.confidence !== "low";
+      if (predictedBoundary) boundaryTp += 1;
+      else boundaryFn += 1;
+      if (classification.confidence === "medium") agentDecisions += 1;
+      if (section.knownComponent) {
+        if (classification.confidence === "low") componentFn += 1;
+        else if (classification.kind === section.expectedKind) componentTp += 1;
+        else {
+          componentFp += 1;
+          componentFn += 1;
+          failures.push({ fixture: fixture.id, unit: section.id, metric: "component-kind", expected: section.expectedKind, actual: classification.kind });
+        }
+      } else if (classification.kind !== section.expectedKind) {
+        failures.push({ fixture: fixture.id, unit: section.id, metric: "classification", expected: section.expectedKind, actual: classification.kind });
+      }
+      const expectedStates = new Set(section.expectedStates || []);
+      const observedStates = new Set(section.observed?.behavior?.states || []);
+      behaviorExpected += expectedStates.size;
+      for (const state of expectedStates) if (observedStates.has(state)) behaviorFound += 1;
+      for (const defect of detectQaDefects(section.id, section.observed)) actualQa.add(defect);
+    }
+    qaExpected += expectedQa.size;
+    for (const defect of expectedQa) {
+      if (actualQa.has(defect)) qaFound += 1;
+      else failures.push({ fixture: fixture.id, metric: "qa-missed-defect", defect });
+    }
+    const cleanAssertions = Math.max(1, sections.length * 6 - expectedQa.size);
+    qaClean += cleanAssertions;
+    for (const defect of actualQa) if (!expectedQa.has(defect)) {
+      qaFalsePositive += 1;
+      failures.push({ fixture: fixture.id, metric: "qa-false-positive", defect });
+    }
+    measurements.push({ fixture: fixture.id, extractionMs: Number((performance.now() - started).toFixed(3)), rawEvidenceBytes: Buffer.byteLength(JSON.stringify(fixture)), frozenSpecBytes: Buffer.byteLength(JSON.stringify(plan)) });
+  }
+  const metrics = {
+    fixtureCount: corpus.fixtures?.length || 0,
+    coverage: [...new Set((corpus.fixtures || []).flatMap((fixture) => fixture.features || []))].sort(),
+    segmentationPrecision: ratio(boundaryTp, boundaryTp + boundaryFp),
+    segmentationRecall: ratio(boundaryTp, boundaryTp + boundaryFn),
+    componentPrecision: ratio(componentTp, componentTp + componentFp),
+    componentRecall: ratio(componentTp, componentTp + componentFn),
+    behaviorRecall: ratio(behaviorFound, behaviorExpected),
+    ownership: ratio(ownershipAccounted, ownershipExpected),
+    qaDefectRecall: ratio(qaFound, qaExpected),
+    qaFalsePositiveRate: ratio(qaFalsePositive, qaClean),
+    p95ExtractionMs: percentile(measurements.map((entry) => entry.extractionMs), 0.95),
+    maxRawEvidenceBytes: Math.max(0, ...measurements.map((entry) => entry.rawEvidenceBytes)),
+    maxFrozenSpecBytes: Math.max(0, ...measurements.map((entry) => entry.frozenSpecBytes)),
+    agentDecisions,
+    agentInputTokens: 0,
+  };
+  const gateResults = [
+    gate("minimum-fixtures", metrics.fixtureCount >= RELEASE_GATES.minimumFixtures, metrics.fixtureCount, RELEASE_GATES.minimumFixtures),
+    gate("segmentation-precision", metrics.segmentationPrecision >= RELEASE_GATES.segmentationPrecision, metrics.segmentationPrecision, RELEASE_GATES.segmentationPrecision),
+    gate("segmentation-recall", metrics.segmentationRecall >= RELEASE_GATES.segmentationRecall, metrics.segmentationRecall, RELEASE_GATES.segmentationRecall),
+    gate("component-precision", metrics.componentPrecision >= RELEASE_GATES.componentPrecision, metrics.componentPrecision, RELEASE_GATES.componentPrecision),
+    gate("component-recall", metrics.componentRecall >= RELEASE_GATES.componentRecall, metrics.componentRecall, RELEASE_GATES.componentRecall),
+    gate("behavior-recall", metrics.behaviorRecall >= RELEASE_GATES.behaviorRecall, metrics.behaviorRecall, RELEASE_GATES.behaviorRecall),
+    gate("ownership", metrics.ownership === RELEASE_GATES.ownership, metrics.ownership, RELEASE_GATES.ownership),
+    gate("qa-defect-recall", metrics.qaDefectRecall >= RELEASE_GATES.qaDefectRecall, metrics.qaDefectRecall, RELEASE_GATES.qaDefectRecall),
+    gate("qa-false-positive-rate", metrics.qaFalsePositiveRate <= RELEASE_GATES.qaFalsePositiveRate, metrics.qaFalsePositiveRate, RELEASE_GATES.qaFalsePositiveRate),
+    gate("p95-extraction-ms", metrics.p95ExtractionMs <= RELEASE_GATES.p95ExtractionMs, metrics.p95ExtractionMs, RELEASE_GATES.p95ExtractionMs),
+    gate("raw-evidence-bytes", metrics.maxRawEvidenceBytes <= RELEASE_GATES.rawEvidenceBytes, metrics.maxRawEvidenceBytes, RELEASE_GATES.rawEvidenceBytes),
+    gate("frozen-spec-bytes", metrics.maxFrozenSpecBytes <= RELEASE_GATES.frozenSpecBytes, metrics.maxFrozenSpecBytes, RELEASE_GATES.frozenSpecBytes),
+    gate("agent-decisions", metrics.agentDecisions <= RELEASE_GATES.agentDecisions, metrics.agentDecisions, RELEASE_GATES.agentDecisions),
+    gate("agent-input-tokens", metrics.agentInputTokens <= RELEASE_GATES.agentInputTokens, metrics.agentInputTokens, RELEASE_GATES.agentInputTokens),
+  ];
+  return {
+    schemaVersion: "0083-benchmark.1",
+    corpus: { path: corpusPath, status: corpus.status, license: corpus.license, provenance: corpus.provenance, approval: corpus.approval || null },
+    status: gateResults.every((entry) => entry.passed) && failures.length === 0
+      ? (humanApproved ? "metrics-passed-human-approved-model-regression-corpus" : "metrics-passed-awaiting-human-model-corpus-approval")
+      : "failed",
+    metrics,
+    gates: gateResults,
+    failures,
+    measurements,
+  };
+}
+
+function detectQaDefects(id, observed = {}) {
+  const defects = [];
+  if ((observed.images || []).some((image) => !String(image.alt || "").trim())) defects.push(`${id}:missing-alt`);
+  if (observed.behavior?.interactive && observed.behavior?.keyboard === false) defects.push(`${id}:keyboard-unreachable`);
+  if (observed.layout?.scrollWidth > observed.layout?.viewportWidth) defects.push(`${id}:horizontal-overflow`);
+  if (observed.behavior?.motion && observed.behavior?.reducedMotion === false) defects.push(`${id}:reduced-motion-missing`);
+  return defects;
+}
+
+function ratio(numerator, denominator) { return denominator ? Number((numerator / denominator).toFixed(4)) : 1; }
+function percentile(values, quantile) { const sorted = [...values].sort((a, b) => a - b); return sorted.length ? sorted[Math.min(sorted.length - 1, Math.ceil(sorted.length * quantile) - 1)] : 0; }
+function gate(name, passed, actual, threshold) { return { name, passed, actual, threshold }; }
+
+async function main() {
+  const args = parseArgs();
+  const corpusPath = path.resolve(String(args.corpus || "tests/fixtures/headless/0083-model-regression-corpus.json"));
+  const report = await benchmarkExtractionCorpus({ corpusPath });
+  if (args.out) await writeJson(path.resolve(String(args.out)), report);
+  console.log(JSON.stringify(report, null, 2));
+  if (report.status === "failed") process.exitCode = 1;
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) main().catch((error) => { console.error(error.stack || error.message); process.exit(1); });

package/skills/wix-headless-replatform/scripts/browser-extraction-preflight.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import { parseArgs } from "./lib/common.mjs";
+import { runBrowserExtractionPreflight } from "./lib/browser-tooling.mjs";
+
+async function main() {
+  const args = parseArgs();
+  const startDir = args["project-root"] || process.cwd();
+  const report = await runBrowserExtractionPreflight({
+    startDir,
+    fix: Boolean(args.fix),
+  });
+
+  if (args.json) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+  } else {
+    console.log(`Project root: ${report.context.projectRoot || "not found"}`);
+    console.log(`Package manager: ${report.context.packageManager}`);
+    for (const check of report.checks) {
+      const label = check.status === "pass" ? "PASS" : check.status === "skip" ? "SKIP" : "FAIL";
+      console.log(`${label} ${check.id}: ${check.message}`);
+    }
+    if (report.remediation.commands.length) {
+      console.log("");
+      console.log("Suggested commands:");
+      for (const command of report.remediation.commands) {
+        console.log(command);
+      }
+    }
+    for (const note of report.remediation.notes) {
+      console.log(note);
+    }
+  }
+
+  if (!report.ok) {
+    process.exit(1);
+  }
+}
+
+main().catch((error) => {
+  console.error(error.stack || error.message);
+  process.exit(1);
+});

package/skills/wix-headless-replatform/scripts/build-extracted-homepage.mjs

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { parseArgs, readJson, writeJson, writeText } from "./lib/common.mjs";
+import { verifyFrozenManifest } from "./lib/extraction-contract.mjs";
+import { installRegistrySelection } from "./lib/component-registry.mjs";
+import { inspectContentObject, removeContaminatedContent } from "./lib/content-boundary.mjs";
+
+const safe = (value) => String(value ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+const plain = (value) => String(value ?? "").replace(/\s+/g, " ").trim();
+
+export async function buildExtractedHomepage({ outputDir, installDependencies } = {}) {
+  const docs = path.join(outputDir, "docs", "site-clone");
+  const latest = await readJson(path.join(docs, "extraction", "latest.json"));
+  const extractionDir = path.join(docs, "extraction", latest.captureId);
+  const integrity = await verifyFrozenManifest(extractionDir);
+  if (!integrity.ok) throw new Error(`Frozen extraction integrity failed: ${integrity.failures.join("; ")}`);
+  if (integrity.manifest.manifestHash !== latest.manifestHash) throw new Error("Latest extraction pointer does not match the frozen manifest hash");
+  const index = await readJson(path.join(extractionDir, "spec-index.json"));
+  const specs = new Map();
+  for (const [id, relativePath] of Object.entries(index)) specs.set(id, await readJson(path.join(extractionDir, relativePath)));
+  const plan = await readJson(path.join(docs, "build", "build-plan.json"));
+  if (plan.manifestHash !== integrity.manifest.manifestHash) throw new Error("Build plan is stale for the current frozen manifest");
+  const componentSelection = await readJson(path.join(docs, "build", "component-selection.json"));
+  if (componentSelection.manifestHash !== plan.manifestHash) throw new Error("Component selection is stale for the current frozen manifest");
+  const registryInstallations = [];
+  for (const selection of componentSelection.selections || []) {
+    if (selection.strategy !== "curated-registry") continue;
+    registryInstallations.push({ unitId: selection.unitId, ...(await installRegistrySelection({ selection, outputDir, ...(installDependencies ? { installDependencies } : {}) })) });
+  }
+  await writeJson(path.join(docs, "build", "registry-installation.json"), {
+    schemaVersion: plan.schemaVersion,
+    manifestHash: plan.manifestHash,
+    installations: registryInstallations,
+  });
+  const selectionByUnit = new Map((componentSelection.selections || []).map((selection) => [selection.unitId, selection]));
+  const registryImports = registryComponentImports(componentSelection.selections || []);
+
+  const metadata = specs.get("metadata:home")?.document || {};
+  const foundation = specs.get("foundation:home") || {};
+  const chrome = removeContaminatedContent(specs.get("shared-chrome:home") || {});
+  const sections = [...specs.values()].filter((spec) => spec.kind === "unit" && spec.unitKind === "section").sort((a, b) => a.order - b.order);
+  const resolution = await readJson(path.join(extractionDir, "page-resolution.spec.json"));
+  const title = plain(metadata.title || metadata.openGraph?.["og:site_name"] || new URL(resolution.source.resolvedUrl).hostname);
+  const description = plain(metadata.description || "");
+  const logo = chrome.visualAssets?.logos?.find((asset) => asset.usages?.some((usage) => /header/.test(usage.context))) || chrome.visualAssets?.logos?.[0];
+  const logoPath = assetPath(logo);
+  const navigation = chrome.header?.navigation || chrome.header?.header?.navigation || [];
+  const sectionMarkup = sections.map((section) => renderSection(section, specs, selectionByUnit, registryImports.symbols)).join("\n    ");
+  const navMarkup = navigation.map((item) => renderNavItem(item)).join("");
+  const fontCss = renderFontFaces(foundation.fonts?.faces || []);
+  const direction = foundation.globalCssIntent?.direction === "rtl" ? "rtl" : "ltr";
+
+  const astro = `---
+import Layout from '../layouts/Layout.astro';
+${registryImports.lines.join("\n")}
+---
+<Layout title=${JSON.stringify(title)} description=${JSON.stringify(description)}>
+  <div data-rp-manifest=${JSON.stringify(plan.manifestHash)} data-rp-status=${JSON.stringify(plan.status)} dir=${JSON.stringify(direction)}>
+    <header class="site-header" data-rp-unit="shared-chrome:home">
+      <a href="/" aria-label=${JSON.stringify(title ? `${title} home` : "Home")}>${logoPath ? `<img src="${safe(logoPath)}" alt="${safe(logo?.accessibleName || title)}" />` : `<span>${safe(title)}</span>`}</a>
+      ${navMarkup ? `<nav aria-label="Primary"><ul>${navMarkup}</ul></nav>` : ""}
+    </header>
+    <main id="content">${sectionMarkup}</main>
+    ${chrome.footer ? `<footer data-rp-unit="shared-chrome:home">${footerContent(chrome.footer)}</footer>` : ""}
+    ${sections.some((section) => sceneIdFor(section)) ? INTERACTION_BOOTSTRAP_TAG : ""}
+  </div>
+</Layout>
+<style>
+  ${fontCss}
+  :global(*){box-sizing:border-box}:global(body){margin:0;color:var(--rp-foreground,#1d1d1f);background:var(--rp-background,#fff);font-family:var(--rp-font-body,Arial,sans-serif)}
+  .site-header{display:flex;align-items:center;justify-content:space-between;gap:24px;padding:18px clamp(20px,6vw,96px);border-bottom:1px solid var(--rp-border,#ececec)}
+  .site-header img{display:block;max-height:56px;max-width:220px}.site-header a{color:inherit;text-decoration:none}.site-header ul{display:flex;align-items:center;gap:20px;margin:0;padding:0;list-style:none}.site-header li{position:relative}.site-header li ul{display:none;position:absolute;z-index:10;min-width:14rem;padding:1rem;background:var(--rp-background,#fff)}.site-header li:focus-within>ul,.site-header li:hover>ul{display:grid}
+  .rp-section{position:relative;padding:clamp(44px,8vw,112px) clamp(20px,7vw,120px);overflow:hidden}.rp-section h2{margin:0 0 16px;font-size:clamp(1.8rem,3.5vw,3.4rem);line-height:1.12}.rp-section p{max-width:900px;margin:0;line-height:1.7;white-space:pre-line}.rp-section-media{display:grid;grid-template-columns:minmax(0,1fr) minmax(0,1fr);align-items:center;gap:clamp(28px,7vw,120px)}.rp-section-media>img{width:100%;max-height:640px;object-fit:cover}.rp-items{display:grid;grid-template-columns:repeat(auto-fit,minmax(min(100%,16rem),1fr));gap:20px;margin-top:2rem}.rp-item{padding:1rem;border:1px solid var(--rp-border,#ddd)}footer{padding:34px clamp(20px,6vw,96px)}
+  @media(max-width:760px){.site-header{align-items:flex-start}.site-header ul{flex-wrap:wrap}.rp-section-media{grid-template-columns:1fr}}
+</style>
+`;
+  await writeText(path.join(outputDir, "src", "pages", "index.astro"), astro);
+  const ledger = {
+    schemaVersion: plan.schemaVersion,
+    manifestHash: plan.manifestHash,
+    pageKey: "home",
+    units: plan.units.map((unit) => ({
+      id: unit.id,
+      specHash: unit.hash,
+      status: unit.status === "provisional" ? "provisional" : "implemented",
+      cloneRoot: ["foundation", "metadata"].includes(unit.kind) ? null : `[data-rp-unit="${unit.id}"]`,
+      gapRefs: unit.gapRefs,
+      verification: { desktop: "pending", tablet: "pending", mobile: "pending" },
+    })),
+  };
+  await writeJson(path.join(docs, "build", "section-implementation.json"), ledger);
+  return { outputDir, manifestHash: plan.manifestHash, status: plan.status, sections: sections.length, registryInstallations: registryInstallations.length, provisionalUnits: plan.units.filter((unit) => unit.status === "provisional").map((unit) => unit.id) };
+}
+
+// A section whose frozen `behavior` is a scene-contract entry is a core scene; its id is what
+// `autoBindInteractions()` and interaction verification look up through `[data-rp-scene]`.
+export function sceneIdFor(spec) {
+  const scene = spec?.behavior;
+  return scene && !Array.isArray(scene) && scene.implementation?.primitive && scene.id ? String(scene.id) : null;
+}
+
+export const INTERACTION_BOOTSTRAP_TAG = '<script type="module" src="/site-clone/rp-interactions-bootstrap.mjs"></script>';
+
+export function renderSection(spec, specs = new Map(), selectionByUnit = new Map(), registrySymbols = new Map()) {
+  const contentOptions = { allowVisibleCode: spec.extensions?.["wix.replatform.content-boundary"]?.visibleCode === true };
+  const contamination = inspectContentObject(spec.content || {}, contentOptions);
+  const content = removeContaminatedContent(spec.content || {}, contentOptions);
+  const effectiveStatus = contamination.contaminated ? "provisional" : spec.status;
+  const heading = safe(plain(content.heading || content.label));
+  const text = safe(plain(content.text));
+  const assets = Array.isArray(spec.assets) ? spec.assets : [];
+  const image = assets.map(assetPath).find(Boolean);
+  const items = Array.isArray(content.items) ? content.items : [];
+  const itemMarkup = items.length ? `<div class="rp-items">${items.map((item) => `<article class="rp-item">${item.heading ? `<h3>${safe(plain(item.heading))}</h3>` : ""}${item.text || item.paragraphs ? `<p>${safe(plain(item.text || item.paragraphs?.join(" ")))}</p>` : ""}</article>`).join("")}</div>` : "";
+  const children = (spec.children || []).map((id) => specs.get(id)).filter(Boolean).sort((a, b) => a.order - b.order);
+  const childMarkup = children.length ? `<div class="rp-components">${children.map((child) => renderComponent(child, specs, selectionByUnit, registrySymbols)).join("")}</div>` : "";
+  const body = `<div>${heading ? `<h2>${heading}</h2>` : ""}${text ? `<p>${text}</p>` : ""}${itemMarkup}${childMarkup}</div>`;
+  const warning = contamination.contaminated ? ' data-rp-content-warning="source-code-contamination"' : "";
+  const sceneId = sceneIdFor(spec);
+  const sceneMarker = sceneId ? ` data-rp-scene="${safe(sceneId)}"` : "";
+  return `<section id="${safe(spec.id)}" class="rp-section${image ? " rp-section-media" : ""}" data-rp-unit="${safe(spec.id)}" data-rp-classification="${safe(spec.classification?.kind)}" data-rp-status="${safe(effectiveStatus)}"${sceneMarker}${warning}>${image ? `<img src="${safe(image)}" alt="" loading="lazy" />` : ""}${body}</section>`;
+}
+
+function renderComponent(spec, specs, selectionByUnit, registrySymbols) {
+  const selection = selectionByUnit.get(spec.id);
+  const contentOptions = { allowVisibleCode: spec.extensions?.["wix.replatform.content-boundary"]?.visibleCode === true };
+  const contamination = inspectContentObject(spec.content || {}, contentOptions);
+  const content = removeContaminatedContent(spec.content || {}, contentOptions);
+  const effectiveStatus = contamination.contaminated ? "provisional" : spec.status;
+  const rawLabel = plain(content.label || content.heading || content.text || spec.classification?.kind);
+  const label = safe(rawLabel);
+  let ownMarkup;
+  if (selection?.strategy === "curated-registry" && selection.selected?.name === "button") {
+    const symbol = registrySymbols.get(`${selection.selected.name}@${selection.selected.revision}`);
+    if (!symbol) throw new Error(`Installed registry button has no generated import for ${spec.id}`);
+    ownMarkup = renderRegistryButton({ spec: { ...spec, content }, selection, symbol, label });
+  } else {
+    const tag = spec.classification?.kind === "button" ? "button" : "div";
+    ownMarkup = `<${tag} data-rp-custom-component="${safe(spec.classification?.kind || "static-content")}">${label}</${tag}>`;
+  }
+  const children = (spec.children || []).map((id) => specs.get(id)).filter(Boolean).sort((a, b) => a.order - b.order);
+  const warning = contamination.contaminated ? ' data-rp-content-warning="source-code-contamination"' : "";
+  return `<div data-rp-unit="${safe(spec.id)}" data-rp-status="${safe(effectiveStatus)}"${warning}>${ownMarkup}${children.map((child) => renderComponent(child, specs, selectionByUnit, registrySymbols)).join("")}</div>`;
+}
+
+export function renderRegistryButton({ spec, selection, symbol, label }) {
+  const binding = selection.selected.binding || { axes: {}, composition: "text" };
+  const variant = binding.axes?.variant || "default";
+  const size = binding.axes?.size || "default";
+  const marker = `${safe(selection.selected.name)}@${safe(selection.selected.revision)}`;
+  const props = `variant="${safe(variant)}" size="${safe(size)}" data-rp-registry-item="${marker}"`;
+  const iconSource = assetPath(spec.content?.icon) || (spec.assets || []).map(assetPath).find(Boolean);
+  const icon = iconSource ? `<img src="${safe(iconSource)}" alt="" aria-hidden="true" />` : "";
+  const accessibleName = safe(plain(spec.content?.accessibleName || spec.content?.label || spec.content?.heading || spec.content?.text));
+  if (binding.composition === "as-link") {
+    const href = (spec.content?.links || []).find((link) => link?.href)?.href;
+    if (!href) throw new Error(`Registry button binding for ${spec.id} requires href`);
+    return `<${symbol} asChild ${props}><a href="${safe(href)}">${label}</a></${symbol}>`;
+  }
+  if (binding.composition === "icon-only") {
+    if (!iconSource || !accessibleName) throw new Error(`Registry button binding for ${spec.id} requires icon and accessible name`);
+    return `<${symbol} ${props} aria-label="${accessibleName}">${icon}</${symbol}>`;
+  }
+  if (binding.composition === "leading-icon") return `<${symbol} ${props}>${icon}${label}</${symbol}>`;
+  if (binding.composition === "trailing-icon") return `<${symbol} ${props}>${label}${icon}</${symbol}>`;
+  return `<${symbol} ${props}>${label}</${symbol}>`;
+}
+
+function registryComponentImports(selections) {
+  const lines = [];
+  const symbols = new Map();
+  const seen = new Set();
+  for (const selection of selections) {
+    const selected = selection.selected;
+    if (selection.strategy !== "curated-registry" || !selected || selected.name !== "button") continue;
+    const key = `${selected.name}@${selected.revision}`;
+    if (seen.has(key)) continue;
+    const target = selected.files?.find((file) => file.type === "registry:ui")?.target;
+    if (!target?.startsWith("src/")) throw new Error(`Registry component target must be under src/: ${target}`);
+    const fromPages = `../${target.slice(4)}`.replace(/\.(?:tsx?|jsx?)$/, "");
+    const symbol = `RpRegistry${selected.name.replace(/[^a-z0-9]+/gi, " ").split(/\s+/).filter(Boolean).map((part) => `${part[0].toUpperCase()}${part.slice(1)}`).join("")}`;
+    lines.push(`import { Button as ${symbol} } from ${JSON.stringify(fromPages)};`);
+    symbols.set(key, symbol);
+    seen.add(key);
+  }
+  return { lines, symbols };
+}
+
+function renderNavItem(item) {
+  const label = safe(plain(item.label || item.text));
+  const href = safe(item.href || "#");
+  const children = Array.isArray(item.children) ? item.children : [];
+  return `<li><a href="${href}"${children.length ? ' aria-haspopup="true"' : ""}>${label}</a>${children.length ? `<ul>${children.map(renderNavItem).join("")}</ul>` : ""}</li>`;
+}
+
+function assetPath(value) {
+  if (!value) return "";
+  if (typeof value === "string") return normalizeAssetPath(value);
+  return normalizeAssetPath(value.localPath || value.sourceUrl || value.url || value.src || "");
+}
+
+function normalizeAssetPath(value) {
+  if (!value) return "";
+  if (/^https?:\/\//i.test(value) || value.startsWith("/")) return value;
+  return `/${String(value).replace(/^public\//, "")}`;
+}
+
+function footerContent(footer) {
+  const groups = footer?.groups || footer?.linkGroups || [];
+  const links = groups.flatMap((group) => group.links || []).map((link) => `<a href="${safe(link.href || "#")}">${safe(plain(link.label || link.text))}</a>`).join(" ");
+  const legal = safe(plain(footer?.legalText || footer?.text || ""));
+  return `${links}${legal ? `<p>${legal}</p>` : ""}`;
+}
+
+function renderFontFaces(faces) {
+  return faces.filter((face) => face.family && face.sources?.length).map((face) => {
+    const sources = face.sources.filter((source) => source.localPath || source.url).map((source) => `url(${JSON.stringify(normalizeAssetPath(source.localPath || source.url))})${source.format ? ` format(${JSON.stringify(source.format)})` : ""}`).join(",");
+    return sources ? `@font-face{font-family:${JSON.stringify(face.family)};src:${sources};font-style:${face.style || "normal"};font-weight:${face.weight || "normal"};${face.unicodeRange ? `unicode-range:${face.unicodeRange};` : ""}}` : "";
+  }).join("\n");
+}
+
+async function main() {
+  const args = parseArgs();
+  if (!args.out) throw new Error("--out is required");
+  console.log(JSON.stringify(await buildExtractedHomepage({ outputDir: path.resolve(String(args.out)) }), null, 2));
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) main().catch((error) => { console.error(error.stack || error.message); process.exit(1); });

package/skills/wix-headless-replatform/scripts/clear-wix-starter.mjs

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+import { rm } from "node:fs/promises";
+import path from "node:path";
+import { ensureDir, parseArgs, resolveOutputDir, writeText } from "./lib/common.mjs";
+
+async function main() {
+  const args = parseArgs();
+  const outputDir = args.out ? path.normalize(args.out) : resolveOutputDir(args._[0] || args.url, args.out);
+  const result = await clearWixStarter({ outputDir });
+  if (args.json) process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+  else {
+    console.log(`Cleared Wix starter files in ${outputDir}`);
+    for (const item of result.removed) console.log(`- removed ${item}`);
+    for (const item of result.written) console.log(`- wrote ${item}`);
+  }
+}
+
+export async function clearWixStarter({ outputDir }) {
+  const removed = [];
+  const written = [];
+  const relativeRemovals = [
+    "src/components/AppIsland.jsx",
+    "src/pages/about.astro",
+  ];
+
+  for (const relative of relativeRemovals) {
+    await rm(path.join(outputDir, relative), { force: true });
+    removed.push(relative);
+  }
+
+  await ensureDir(path.join(outputDir, "src", "components"));
+  await ensureDir(path.join(outputDir, "src", "layouts"));
+  await ensureDir(path.join(outputDir, "src", "pages"));
+
+  await writeText(path.join(outputDir, "src", "layouts", "Layout.astro"), `---
+const { title = "Site Clone", description = "Generated site clone." } = Astro.props;
+---
+
+<!doctype html>
+<html lang="en">
+\t<head>
+\t\t<meta charset="UTF-8" />
+\t\t<meta name="viewport" content="width=device-width, initial-scale=1" />
+\t\t<meta name="description" content={description} />
+\t\t<meta name="generator" content={Astro.generator} />
+\t\t<title>{title}</title>
+\t</head>
+\t<body>
+\t\t<slot />
+\t</body>
+</html>
+
+<style is:global>
+\t* {
+\t\tbox-sizing: border-box;
+\t}
+
+\tbody {
+\t\tmargin: 0;
+\t\tmin-width: 320px;
+\t\tfont-family: system-ui, sans-serif;
+\t}
+</style>
+`);
+  written.push("src/layouts/Layout.astro");
+
+  await writeText(path.join(outputDir, "src", "pages", "index.astro"), `---
+import Layout from "../layouts/Layout.astro";
+---
+
+<Layout>
+\t<main>
+\t\t<h1>Site clone starter cleared</h1>
+\t</main>
+</Layout>
+`);
+  written.push("src/pages/index.astro");
+
+  return { outputDir, removed, written };
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch((error) => {
+    console.error(error.stack || error.message);
+    process.exit(1);
+  });
+}