@avocadostudio-ai/orchestrator-core 0.1.0

package/dist/chat/chat-pipeline-translation.js

@@ -0,0 +1,417 @@
+import { getAllBlockMeta } from "@avocadostudio-ai/shared";
+export function sanitizeMessageForPlanning(message) {
+    const normalized = normalizeVariationTypos(message.replace(/\r\n?/g, "\n")).trim();
+    if (normalized.length === 0)
+        return normalized;
+    const hasDebugEcho = /(^|\n)\s*debug\s*$|(^|\n)\s*(traceid|prompthash|outcome|intent|opcount|ops)\s*:/im.test(normalized);
+    const canonicalized = normalized
+        // Normalize common smart quote variants so downstream quoted-text parsing is stable.
+        .replace(/[\u2018\u2019\u2032]/g, "'")
+        .replace(/[\u201C\u201D\u2033]/g, "\"")
+        // Light typo normalization for frequently used edit verbs/nouns.
+        .replace(/\btestomonials\b/gi, "testimonials")
+        .replace(/\bfetures\b/gi, "features")
+        .replace(/\bheding\b/gi, "heading")
+        .replace(/\bad a\b/gi, "add a")
+        .replace(/\bupdte\b/gi, "update")
+        .replace(/\btras?n[asl]{1,3}[aet]{1,3}e?\b/gi, (m) => /translat/i.test(m) ? m : "translate");
+    if (!hasDebugEcho)
+        return canonicalized;
+    const promptEcho = canonicalized.match(/(^|\n)\s*prompt\s*:\s*(.+)$/im)?.[2]?.trim();
+    if (promptEcho && promptEcho.length > 0)
+        return promptEcho;
+    const cleanedLines = canonicalized
+        .split("\n")
+        .map((line) => line.trimEnd())
+        .filter((line) => {
+        if (line.trim().length === 0)
+            return true;
+        if (/^\s*debug\s*$/i.test(line))
+            return false;
+        if (/^\s*(traceid|prompthash|outcome|intent|opcount|optypes|ops|reason|reasoncategory)\s*:/i.test(line))
+            return false;
+        if (/^\s*renamed the hero secondary cta\.?\s*$/i.test(line))
+            return false;
+        if (/^\s*performance awareness\b/i.test(line))
+            return false;
+        if (/semantic relevance and supports seo,\s*accessibility,\s*and conversion checks\.?\s*$/i.test(line))
+            return false;
+        return true;
+    });
+    return cleanedLines.join("\n").trim();
+}
+export function inferTranslationScopeFromMessage(message) {
+    const lower = message.toLowerCase();
+    const isTranslation = /\btranslate\b/.test(lower) ||
+        /\btranslation\b/.test(lower) ||
+        /\blocaliz/.test(lower) ||
+        /\bgerman\b/.test(lower) ||
+        /\bdeutsch\b/.test(lower);
+    if (!isTranslation)
+        return "none";
+    const pageScope = /\b(this|the|entire|whole|full)\s+page\b/.test(lower) ||
+        /\bwhole\s+site\b/.test(lower) ||
+        /\ball\s+sections?\b/.test(lower) ||
+        /\btranslate\s+page\b/.test(lower);
+    if (pageScope)
+        return "page";
+    const componentScope = /\b(this|selected|current)\s+(block|section|component)\b/.test(lower) ||
+        /\btranslate\s+(the\s+)?(block|section|component)\b/.test(lower) ||
+        /\bselected\s+component\b/.test(lower);
+    if (componentScope)
+        return "component";
+    // Default translation intent to page scope unless the user explicitly narrows it.
+    return "page";
+}
+// ---------------------------------------------------------------------------
+// Clone-and-translate compound detection
+// ---------------------------------------------------------------------------
+//
+// "clone the home page into /test, same content but translated to Spanish" is a
+// two-phase request the single-pass planner can't satisfy: it can emit
+// `duplicate_page`, but the copy's blocks don't exist yet at plan time, so it
+// can't target them for translation — it silently drops the translation half
+// and narrates a translation that never happens. The pipeline handles this by
+// detecting the intent here, duplicating the page, then translating the fresh
+// copy through the normal full-page translation path.
+// Language synonym → canonical English name used in the follow-up
+// "translate this page to <Lang>" message. Keys are matched lowercase.
+const TRANSLATION_LANGUAGE_NAMES = {
+    spanish: "Spanish", español: "Spanish", espanol: "Spanish", castellano: "Spanish",
+    german: "German", deutsch: "German",
+    french: "French", français: "French", francais: "French",
+    italian: "Italian", italiano: "Italian",
+    portuguese: "Portuguese", português: "Portuguese", portugues: "Portuguese", brazilian: "Portuguese",
+    dutch: "Dutch", nederlands: "Dutch",
+    english: "English", inglés: "English", ingles: "English",
+    japanese: "Japanese", chinese: "Chinese", mandarin: "Chinese", cantonese: "Chinese",
+    korean: "Korean", russian: "Russian", arabic: "Arabic", hindi: "Hindi",
+    polish: "Polish", swedish: "Swedish", norwegian: "Norwegian", danish: "Danish",
+    finnish: "Finnish", greek: "Greek", turkish: "Turkish", czech: "Czech",
+    ukrainian: "Ukrainian", romanian: "Romanian", hungarian: "Hungarian",
+    catalan: "Catalan", hebrew: "Hebrew", thai: "Thai", vietnamese: "Vietnamese",
+    indonesian: "Indonesian", malay: "Malay", tagalog: "Tagalog", filipino: "Tagalog",
+};
+// clone/duplicate/copy/replicate verb (whole-page scope is enforced separately).
+const CLONE_PAGE_VERB = /\b(?:clone|duplicate|replicate|copy)\b|\bmake\s+(?:a\s+)?(?:copy|duplicate|clone)\b/i;
+// Canonical English name → ISO 639-1 code, used to tag the cloned page's title
+// (e.g. "Home (ES)") so a localized copy is distinguishable from its source.
+const LANGUAGE_ISO_CODES = {
+    Spanish: "ES", German: "DE", French: "FR", Italian: "IT", Portuguese: "PT",
+    Dutch: "NL", English: "EN", Japanese: "JA", Chinese: "ZH", Korean: "KO",
+    Russian: "RU", Arabic: "AR", Hindi: "HI", Polish: "PL", Swedish: "SV",
+    Norwegian: "NO", Danish: "DA", Finnish: "FI", Greek: "EL", Turkish: "TR",
+    Czech: "CS", Ukrainian: "UK", Romanian: "RO", Hungarian: "HU", Catalan: "CA",
+    Hebrew: "HE", Thai: "TH", Vietnamese: "VI", Indonesian: "ID", Malay: "MS", Tagalog: "TL",
+};
+export function parseCloneAndTranslateRequest(message) {
+    const text = message.replace(/\s+/g, " ").trim();
+    const lower = text.toLowerCase();
+    if (!CLONE_PAGE_VERB.test(lower))
+        return null;
+    // Must be a whole-page clone, not a block/section copy ("duplicate this card",
+    // "copy the hero"). Require a page noun or a route, and bail if it clearly
+    // targets a block instead of a page.
+    const mentionsPage = /\b(?:page|homepage|home\s*page|landing|site)\b/.test(lower) || /\/[a-z0-9]/i.test(text);
+    if (!mentionsPage)
+        return null;
+    if (/\b(?:this|the|that)\s+(?:block|section|card|hero|cta|grid|component|banner|testimonial)\b/.test(lower) && !/\bpage\b/.test(lower)) {
+        return null;
+    }
+    const langAlternation = Object.keys(TRANSLATION_LANGUAGE_NAMES).join("|");
+    // Prefer a language introduced by an explicit translate/localize verb so the
+    // looser prepositional fallback can't misfire.
+    const explicitTranslate = new RegExp(`\\b(?:translat\\w*|localiz\\w*|render(?:ed)?|convert(?:ed)?)\\b[^.]*?\\b(?:in|into|to)\\s+(${langAlternation})\\b`, "i").exec(lower);
+    const prepositional = new RegExp(`\\b(?:in|into|to)\\s+(${langAlternation})\\b`, "i").exec(lower);
+    const langKey = (explicitTranslate?.[1] ?? prepositional?.[1])?.toLowerCase();
+    if (!langKey)
+        return null;
+    // For the loose prepositional match only ("… in Spanish", no translate verb),
+    // guard against the language naming something OTHER than a translation target:
+    //  - a SOURCE descriptor: "clone the Spanish page"
+    //  - a STYLING request: "copy the page in a Spanish style", "in French restaurant
+    //    theme" — the user wants the page restyled, not machine-translated.
+    // Match the language followed (within ≤2 words, no clause break) by a source or
+    // styling noun. A false negative here just defers to the LLM (safe); a false
+    // positive silently translates a page the user wanted restyled (not safe).
+    const sourceOrStyleNoun = "page|version|site|homepage|style|theme|design|aesthetics?|branding|brand|look|feel|vibe|mood|fonts?|colou?rs?|palette|layout|tone";
+    if (!explicitTranslate && new RegExp(`\\b${langKey}\\b(?:\\s+\\w+){0,2}\\s+(?:${sourceOrStyleNoun})\\b`, "i").test(lower)) {
+        return null;
+    }
+    const languageName = TRANSLATION_LANGUAGE_NAMES[langKey];
+    if (!languageName)
+        return null;
+    // Optional explicit target slug: an explicit route after into/to/as/at/called.
+    let newSlug;
+    const routeMatch = text.match(/\b(?:into|to|as|at|named|called)\s+(?:an?\s+|the\s+)?(?:brand[\s-]?new\s+|new\s+)?(?:page\s+(?:called\s+|named\s+|at\s+)?)?["'`]?(\/[a-z0-9][a-z0-9-]*)/i);
+    if (routeMatch) {
+        newSlug = routeMatch[1].toLowerCase();
+    }
+    else {
+        // Capture the page name after "called/named", stopping before any trailing
+        // clause ("… translated to Spanish", "… and …") so we don't slurp it in.
+        const namedMatch = text.match(/\b(?:called|named)\s+["'`]?([a-z0-9][a-z0-9 -]*?)["'`]?\s*(?:,|\bpage\b|\btranslat\w*|\blocaliz\w*|\band\b|\bbut\b|\bwith\b|\bin\b|\bto\b|$)/i);
+        const name = namedMatch?.[1]?.trim();
+        if (name) {
+            const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+            if (slug)
+                newSlug = `/${slug}`;
+        }
+    }
+    return { newSlug, languageName, languageCode: LANGUAGE_ISO_CODES[languageName] ?? languageName.slice(0, 2).toUpperCase() };
+}
+export function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function normalizeUpdatePropsPatch(op) {
+    const rawPatch = op.patch;
+    if (rawPatch &&
+        typeof rawPatch.props === "object" &&
+        rawPatch.props !== null &&
+        !Array.isArray(rawPatch.props)) {
+        return rawPatch.props;
+    }
+    return rawPatch;
+}
+function isExplicitMultiTargetCtaRequest(message) {
+    const lower = message.toLowerCase();
+    const mentionsCta = /\bcta\b/.test(lower);
+    const mentionsHeroTarget = /\bhero\b/.test(lower);
+    const mentionsFooterTarget = /\bfooter\b/.test(lower) || /\bcta section\b/.test(lower);
+    const asksMultipleTargets = /\b(both|all|each)\b/.test(lower) || (mentionsHeroTarget && mentionsFooterTarget);
+    return mentionsCta && asksMultipleTargets && mentionsHeroTarget && mentionsFooterTarget;
+}
+function shouldKeepLinksUnchanged(message) {
+    const lower = message.toLowerCase();
+    return (/\bkeep\b[^.\n]{0,80}\b(?:links?|hrefs?|urls?)\b[^.\n]{0,80}\bunchanged\b/.test(lower) ||
+        /\b(?:without|don't|do not)\b[^.\n]{0,80}\bchange\b[^.\n]{0,80}\b(?:links?|hrefs?|urls?)\b/.test(lower));
+}
+export function findExplicitCtaTargetCoverageGap(args) {
+    if (!isExplicitMultiTargetCtaRequest(args.message))
+        return null;
+    if (args.plan.intent !== "edit_plan")
+        return null;
+    const hero = args.currentPage.blocks.find((block) => block.type === "Hero");
+    const footerCta = args.currentPage.blocks.find((block) => block.type === "CTA");
+    if (!hero || !footerCta)
+        return null;
+    const heroOps = args.plan.ops.filter((op) => op.op === "update_props" && op.pageSlug === args.slug && op.blockId === hero.id);
+    const footerOps = args.plan.ops.filter((op) => op.op === "update_props" && op.pageSlug === args.slug && op.blockId === footerCta.id);
+    const heroCurrentCta = String(hero.props.ctaText ?? "");
+    const footerCurrentCta = String(footerCta.props.ctaText ?? "");
+    const heroCovered = heroOps.some((op) => {
+        const patch = normalizeUpdatePropsPatch(op);
+        const next = patch.ctaText;
+        return typeof next === "string" && next.trim().length > 0 && next.trim() !== heroCurrentCta.trim();
+    });
+    const footerCovered = footerOps.some((op) => {
+        const patch = normalizeUpdatePropsPatch(op);
+        const next = patch.ctaText;
+        return typeof next === "string" && next.trim().length > 0 && next.trim() !== footerCurrentCta.trim();
+    });
+    const missingTargets = [];
+    if (!heroCovered)
+        missingTargets.push("hero CTA text");
+    if (!footerCovered)
+        missingTargets.push("footer CTA text");
+    if (missingTargets.length > 0) {
+        return `Invalid explicit CTA target coverage. Missing updates for: ${missingTargets.join(", ")}.`;
+    }
+    if (!shouldKeepLinksUnchanged(args.message))
+        return null;
+    const linkChanged = [...heroOps, ...footerOps].some((op) => {
+        const patch = normalizeUpdatePropsPatch(op);
+        return Object.prototype.hasOwnProperty.call(patch, "ctaHref");
+    });
+    if (linkChanged) {
+        return "Invalid explicit CTA target coverage. Request says to keep links unchanged, but plan modifies CTA links.";
+    }
+    return null;
+}
+export function findFullPageTranslationCoverageGap(args) {
+    if (inferTranslationScopeFromMessage(args.message) !== "page")
+        return null;
+    if (args.plan.intent !== "edit_plan")
+        return null;
+    const blockMeta = getAllBlockMeta();
+    const touchedBlockIds = new Set(args.plan.ops
+        .filter((op) => {
+        if (!(op.op === "update_props" || op.op === "update_item" || op.op === "add_item" || op.op === "remove_item" || op.op === "move_item"))
+            return false;
+        return "pageSlug" in op && op.pageSlug === args.slug;
+    })
+        .map((op) => ("blockId" in op ? op.blockId : ""))
+        .filter((id) => typeof id === "string" && id.length > 0));
+    if (touchedBlockIds.size === 0)
+        return null;
+    const missingPaths = [];
+    for (const block of args.currentPage.blocks) {
+        if (!touchedBlockIds.has(block.id))
+            continue;
+        const meta = blockMeta[block.type];
+        // --- Top-level scalar prop coverage ---
+        if (meta?.fields) {
+            const translatableTopLevel = Object.entries(meta.fields)
+                .filter(([, fm]) => fm.kind === "text" || fm.kind === "richtext" || fm.kind === "imageAlt")
+                .map(([key]) => key);
+            if (translatableTopLevel.length > 0) {
+                const coveredTopLevel = new Set();
+                for (const op of args.plan.ops) {
+                    if (!("pageSlug" in op) || op.pageSlug !== args.slug)
+                        continue;
+                    if (op.op === "update_props" && op.blockId === block.id) {
+                        const patch = normalizeUpdatePropsPatch(op);
+                        for (const key of translatableTopLevel) {
+                            if (isNonEmptyString(patch[key]))
+                                coveredTopLevel.add(key);
+                        }
+                    }
+                }
+                const blockProps = block.props;
+                for (const key of translatableTopLevel) {
+                    if (!isNonEmptyString(blockProps[key]))
+                        continue;
+                    if (!coveredTopLevel.has(key))
+                        missingPaths.push(`${block.id}.${key}`);
+                }
+            }
+        }
+        // --- List field child coverage ---
+        const listFields = meta?.listFields ?? {};
+        const listEntries = Object.entries(listFields);
+        for (const [listKey, listMeta] of listEntries) {
+            const translatableItemFields = Object.entries(listMeta.itemFields ?? {})
+                .filter(([, fieldMeta]) => fieldMeta.kind === "text" || fieldMeta.kind === "richtext" || fieldMeta.kind === "imageAlt")
+                .map(([key]) => key);
+            if (translatableItemFields.length === 0)
+                continue;
+            const listValue = block.props[listKey];
+            if (!Array.isArray(listValue) || listValue.length === 0)
+                continue;
+            const perItemCoverage = new Map();
+            const ensureCoverage = (index) => {
+                const existing = perItemCoverage.get(index);
+                if (existing)
+                    return existing;
+                const next = new Set();
+                perItemCoverage.set(index, next);
+                return next;
+            };
+            for (const op of args.plan.ops) {
+                if (!("pageSlug" in op) || op.pageSlug !== args.slug)
+                    continue;
+                if (op.op === "update_item" && op.blockId === block.id && op.listKey === listKey) {
+                    const patch = op.patch;
+                    // The op may address its target by stable itemId or positional index.
+                    const targetIdx = typeof op.index === "number"
+                        ? op.index
+                        : listValue.findIndex((e) => e != null && typeof e === "object" && !Array.isArray(e) && e.id === op.itemId);
+                    if (targetIdx < 0)
+                        continue;
+                    const cov = ensureCoverage(targetIdx);
+                    for (const key of translatableItemFields) {
+                        if (isNonEmptyString(patch[key]))
+                            cov.add(key);
+                    }
+                    continue;
+                }
+                if (op.op === "update_props" && op.blockId === block.id) {
+                    const patch = op.patch;
+                    if (!Array.isArray(patch[listKey]))
+                        continue;
+                    const rows = patch[listKey];
+                    for (let idx = 0; idx < rows.length; idx += 1) {
+                        const rowPatch = rows[idx];
+                        if (!rowPatch || typeof rowPatch !== "object" || Array.isArray(rowPatch))
+                            continue;
+                        const row = rowPatch;
+                        const cov = ensureCoverage(idx);
+                        for (const key of translatableItemFields) {
+                            if (isNonEmptyString(row[key]))
+                                cov.add(key);
+                        }
+                    }
+                }
+            }
+            for (let idx = 0; idx < listValue.length; idx += 1) {
+                const item = listValue[idx];
+                if (!item || typeof item !== "object" || Array.isArray(item))
+                    continue;
+                const row = item;
+                const required = translatableItemFields.filter((key) => isNonEmptyString(row[key]));
+                if (required.length === 0)
+                    continue;
+                const covered = perItemCoverage.get(idx) ?? new Set();
+                const missing = required.filter((key) => !covered.has(key));
+                for (const field of missing)
+                    missingPaths.push(`${block.id}.${listKey}[${idx}].${field}`);
+            }
+        }
+    }
+    if (missingPaths.length === 0)
+        return null;
+    // Auto-patch: fill missing fields with original (untranslated) values rather than failing.
+    // This ensures partial LLM translations still apply — untranslated text is better than no translation.
+    let patched = 0;
+    for (const path of missingPaths) {
+        // Parse path: "b_hero_1.heading" or "b_cardgrid_7.cards[0].imageAlt"
+        const topMatch = path.match(/^([^.]+)\.([^[]+)$/);
+        const listMatch = path.match(/^([^.]+)\.([^[]+)\[(\d+)\]\.(.+)$/);
+        if (topMatch) {
+            const [, blockId, key] = topMatch;
+            const block = args.currentPage.blocks.find(b => b.id === blockId);
+            if (!block)
+                continue;
+            const originalValue = block.props[key];
+            if (!isNonEmptyString(originalValue))
+                continue;
+            // Find the existing update_props op for this block and add the missing key
+            const existingOp = args.plan.ops.find(op => op.op === "update_props" && "blockId" in op && op.blockId === blockId && "pageSlug" in op && op.pageSlug === args.slug);
+            if (existingOp && "patch" in existingOp) {
+                const patch = existingOp.patch;
+                if (!isNonEmptyString(patch[key])) {
+                    patch[key] = originalValue;
+                    patched++;
+                }
+            }
+        }
+        else if (listMatch) {
+            const [, blockId, listKey, indexStr, field] = listMatch;
+            const idx = Number(indexStr);
+            const block = args.currentPage.blocks.find(b => b.id === blockId);
+            if (!block)
+                continue;
+            const listValue = block.props[listKey];
+            if (!Array.isArray(listValue) || !listValue[idx])
+                continue;
+            const originalItem = listValue[idx];
+            const originalValue = originalItem[field];
+            if (!isNonEmptyString(originalValue))
+                continue;
+            // Find the existing update_props op and patch the list item
+            const existingOp = args.plan.ops.find(op => op.op === "update_props" && "blockId" in op && op.blockId === blockId && "pageSlug" in op && op.pageSlug === args.slug);
+            if (existingOp && "patch" in existingOp) {
+                const patch = existingOp.patch;
+                if (Array.isArray(patch[listKey]) && patch[listKey][idx] && typeof patch[listKey][idx] === "object") {
+                    const itemPatch = patch[listKey][idx];
+                    if (!isNonEmptyString(itemPatch[field])) {
+                        itemPatch[field] = originalValue;
+                        patched++;
+                    }
+                }
+            }
+        }
+    }
+    if (patched > 0) {
+        console.log(`[translation-coverage] Auto-patched ${patched} missing fields with original values`);
+        return null; // Patched — no gap anymore
+    }
+    return `Invalid full-page translation coverage. Missing translated fields: ${missingPaths.join(", ")}`;
+}
+export function normalizeVariationTypos(text) {
+    return text
+        .replace(/\bvariaqtions?\b/gi, "variations")
+        .replace(/\bvariatons?\b/gi, "variations")
+        .replace(/\bvaritions?\b/gi, "variations")
+        .replace(/\bvariants?\b/gi, (m) => m.endsWith("s") ? "variations" : "variation");
+}

package/dist/chat/chat-pipeline-ui.d.ts

@@ -0,0 +1,14 @@
+import type { EditPlan, Operation, PageDoc } from "@avocadostudio-ai/shared";
+export declare function sentenceCase(text: string): string;
+export declare function futureToPastTense(text: string): string;
+export declare function pastToFutureTense(text: string): string;
+export declare function firstUrlFromText(text: string): string | undefined;
+export declare function looksLikeUserInstruction(value: string): boolean;
+export declare function preferredImageAltText(args: {
+    query: string;
+    resolvedAlt?: string;
+    existingAlt?: string;
+}): string;
+export declare function collectMentionedSlugsFromPlan(plan: EditPlan, fallbackSlug?: string): string[];
+export declare function collectMentionedSlugsFromOps(ops: Operation[], fallbackSlug?: string): string[];
+export declare function normalizePlanCopyForUi(plan: EditPlan, currentPage: PageDoc): EditPlan;