@avocadostudio-ai/orchestrator-core 0.1.0

package/dist/nlp/deterministic-planner-patches.js

@@ -0,0 +1,508 @@
+import { patchObject } from "./plan-normalizer.js";
+export function extractAudienceTarget(message) {
+    return extractAudienceTargets(message)[0];
+}
+function cleanAudienceCandidate(raw) {
+    const cleaned = raw
+        .replace(/\b(?:an?|the|only|just)\b/g, " ")
+        .replace(/\b(?:audience|audiences|segment|segments)\b/g, " ")
+        .replace(/[.?!:;"'`()[\]{}]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, 80);
+    if (cleaned.length <= 1)
+        return undefined;
+    const rejectWords = new Set([
+        "a while",
+        "now",
+        "later",
+        "free",
+        "this",
+        "these",
+        "that",
+        "those",
+        "me",
+        "you",
+        "testing",
+        "demo",
+        "it",
+        "here",
+        "there",
+        "sure",
+        "fun",
+        "good",
+        "better",
+        "best",
+        "while"
+    ]);
+    if (rejectWords.has(cleaned.toLowerCase()))
+        return undefined;
+    const stopwords = new Set(["a", "an", "the", "is", "it", "to", "of", "in", "on", "for", "and", "or", "so", "if"]);
+    const words = cleaned.toLowerCase().split(/\s+/);
+    if (words.every((w) => stopwords.has(w)))
+        return undefined;
+    return cleaned;
+}
+function splitAudienceList(raw) {
+    return raw
+        .split(/\s*(?:,|&|\band\b|\bor\b|\/)\s*/i)
+        .map((part) => cleanAudienceCandidate(part))
+        .filter((part) => Boolean(part));
+}
+export function extractAudienceTargets(message) {
+    const lower = message.toLowerCase();
+    const patternMatches = [
+        lower.match(/\bfor\s+([a-z0-9 ,&/-]{2,80}?)\s+(?:audience|users?|customers?|buyers?|founders?|teams?|developers?|marketers?|parents?|students?)\b/),
+        lower.match(/\bfor\s+([a-z0-9 ,&/-]{2,160})$/),
+        lower.match(/\btarget(?:ing)?\s+([a-z0-9 ,&/-]{2,80})\b/),
+        lower.match(/\bpages?\s+for\s+([a-z0-9 ,&/-]{2,160})(?:$|[.!?])/),
+        lower.match(/\bfor\s+([a-z0-9 ,&/-]{2,160})\s+pages?\b/),
+        lower.match(/\b(?:create|generate|build|make|draft)\s+(?:only\s+)?([a-z0-9 ,&/-]{2,160})\s+pages?\b/)
+    ];
+    const raw = patternMatches.find(Boolean)?.[1];
+    if (!raw)
+        return [];
+    const candidates = splitAudienceList(raw);
+    return [...new Set(candidates)];
+}
+export function titleCaseWords(text) {
+    return text
+        .split(/\s+/)
+        .filter(Boolean)
+        .map((word) => (word.length > 2 ? word[0].toUpperCase() + word.slice(1) : word))
+        .join(" ");
+}
+export function addAudienceSuffix(value, audience) {
+    const normalized = value.trim();
+    if (!normalized)
+        return normalized;
+    const audienceRe = new RegExp(`\\b${audience.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "i");
+    if (audienceRe.test(normalized))
+        return normalized;
+    return `${normalized} for ${audience}`;
+}
+export function audiencePatchForBlock(block, audience) {
+    const props = block.props;
+    if (block.type === "Hero") {
+        const heading = typeof props.heading === "string" ? props.heading : "";
+        const subheading = typeof props.subheading === "string" ? props.subheading : "";
+        const nextHeading = addAudienceSuffix(heading, audience);
+        const nextSubheading = addAudienceSuffix(subheading, audience);
+        const patch = {};
+        if (nextHeading && nextHeading !== heading)
+            patch.heading = nextHeading;
+        if (nextSubheading && nextSubheading !== subheading)
+            patch.subheading = nextSubheading;
+        return patch;
+    }
+    if (block.type === "RichText") {
+        const body = typeof props.body === "string" ? props.body : "";
+        const nextBody = body.toLowerCase().includes(audience.toLowerCase()) ? body : `For ${audience}: ${body}`;
+        return nextBody !== body ? { body: nextBody } : {};
+    }
+    if (block.type === "CTA") {
+        const title = typeof props.title === "string" ? props.title : "";
+        const nextTitle = addAudienceSuffix(title, audience);
+        return nextTitle !== title ? { title: nextTitle } : {};
+    }
+    if (block.type === "FeatureGrid" || block.type === "Testimonials" || block.type === "FAQAccordion" || block.type === "CardGrid" || block.type === "Card") {
+        const title = typeof props.title === "string" ? props.title : "";
+        const nextTitle = addAudienceSuffix(title, audience);
+        return nextTitle !== title ? { title: nextTitle } : {};
+    }
+    return {};
+}
+export function coercePatchForBlock(block, rawPatch) {
+    if (!rawPatch || typeof rawPatch !== "object" || Array.isArray(rawPatch))
+        return {};
+    const source = "props" in rawPatch &&
+        rawPatch.props &&
+        typeof rawPatch.props === "object" &&
+        !Array.isArray(rawPatch.props)
+        ? rawPatch.props
+        : rawPatch;
+    const allowed = Object.keys(block.props);
+    const normalizedToAllowed = new Map();
+    for (const key of allowed)
+        normalizedToAllowed.set(key.toLowerCase(), key);
+    const out = {};
+    for (const [key, value] of Object.entries(source)) {
+        if (allowed.includes(key)) {
+            out[key] = value;
+            continue;
+        }
+        const mapped = normalizedToAllowed.get(key.toLowerCase());
+        if (mapped)
+            out[mapped] = value;
+    }
+    if (block.type === "RichText" && typeof out.body === "string") {
+        out.body = out.body
+            .replace(/\r\n?/g, "\n")
+            .replace(/([.!?])([A-Z])/g, "$1 $2")
+            .replace(/\n{3,}/g, "\n\n")
+            .trim();
+    }
+    return out;
+}
+export function parseIndexedPath(path) {
+    const match = /^([a-zA-Z0-9_]+)\[(\d+)\](?:\.(.+))?$/.exec(path.trim());
+    if (!match)
+        return null;
+    return {
+        listKey: match[1],
+        index: Number(match[2]),
+        leaf: match[3]
+    };
+}
+export function inferSimpleFieldPatchFromMessage(message) {
+    const normalized = message
+        .replace(/\u201c|\u201d/g, '"')
+        .replace(/\u2018|\u2019/g, "'");
+    const m = normalized
+        .match(/\b(?:change|set|update|edit|replace)\b[\s\w]*?\b(heading|subheading|title|description|image(?:\s*url)?|photo|picture|cta\s*text|button\s*text|cta|link|href|quote|author|question|answer|q|a)\b[\s\w]*?\b(?:to|as|with)\b\s+['"]?([^'"\n]+)['"]?/i);
+    if (!m)
+        return null;
+    const rawField = m[1].toLowerCase().replace(/\s+/g, "");
+    const value = m[2]?.trim();
+    if (!value)
+        return null;
+    const map = {
+        heading: "heading",
+        subheading: "subheading",
+        title: "title",
+        description: "description",
+        image: "imageUrl",
+        imageurl: "imageUrl",
+        photo: "imageUrl",
+        picture: "imageUrl",
+        ctatext: "ctaText",
+        buttontext: "ctaText",
+        cta: "ctaText",
+        link: "ctaHref",
+        href: "ctaHref",
+        quote: "quote",
+        author: "author",
+        question: "q",
+        answer: "a",
+        q: "q",
+        a: "a"
+    };
+    const key = map[rawField];
+    if (!key)
+        return null;
+    return { [key]: value };
+}
+export function isRewriteRequest(message) {
+    const lower = message.toLowerCase();
+    return (/\brewrit\w*\b/.test(lower) ||
+        /\breword\w*\b/.test(lower) ||
+        /\brephras\w*\b/.test(lower) ||
+        /\bpolish\w*\b/.test(lower) ||
+        /\brefin\w*\b/.test(lower) ||
+        /\brefresh\w*\b/.test(lower) ||
+        /\btighten\w*\b/.test(lower) ||
+        /\bclarif\w*\b/.test(lower) ||
+        /\bclean\s*up\b/.test(lower) ||
+        /\bfreshen\s*up\b/.test(lower) ||
+        /\bredo\b.*\b(copy|text|wording|messaging)\b/.test(lower) ||
+        /\bimprove\b/.test(lower) ||
+        /\bsimplif\w*\b/.test(lower) ||
+        /\bmake\b.*\b(shorter|clearer|crisper|concise)\b/.test(lower) ||
+        /\bshorten\w*\b/.test(lower));
+}
+const TRANSLATION_KEYWORD_RE = /\btranslat\w*\b|\blocali[zs]\w*\b/;
+const LANGUAGE_NAME_RE = /\bin\s+(?:spanish|french|german|italian|portuguese|chinese|japanese|korean|arabic|russian|hindi|dutch|swedish|norwegian|danish|finnish|polish|turkish|greek|hebrew|thai|vietnamese|indonesian|malay|czech|hungarian|romanian|ukrainian|bulgarian|croatian|serbian|slovak|slovenian|latvian|lithuanian|estonian|bengali|tamil|telugu|urdu|persian|swahili|catalan|basque|galician|tagalog)\b/;
+export function isTranslationRequest(message) {
+    const lower = message.toLowerCase();
+    return TRANSLATION_KEYWORD_RE.test(lower) || LANGUAGE_NAME_RE.test(lower);
+}
+export function shouldKeepRichTextTitleOnTranslate(args) {
+    const { target, activeEditablePath, message, fullPatch } = args;
+    if (target.type !== "RichText")
+        return false;
+    if (activeEditablePath !== "body")
+        return false;
+    if (!isTranslationRequest(message))
+        return false;
+    return Object.prototype.hasOwnProperty.call(fullPatch, "title");
+}
+// Keys shorter than this are not matched by name: a prop literally called "a"
+// or "q" (FAQAccordion items) would otherwise match the article "a" in almost
+// any sentence. Those keys are reachable through the synonym table below.
+const MIN_NAMED_KEY_LENGTH = 3;
+// "ctaText" -> /\bcta[\s_-]*text\b/ , "heading" -> /\bheading\b/. The word
+// boundary is what keeps "heading" from matching inside "subheading".
+function fieldNamePattern(key) {
+    const words = key
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .split(/[\s_-]+/)
+        .filter(Boolean)
+        .map((word) => word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+    if (words.length === 0)
+        return null;
+    return new RegExp(`\\b${words.join("[\\s_-]*")}\\b`, "i");
+}
+export function inferFieldHintFromMessage(message, allowedKeys) {
+    const lower = message.toLowerCase();
+    // 1. The message names one of this block's own props. A site's blocks are its
+    //    own — their props are called whatever the site calls them ("heading",
+    //    "eyebrow", "leadText"), so match those before falling back to Avocado's
+    //    house vocabulary. Longest first, so "subheading" beats "heading" when a
+    //    block happens to expose both.
+    const named = [...allowedKeys]
+        .filter((key) => key.length >= MIN_NAMED_KEY_LENGTH)
+        .sort((a, b) => b.length - a.length);
+    for (const key of named) {
+        const pattern = fieldNamePattern(key);
+        if (pattern?.test(lower))
+            return key;
+    }
+    // 2. Otherwise map the wording onto a synonym. Each entry lists its candidate
+    //    keys in preference order, so "change the heading" still resolves to
+    //    `title` on a canonical Hero, and to `heading` on a block that calls it that.
+    const keyMap = [
+        { test: /\btitle\b|\bheading\b|\bheadline\b/, keys: ["title", "heading", "headline"] },
+        { test: /\bdescription\b|\bbody\b|\bcopy\b/, keys: ["description", "body", "copy"] },
+        { test: /\bcta\s*text\b|\bbutton\s*text\b/, keys: ["ctaText", "buttonText"] },
+        { test: /\bcta\s*link\b|\bhref\b|\blink\b|\burl\b/, keys: ["ctaHref", "href", "link", "url"] },
+        { test: /\bquote\b/, keys: ["quote"] },
+        { test: /\bauthor\b/, keys: ["author"] },
+        { test: /\bquestion\b|\bfaq\s*q\b/, keys: ["q", "question"] },
+        { test: /\banswer\b|\bfaq\s*a\b/, keys: ["a", "answer"] }
+    ];
+    for (const entry of keyMap) {
+        if (!entry.test.test(lower))
+            continue;
+        const hit = entry.keys.find((key) => allowedKeys.includes(key));
+        if (hit)
+            return hit;
+    }
+    return null;
+}
+export function rewriteFromExisting(existing, message) {
+    let next = existing
+        .replace(/\bamazing\b/gi, "great")
+        .replace(/\bincredible\b/gi, "powerful")
+        .replace(/\breally\b/gi, "")
+        .replace(/\bvery\b/gi, "")
+        .replace(/\s{2,}/g, " ")
+        .trim();
+    if (/short|shorter|concise|brief/i.test(message)) {
+        const sentence = next.split(/[.!?]/)[0]?.trim();
+        if (sentence)
+            next = sentence.endsWith(".") ? sentence : `${sentence}.`;
+    }
+    if (next === existing) {
+        next = existing.endsWith(".") ? `${existing.slice(0, -1)} today.` : `${existing} today.`;
+    }
+    return next;
+}
+export function coercePatchForEditablePath(block, editablePath, rawPatch, message) {
+    if (!editablePath)
+        return null;
+    const directKey = editablePath.trim();
+    const blockProps = block.props;
+    if (directKey && Object.prototype.hasOwnProperty.call(blockProps, directKey)) {
+        const source = patchObject(rawPatch) ?? inferSimpleFieldPatchFromMessage(message);
+        let value;
+        if (source) {
+            if (Object.prototype.hasOwnProperty.call(source, directKey))
+                value = source[directKey];
+            else {
+                const mapped = Object.keys(source).find((key) => key.toLowerCase() === directKey.toLowerCase());
+                if (mapped)
+                    value = source[mapped];
+            }
+        }
+        if (value === undefined) {
+            const quoted = quotedText(message);
+            if (quoted)
+                value = quoted;
+        }
+        if (value === undefined && isRewriteRequest(message)) {
+            const existing = blockProps[directKey];
+            if (typeof existing === "string" && existing.trim().length > 0)
+                value = rewriteFromExisting(existing, message);
+        }
+        if (value === undefined && /(?:imageurl|href|url|ogimage)/i.test(directKey)) {
+            const match = message.match(/https?:\/\/[^\s<>"')]+/i);
+            if (match?.[0])
+                value = match[0].trim();
+        }
+        if (value === undefined)
+            return null;
+        return {
+            patch: { [directKey]: value },
+            changedKeys: [directKey],
+            rootKey: directKey
+        };
+    }
+    const parsed = parseIndexedPath(editablePath);
+    if (!parsed)
+        return null;
+    const list = block.props[parsed.listKey];
+    if (!Array.isArray(list) || parsed.index < 0 || parsed.index >= list.length)
+        return null;
+    const rowRaw = list[parsed.index];
+    if (!rowRaw || typeof rowRaw !== "object" || Array.isArray(rowRaw))
+        return null;
+    const row = rowRaw;
+    const source = patchObject(rawPatch) ?? inferSimpleFieldPatchFromMessage(message);
+    const allowedItemKeys = Object.keys(row);
+    const normalizedToAllowed = new Map();
+    for (const key of allowedItemKeys)
+        normalizedToAllowed.set(key.toLowerCase(), key);
+    const itemPatch = {};
+    if (source) {
+        for (const [key, value] of Object.entries(source)) {
+            const normalized = key.trim();
+            const fromPathPrefix = `${parsed.listKey}[${parsed.index}].`;
+            const childKey = normalized.startsWith(fromPathPrefix) ? normalized.slice(fromPathPrefix.length) : normalized;
+            const mapped = normalizedToAllowed.get(childKey.toLowerCase());
+            if (mapped)
+                itemPatch[mapped] = value;
+        }
+    }
+    if (Object.keys(itemPatch).length === 0 && isRewriteRequest(message)) {
+        const preferredKey = (parsed.leaf && normalizedToAllowed.get(parsed.leaf.toLowerCase())) ?? inferFieldHintFromMessage(message, allowedItemKeys);
+        if (preferredKey) {
+            const existing = row[preferredKey];
+            if (typeof existing === "string" && existing.trim().length > 0) {
+                itemPatch[preferredKey] = rewriteFromExisting(existing, message);
+            }
+        }
+    }
+    if (Object.keys(itemPatch).length === 0)
+        return null;
+    const nextList = list.map((entry, idx) => {
+        if (idx !== parsed.index || !entry || typeof entry !== "object" || Array.isArray(entry))
+            return entry;
+        return { ...entry, ...itemPatch };
+    });
+    return {
+        patch: { [parsed.listKey]: nextList },
+        changedKeys: Object.keys(itemPatch),
+        rootKey: parsed.listKey
+    };
+}
+export function quotedText(message) {
+    const normalized = message
+        .replace(/\u201c|\u201d/g, '"')
+        .replace(/\u2018|\u2019/g, "'");
+    return /"([^"]+)"/.exec(normalized)?.[1]?.trim()
+        ?? /'([^']+)'/.exec(normalized)?.[1]?.trim();
+}
+const NUMBER_WORDS = {
+    one: 1, two: 2, three: 3, four: 4, five: 5, six: 6, seven: 7, eight: 8, nine: 9, ten: 10
+};
+const MAX_APPEND_COUNT = 10;
+/**
+ * How many items a list-append request asks for. Only a quantity that directly follows
+ * the add verb counts ("add 3 cards", "add two more faqs") — a number elsewhere ("cards
+ * about our 5 values") is content, not a count. Recognises digits, number words, and the
+ * vague quantifiers "a couple" (2) / "a few" / "several" (3). Clamped to [1, 10] so a
+ * typo like "add 500 cards" can't blow up the patch.
+ */
+export function parseRequestedCount(message) {
+    const lower = message.toLowerCase();
+    const m = lower.match(/\b(?:add|insert|append|create|include|put)\s+(?:another\s+|more\s+)?(\d{1,2}|one|two|three|four|five|six|seven|eight|nine|ten)\b/);
+    if (m) {
+        const raw = m[1];
+        const n = /^\d+$/.test(raw) ? parseInt(raw, 10) : NUMBER_WORDS[raw] ?? 1;
+        return Math.max(1, Math.min(MAX_APPEND_COUNT, n));
+    }
+    if (/\ba\s+couple\b/.test(lower))
+        return 2;
+    if (/\b(?:a\s+few|several)\b/.test(lower))
+        return 3;
+    return 1;
+}
+/** Append `count` freshly-built items (index passed to the factory) onto `existing`. */
+function appendItems(existing, count, makeItem) {
+    return [...existing, ...Array.from({ length: count }, (_, i) => makeItem(i))];
+}
+export function buildListAppendPatch(block, message) {
+    const lower = message.toLowerCase();
+    const allQuoted = [...message.matchAll(/['"]([^'"]+)['"]/g)].map((m) => m[1].trim()).filter(Boolean);
+    const quoted = allQuoted[0] ?? null;
+    // Honour a requested quantity ("add 3 testimonials" → three items). The first item
+    // carries any quoted content; extras get a numbered default so they're distinguishable.
+    const count = parseRequestedCount(message);
+    const sfx = (i) => (count > 1 ? ` ${i + 1}` : "");
+    if (block.type === "FAQAccordion") {
+        const existing = Array.isArray(block.props.items) ? block.props.items : [];
+        const baseQ = quoted ?? (lower.includes("question") ? "New question" : "How does this work?");
+        return {
+            items: appendItems(existing, count, (i) => ({
+                q: i === 0 ? baseQ : `New question${sfx(i)}`,
+                a: i === 0 ? allQuoted[1] ?? "Add answer here." : "Add answer here."
+            }))
+        };
+    }
+    if (block.type === "Testimonials") {
+        const existing = Array.isArray(block.props.items) ? block.props.items : [];
+        return {
+            items: appendItems(existing, count, (i) => ({
+                quote: i === 0 && quoted ? quoted : "Great experience.",
+                author: "Customer"
+            }))
+        };
+    }
+    if (block.type === "FeatureGrid") {
+        const existing = Array.isArray(block.props.features) ? block.props.features : [];
+        return {
+            features: appendItems(existing, count, (i) => ({
+                title: i === 0 && quoted ? quoted : `New feature${sfx(i)}`,
+                description: "Describe this feature."
+            }))
+        };
+    }
+    if (block.type === "CardGrid") {
+        const existing = Array.isArray(block.props.cards) ? block.props.cards : [];
+        return {
+            cards: appendItems(existing, count, (i) => ({
+                title: i === 0 && quoted ? quoted : `New card${sfx(i)}`,
+                description: "Add card description.",
+                ctaText: "Learn more",
+                ctaHref: "/"
+            }))
+        };
+    }
+    if (block.type === "Tabs") {
+        const existing = Array.isArray(block.props.tabs) ? block.props.tabs : [];
+        return {
+            tabs: appendItems(existing, count, (i) => ({
+                label: i === 0 && quoted ? quoted : `New tab${sfx(i)}`,
+                content: i === 0 ? allQuoted[1] ?? "Add tab content here." : "Add tab content here."
+            }))
+        };
+    }
+    if (block.type === "Stats") {
+        const existing = Array.isArray(block.props.stats) ? block.props.stats : [];
+        return {
+            stats: appendItems(existing, count, (i) => ({
+                value: i === 0 && quoted ? quoted : "100+",
+                label: i === 0 ? allQuoted[1] ?? "New metric" : `New metric${sfx(i)}`
+            }))
+        };
+    }
+    if (block.type === "Carousel") {
+        const existing = Array.isArray(block.props.items) ? block.props.items : [];
+        return {
+            items: appendItems(existing, count, (i) => ({
+                imageUrl: "/hero-generated.svg",
+                imageAlt: "New slide",
+                heading: i === 0 && quoted ? quoted : `New slide${sfx(i)}`
+            }))
+        };
+    }
+    if (block.type === "Table") {
+        const existing = Array.isArray(block.props.rows) ? block.props.rows : [];
+        const headers = Array.isArray(block.props.headers) ? block.props.headers : [];
+        const width = headers.length || existing[0]?.length || 1;
+        return {
+            rows: appendItems(existing, count, (i) => Array.from({ length: width }, (_, c) => (c === 0 ? (i === 0 && quoted ? quoted : `New${sfx(i)}`) : "")))
+        };
+    }
+    return null;
+}

package/dist/nlp/deterministic-planner-refs.d.ts

@@ -0,0 +1,33 @@
+import type { BlockType, PageDoc } from "@avocadostudio-ai/shared";
+export declare function inferAddedBlockTypeFromMessage(message: string): BlockType | undefined;
+export declare function resolveBlockRef(args: {
+    ref?: string | null;
+    currentPage: PageDoc;
+    activeBlockId?: string;
+    fallbackType?: BlockType | null;
+}): PageDoc["blocks"][number] | null;
+export declare function ordinalToIndex(value: string): 1 | 0 | -1 | 2 | 3 | 4 | null;
+export declare function resolveByDescriptor(args: {
+    descriptor: string;
+    currentPage: PageDoc;
+    activeBlockId?: string;
+}): import("@avocadostudio-ai/shared").BlockInstance | null;
+export declare function resolveReferencesFromMessage(args: {
+    message: string;
+    currentPage: PageDoc;
+    activeBlockId?: string;
+}): {
+    target: {
+        id: string;
+        type: BlockType;
+    } | null;
+    anchor: {
+        id: string;
+        type: BlockType;
+    } | null;
+    mentionedBlocks: {
+        id: string;
+        type: BlockType;
+        reason: string;
+    }[];
+};