@avocadostudio-ai/orchestrator-core 0.1.0

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

@@ -0,0 +1,362 @@
+import { getSessionDraft, getRecentEdits, getSiteConfig, orderSlugsHomeFirst } from "../state/session-state.js";
+import { resolveReferencesFromMessage } from "./deterministic-planner-refs.js";
+// ---------------------------------------------------------------------------
+// Path traversal
+// ---------------------------------------------------------------------------
+export function readPathValue(root, path) {
+    if (!path)
+        return undefined;
+    const parts = [];
+    const regex = /([^[.\]]+)|\[(\d+)\]/g;
+    for (const match of path.matchAll(regex)) {
+        if (match[1])
+            parts.push(match[1]);
+        if (match[2])
+            parts.push(Number(match[2]));
+    }
+    let current = root;
+    for (const part of parts) {
+        if (typeof part === "number") {
+            if (!Array.isArray(current))
+                return undefined;
+            current = current[part];
+            continue;
+        }
+        if (!current || typeof current !== "object" || Array.isArray(current))
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+// ---------------------------------------------------------------------------
+// Image URL helpers
+// ---------------------------------------------------------------------------
+/**
+ * Given block props and an editablePath targeting an alt-text field,
+ * resolve the companion image URL for vision-powered alt text generation.
+ *
+ * Examples:
+ *  - "imageAlt"           → props.imageUrl
+ *  - "cards[2].imageAlt"  → props.cards[2].imageUrl
+ *  - "items[0].image.alt" → props.items[0].image.src
+ */
+export function resolveImageUrlForAltField(blockProps, editablePath) {
+    if (!editablePath)
+        return undefined;
+    // Only trigger for paths ending in an alt-text field
+    if (!/(^|[.])imageAlt$/.test(editablePath) && !/(^|[.])alt$/.test(editablePath))
+        return undefined;
+    let companionPath;
+    if (editablePath.endsWith(".alt")) {
+        // e.g. "items[0].image.alt" → "items[0].image.src"
+        companionPath = editablePath.replace(/\.alt$/, ".src");
+    }
+    else {
+        // e.g. "imageAlt" or "cards[2].imageAlt" → "imageUrl" or "cards[2].imageUrl"
+        companionPath = editablePath.replace(/imageAlt$/, "imageUrl");
+    }
+    const value = readPathValue(blockProps, companionPath);
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function isLocalUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || parsed.hostname === "[::1]";
+    }
+    catch {
+        return false;
+    }
+}
+const MIME_BY_EXT = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".svg": "image/svg+xml"
+};
+/**
+ * Fetch an image URL and return base64 + media type.
+ * For localhost URLs the AI APIs can't reach, we fetch locally.
+ * For remote URLs, returns null so the caller can use the URL directly.
+ */
+export async function fetchImageAsBase64(url) {
+    if (!isLocalUrl(url))
+        return null;
+    try {
+        const res = await fetch(url);
+        if (!res.ok)
+            return null;
+        const buffer = Buffer.from(await res.arrayBuffer());
+        const contentType = res.headers.get("content-type");
+        let mediaType = contentType?.split(";")[0]?.trim() ?? "";
+        if (!mediaType || mediaType === "application/octet-stream") {
+            const ext = url.match(/(\.[a-z]+)(?:\?|$)/i)?.[1]?.toLowerCase() ?? "";
+            mediaType = MIME_BY_EXT[ext] ?? "image/jpeg";
+        }
+        return { base64: buffer.toString("base64"), mediaType };
+    }
+    catch {
+        return null;
+    }
+}
+const MAX_ATTACHMENT_FETCH_BYTES = 32 * 1024 * 1024;
+const ATTACHMENT_FETCH_TIMEOUT_MS = 15_000;
+const ALLOWED_IMAGE_MEDIA_TYPES = new Set(["image/png", "image/jpeg", "image/webp", "image/gif"]);
+function allowedAttachmentOrigin() {
+    return (process.env.ORCHESTRATOR_PUBLIC_ORIGIN ?? "http://localhost:4200").replace(/\/+$/, "");
+}
+/**
+ * SSRF guard: only fetch attachment URLs that point at this orchestrator's own
+ * `/generated-images/` store (where `/attachment/upload` writes them). Any
+ * other host or path — cloud metadata endpoints, internal services, arbitrary
+ * remote URLs — is rejected before we ever issue the request. Attachment URLs
+ * arrive in the client-supplied `/chat` body, so this cannot be skipped.
+ */
+function isAllowedAttachmentUrl(rawUrl) {
+    try {
+        const url = new URL(rawUrl);
+        const allowed = new URL(allowedAttachmentOrigin());
+        return url.origin === allowed.origin && url.pathname.startsWith("/generated-images/");
+    }
+    catch {
+        return false;
+    }
+}
+function normalizeImageMediaType(raw) {
+    const value = (raw ?? "").split(";")[0]?.trim().toLowerCase();
+    return value && ALLOWED_IMAGE_MEDIA_TYPES.has(value) ? value : "image/png";
+}
+/**
+ * Fetch each chat attachment's bytes and return base64 + media type for the
+ * planner to embed as native multimodal content blocks. We always base64 the
+ * bytes (rather than pass a URL) so all three providers behave uniformly —
+ * OpenAI's `file` part requires inline data, and dev URLs (localhost) aren't
+ * reachable by the model APIs anyway. URLs are SSRF-allowlisted, fetches are
+ * bounded by a timeout and a byte cap, and anything that fails is skipped.
+ */
+export async function resolveAttachmentsForLlm(attachments) {
+    if (!attachments || attachments.length === 0)
+        return [];
+    const resolved = [];
+    for (const attachment of attachments) {
+        if (!isAllowedAttachmentUrl(attachment.url))
+            continue;
+        try {
+            const res = await fetch(attachment.url, { signal: AbortSignal.timeout(ATTACHMENT_FETCH_TIMEOUT_MS) });
+            if (!res.ok)
+                continue;
+            const declaredLength = Number(res.headers.get("content-length") ?? "");
+            if (Number.isFinite(declaredLength) && declaredLength > MAX_ATTACHMENT_FETCH_BYTES)
+                continue;
+            const buffer = Buffer.from(await res.arrayBuffer());
+            if (buffer.byteLength > MAX_ATTACHMENT_FETCH_BYTES)
+                continue;
+            const mediaType = attachment.kind === "pdf"
+                ? "application/pdf"
+                : normalizeImageMediaType(attachment.mimeType || res.headers.get("content-type"));
+            resolved.push({ kind: attachment.kind, mediaType, base64: buffer.toString("base64"), name: attachment.name });
+        }
+        catch {
+            // Skip attachments we can't fetch (timeout, network error); planning proceeds with the rest.
+        }
+    }
+    return resolved;
+}
+// ---------------------------------------------------------------------------
+// Block snapshot
+// ---------------------------------------------------------------------------
+export function selectedBlockSnapshot(args) {
+    if (!args.activeBlockId)
+        return null;
+    const block = args.currentPage.blocks.find((item) => item.id === args.activeBlockId);
+    if (!block)
+        return null;
+    const editablePath = typeof args.activeEditablePath === "string" && args.activeEditablePath.length > 0 ? args.activeEditablePath : null;
+    return {
+        id: block.id,
+        type: block.type,
+        props: block.props,
+        selectedEditablePath: editablePath,
+        selectedEditableValue: editablePath ? readPathValue(block.props, editablePath) ?? null : null
+    };
+}
+// ---------------------------------------------------------------------------
+// Array prop metadata
+// ---------------------------------------------------------------------------
+export function arrayPropLengths(props) {
+    const out = {};
+    for (const [key, value] of Object.entries(props)) {
+        if (!Array.isArray(value))
+            continue;
+        const labels = [];
+        for (const item of value) {
+            if (typeof item === "object" && item !== null) {
+                const labelValue = item.label ??
+                    item.title ??
+                    item.heading ??
+                    item.question ??
+                    item.name;
+                if (typeof labelValue === "string")
+                    labels.push(labelValue);
+            }
+        }
+        out[key] = labels.length > 0 ? { length: value.length, labels } : { length: value.length };
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Text hints — lightweight prop snapshot for brand/theme context
+// ---------------------------------------------------------------------------
+const TEXT_HINT_KEYS = ["heading", "subheading", "title", "body", "ctaText", "label", "sectionTitle"];
+// How many of a block's own props to fall back on when it uses none of the
+// names above. Bounded because these hints go into every planner call.
+const MAX_FALLBACK_HINTS = 3;
+// Values that carry no brand/theme signal but do cost tokens.
+const NON_CONTENT_KEY = /(?:url|href|src|id|key|color|slug|icon|variant|align|position)$/i;
+const NON_CONTENT_VALUE = /^(?:https?:\/\/|\/|#[0-9a-f]{3,8}$|data:)/i;
+function truncateHint(value) {
+    // Truncate long body text to save tokens
+    return value.length > 120 ? value.slice(0, 120) + "…" : value;
+}
+function isContentString(key, value) {
+    if (typeof value !== "string" || value.trim().length === 0)
+        return false;
+    if (NON_CONTENT_KEY.test(key))
+        return false;
+    return !NON_CONTENT_VALUE.test(value.trim());
+}
+function extractTextHints(props) {
+    const hints = {};
+    for (const key of TEXT_HINT_KEYS) {
+        const value = props[key];
+        if (typeof value === "string" && value.trim().length > 0) {
+            hints[key] = truncateHint(value);
+        }
+    }
+    if (Object.keys(hints).length >= MAX_FALLBACK_HINTS)
+        return hints;
+    // The block names its text props something else — every custom block on a
+    // real site does. Without this a block using none of the names above reaches
+    // the planner as `props: {}`, so it can see the page structure but none of
+    // its content, and cannot resolve "the hero heading" to a block. Tops up
+    // rather than replaces, so a block mixing canonical and custom names (a
+    // `heading` plus an `eyebrow`) surfaces both.
+    for (const [key, value] of Object.entries(props)) {
+        if (key in hints || !isContentString(key, value))
+            continue;
+        hints[key] = truncateHint(value);
+        if (Object.keys(hints).length >= MAX_FALLBACK_HINTS)
+            break;
+    }
+    return hints;
+}
+// ---------------------------------------------------------------------------
+// Page intent summary
+// ---------------------------------------------------------------------------
+export function pageIntentSummary(args) {
+    const { slug, currentPage } = args;
+    const typeCounts = new Map();
+    for (const block of currentPage.blocks) {
+        typeCounts.set(block.type, (typeCounts.get(block.type) ?? 0) + 1);
+    }
+    const composition = Array.from(typeCounts.entries())
+        .map(([type, count]) => (count > 1 ? `${type} x${count}` : type))
+        .join(", ");
+    const hero = currentPage.blocks.find((b) => b.type === "Hero");
+    const heroHeading = hero && typeof hero.props.heading === "string" ? hero.props.heading : "";
+    const routeLabel = slug === "/" ? "Home page" : `Page ${slug}`;
+    const headingPart = heroHeading ? ` Hero message: "${heroHeading}".` : "";
+    return `${routeLabel} with ${currentPage.blocks.length} blocks (${composition}).${headingPart}`;
+}
+// ---------------------------------------------------------------------------
+// Planner context pack
+// ---------------------------------------------------------------------------
+export function plannerContextPack(args) {
+    const { session, slug, message, currentPage, activeBlockId, activeBlockType, activeEditablePath } = args;
+    const pageRoutes = orderSlugsHomeFirst(Array.from(getSessionDraft(session).keys()));
+    const siteConfigSummary = summarizeSiteConfigForPlanner(getSiteConfig(session), pageRoutes);
+    const selectedIdx = activeBlockId ? currentPage.blocks.findIndex((b) => b.id === activeBlockId) : -1;
+    const neighbors = selectedIdx >= 0
+        ? {
+            previous: selectedIdx > 0 ? currentPage.blocks[selectedIdx - 1] : null,
+            next: selectedIdx < currentPage.blocks.length - 1 ? currentPage.blocks[selectedIdx + 1] : null
+        }
+        : { previous: null, next: null };
+    return {
+        route: slug,
+        pageRoutes,
+        blockCount: currentPage.blocks.length,
+        // Spread so the key is optional on the inferred type — most turns carry none.
+        ...(args.attachments !== undefined ? { attachments: args.attachments } : {}),
+        selected: {
+            blockId: activeBlockId ?? null,
+            blockType: activeBlockType ?? null,
+            editablePath: activeEditablePath ?? null,
+            block: selectedBlockSnapshot({ currentPage, activeBlockId, activeEditablePath }),
+            imageUrlForVision: activeBlockId && activeEditablePath
+                ? resolveImageUrlForAltField((currentPage.blocks.find((b) => b.id === activeBlockId)?.props ?? {}), activeEditablePath) ?? null
+                : null
+        },
+        neighbors: {
+            previous: neighbors.previous ? { id: neighbors.previous.id, type: neighbors.previous.type } : null,
+            next: neighbors.next ? { id: neighbors.next.id, type: neighbors.next.type } : null
+        },
+        pageOutline: currentPage.blocks.map((b) => {
+            const bProps = b.props;
+            const arrProps = arrayPropLengths(bProps);
+            // Selected block: send full props for precise editing context
+            if (b.id === activeBlockId || args.includeFullProps) {
+                return { id: b.id, type: b.type, props: structuredClone(bProps), arrayProps: arrProps };
+            }
+            // Other blocks: key text props for brand/theme context + array metadata.
+            // Full scalar props are available via includeFullProps for content queries/translations.
+            const textHints = extractTextHints(bProps);
+            return { id: b.id, type: b.type, props: textHints, arrayProps: arrProps };
+        }),
+        pageMeta: currentPage.meta ?? null,
+        pageIntent: pageIntentSummary({ slug, currentPage }),
+        recentSuccessfulEdits: getRecentEdits(session, slug),
+        resolvedReferences: resolveReferencesFromMessage({ message, currentPage, activeBlockId }),
+        siteConfig: siteConfigSummary
+    };
+}
+// Project SiteConfig down to the header-editable surface (name, logo, nav)
+// plus default-label hints for routes that have no override yet, so the planner
+// can issue update_site_config ops with confidence.
+function summarizeSiteConfigForPlanner(config, pageRoutes) {
+    const navLabels = {};
+    for (const [slug, label] of Object.entries(config.navLabels ?? {})) {
+        if (typeof label === "string" && label.length > 0)
+            navLabels[slug] = label;
+    }
+    const navGroups = {};
+    for (const [label, slugs] of Object.entries(config.navGroups ?? {})) {
+        if (Array.isArray(slugs))
+            navGroups[label] = slugs.filter((s) => typeof s === "string");
+    }
+    const defaultLabels = {};
+    for (const slug of pageRoutes) {
+        if (navLabels[slug])
+            continue;
+        defaultLabels[slug] = deriveDefaultNavLabel(slug);
+    }
+    return {
+        name: typeof config.name === "string" && config.name.length > 0 ? config.name : null,
+        logo: typeof config.logo === "string" && config.logo.length > 0 ? config.logo : null,
+        navLabels,
+        navGroups,
+        defaultNavLabels: defaultLabels,
+        editPath: "use update_site_config to change name, logo, navLabels, or navGroups"
+    };
+}
+function deriveDefaultNavLabel(slug) {
+    if (slug === "/")
+        return "Home";
+    const last = slug.replace(/\/+$/, "").split("/").pop() ?? slug;
+    return last
+        .split(/[-_]/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}

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

@@ -0,0 +1,26 @@
+import { type PageDoc } from "@avocadostudio-ai/shared";
+export declare function nextAvailableSlug(session: string, baseSlug: string): string;
+export declare function createPageBlocks(args: {
+    requestedSlug: string;
+    userMessage?: string;
+}): import("@avocadostudio-ai/shared").BlockInstance[];
+export declare function buildCreatePagePlan(args: {
+    session: string;
+    requestedSlug: string;
+    assumptions?: string[];
+    userMessage?: string;
+}): {
+    intent: "needs_clarification";
+    summary_for_user: string;
+    change_log: string[];
+    ops: never[];
+} | {
+    intent: "edit_plan";
+    summary_for_user: string;
+    change_log: string[];
+    ops: {
+        op: "create_page";
+        page: PageDoc;
+    }[];
+} | null;
+export declare function isPageRouteRenameRequest(message?: string): boolean;

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

@@ -0,0 +1,170 @@
+import { normalizeRouteCandidate, toSeedSlug } from "./intent-helpers.js";
+import { stripSiteContextEnvelope, extractSiteContextLineValue } from "./intent-detection.js";
+import { defaultPropsForType, pageIdFromSlug, pageTitleFromSlug } from "./plan-normalizer.js";
+import { getSessionDraft } from "../state/session-state.js";
+import { titleCaseSentence } from "./deterministic-planner-suggestions.js";
+export function nextAvailableSlug(session, baseSlug) {
+    const draft = getSessionDraft(session);
+    if (!draft.has(baseSlug))
+        return baseSlug;
+    let idx = 2;
+    while (draft.has(`${baseSlug}-${idx}`))
+        idx += 1;
+    return `${baseSlug}-${idx}`;
+}
+export function createPageBlocks(args) {
+    const seed = toSeedSlug(args.requestedSlug.replace(/^\//, "") || "new-page") || "new-page";
+    const rawMessage = typeof args.userMessage === "string" ? args.userMessage : "";
+    const cleanMessage = stripSiteContextEnvelope(rawMessage);
+    const lowerMessage = cleanMessage.toLowerCase();
+    const asksIntentPage = /\b(intent|purpose|mission)\b/.test(lowerMessage);
+    const asksHero = /\bhero\b/.test(lowerMessage);
+    const asksText = /\b(rich[\s-]?text|text(?:\s+section|\s+block)?|copy)\b/.test(lowerMessage);
+    const asksCta = /\bcta\b|\bcall to action\b|\baction button\b/.test(lowerMessage);
+    const asksFeatures = /\bfeatures?\b/.test(lowerMessage);
+    const asksFaq = /\bfaq\b/.test(lowerMessage);
+    const asksTestimonials = /\btestimonials?\b/.test(lowerMessage);
+    const asksCards = /\bcards?\b/.test(lowerMessage);
+    const asksStructuredSections = asksHero || asksText || asksCta || asksFeatures || asksFaq || asksTestimonials || asksCards;
+    const sitePurpose = extractSiteContextLineValue(rawMessage, "Site purpose");
+    const pageTitle = pageTitleFromSlug(args.requestedSlug);
+    // Extract explicit hero heading from message (e.g. "hero titled 'About Us'")
+    const heroTitleMatch = cleanMessage.match(/hero\s+(?:titled?|called|named|with\s+(?:the\s+)?(?:title|heading))\s+['"]([^'"]+)['"]/i);
+    const heroHeading = heroTitleMatch?.[1] ?? (asksIntentPage ? "Purpose of This Site" : pageTitle);
+    const heroSubheading = sitePurpose
+        ? `This page explains ${sitePurpose}.`
+        : asksIntentPage
+            ? "This page explains what this site is for, who it helps, and the value it provides."
+            : `Use this page to introduce ${pageTitle}.`;
+    const ctaText = asksIntentPage ? "Explore the site" : "Get started";
+    const ctaHref = "/";
+    const ctaTitle = asksIntentPage ? "Ready to learn more?" : `Ready to explore ${pageTitle}?`;
+    const ctaDescription = sitePurpose
+        ? `Continue to discover how ${sitePurpose} translates into concrete next steps.`
+        : asksIntentPage
+            ? "Review the key points, then continue to the next step."
+            : "Continue to the next step.";
+    const richTextBody = sitePurpose
+        ? `Site intent: ${titleCaseSentence(sitePurpose)}.\n\nUse this section to explain the problem the site solves, who it serves, and what users should do next.`
+        : asksIntentPage
+            ? "This page captures the site intent: why it exists, who it serves, and what outcomes it helps users achieve.\n\nUse this section to add concrete details and examples."
+            : `Use this section to describe ${pageTitle} in detail.\n\nAdd context, benefits, and a clear next step for visitors.`;
+    const blocks = [
+        {
+            id: `b_hero_${seed}`,
+            type: "Hero",
+            props: {
+                ...defaultPropsForType("Hero"),
+                heading: heroHeading,
+                subheading: heroSubheading,
+                ctaText,
+                ctaHref
+            }
+        }
+    ];
+    if (asksStructuredSections && asksText) {
+        blocks.push({
+            id: `b_richtext_${seed}`,
+            type: "RichText",
+            props: {
+                ...defaultPropsForType("RichText"),
+                body: richTextBody
+            }
+        });
+    }
+    if (asksStructuredSections && asksFeatures) {
+        blocks.push({
+            id: `b_features_${seed}`,
+            type: "FeatureGrid",
+            props: defaultPropsForType("FeatureGrid")
+        });
+    }
+    if (asksStructuredSections && asksTestimonials) {
+        blocks.push({
+            id: `b_testimonials_${seed}`,
+            type: "Testimonials",
+            props: defaultPropsForType("Testimonials")
+        });
+    }
+    if (asksStructuredSections && asksFaq) {
+        blocks.push({
+            id: `b_faq_${seed}`,
+            type: "FAQAccordion",
+            props: defaultPropsForType("FAQAccordion")
+        });
+    }
+    if (asksStructuredSections && asksCards) {
+        blocks.push({
+            id: `b_cardgrid_${seed}`,
+            type: "CardGrid",
+            props: defaultPropsForType("CardGrid")
+        });
+    }
+    if (asksStructuredSections && asksCta) {
+        blocks.push({
+            id: `b_cta_${seed}`,
+            type: "CTA",
+            props: {
+                ...defaultPropsForType("CTA"),
+                title: ctaTitle,
+                description: ctaDescription,
+                ctaText,
+                ctaHref
+            }
+        });
+    }
+    return blocks;
+}
+export function buildCreatePagePlan(args) {
+    const normalizedRequested = normalizeRouteCandidate(args.requestedSlug);
+    if (!normalizedRequested || normalizedRequested === "/")
+        return null;
+    const draft = getSessionDraft(args.session);
+    if (draft.has(normalizedRequested)) {
+        return {
+            intent: "needs_clarification",
+            summary_for_user: `Page ${normalizedRequested} already exists. Provide a different page path.`,
+            change_log: args.assumptions ?? [],
+            ops: []
+        };
+    }
+    const now = new Date().toISOString();
+    const page = {
+        id: pageIdFromSlug(normalizedRequested),
+        slug: normalizedRequested,
+        title: pageTitleFromSlug(normalizedRequested),
+        updatedAt: now,
+        blocks: createPageBlocks({ requestedSlug: normalizedRequested, userMessage: args.userMessage })
+    };
+    return {
+        intent: "edit_plan",
+        summary_for_user: `Created page ${normalizedRequested}.`,
+        change_log: [...(args.assumptions ?? []), `Created new page ${normalizedRequested}.`],
+        ops: [{ op: "create_page", page }]
+    };
+}
+export function isPageRouteRenameRequest(message) {
+    if (!message)
+        return false;
+    const lower = message.toLowerCase();
+    const mentionsRoute = lower.includes("slug") || lower.includes("path") || lower.includes("route") || /\/[a-z0-9/_-]*/i.test(message);
+    const asksRename = lower.includes("rename") ||
+        lower.includes("change") ||
+        lower.includes("update") ||
+        lower.includes("move") ||
+        lower.includes("switch");
+    const mentionsPage = lower.includes("page") || lower.includes("this page");
+    if (mentionsRoute && asksRename && mentionsPage)
+        return true;
+    // "rename page to Our community" — natural language name after "to"
+    // Exclude position words (first/last/top/bottom) which indicate nav move, not rename
+    const hasRenameVerb = lower.includes("rename") || lower.includes("change") || lower.includes("switch");
+    const hasTarget = /\bto\s+[A-Za-z]/.test(message) &&
+        !/\bto\s+(first|last|top|bottom|start|end|beginning)\b/i.test(message);
+    if (hasRenameVerb && mentionsPage && hasTarget)
+        return true;
+    // "rename to Olive oil" — implicit current page (no "page" keyword needed when verb is "rename")
+    if (lower.includes("rename") && hasTarget)
+        return true;
+    return false;
+}

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

@@ -0,0 +1,80 @@
+import type { PageDoc } from "@avocadostudio-ai/shared";
+export declare function extractAudienceTarget(message: string): string;
+export declare function extractAudienceTargets(message: string): string[];
+export declare function titleCaseWords(text: string): string;
+export declare function addAudienceSuffix(value: string, audience: string): string;
+export declare function audiencePatchForBlock(block: PageDoc["blocks"][number], audience: string): Record<string, unknown>;
+export declare function coercePatchForBlock(block: PageDoc["blocks"][number], rawPatch: unknown): Record<string, unknown>;
+export declare function parseIndexedPath(path: string): {
+    listKey: string;
+    index: number;
+    leaf: string;
+} | null;
+export declare function inferSimpleFieldPatchFromMessage(message: string): Record<string, unknown> | null;
+export declare function isRewriteRequest(message: string): boolean;
+export declare function isTranslationRequest(message: string): boolean;
+export declare function shouldKeepRichTextTitleOnTranslate(args: {
+    target: PageDoc["blocks"][number];
+    activeEditablePath?: string;
+    message: string;
+    fullPatch: Record<string, unknown>;
+}): boolean;
+export declare function inferFieldHintFromMessage(message: string, allowedKeys: string[]): string | null;
+export declare function rewriteFromExisting(existing: string, message: string): string;
+export declare function coercePatchForEditablePath(block: PageDoc["blocks"][number], editablePath: string | undefined, rawPatch: unknown, message: string): {
+    patch: Record<string, unknown>;
+    changedKeys: string[];
+    rootKey: string;
+} | null;
+export declare function quotedText(message: string): string | undefined;
+/**
+ * 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 declare function parseRequestedCount(message: string): number;
+export declare function buildListAppendPatch(block: PageDoc["blocks"][number], message: string): {
+    items: Record<string, unknown>[];
+    features?: undefined;
+    cards?: undefined;
+    tabs?: undefined;
+    stats?: undefined;
+    rows?: undefined;
+} | {
+    features: Record<string, unknown>[];
+    items?: undefined;
+    cards?: undefined;
+    tabs?: undefined;
+    stats?: undefined;
+    rows?: undefined;
+} | {
+    cards: Record<string, unknown>[];
+    items?: undefined;
+    features?: undefined;
+    tabs?: undefined;
+    stats?: undefined;
+    rows?: undefined;
+} | {
+    tabs: Record<string, unknown>[];
+    items?: undefined;
+    features?: undefined;
+    cards?: undefined;
+    stats?: undefined;
+    rows?: undefined;
+} | {
+    stats: Record<string, unknown>[];
+    items?: undefined;
+    features?: undefined;
+    cards?: undefined;
+    tabs?: undefined;
+    rows?: undefined;
+} | {
+    rows: unknown[][];
+    items?: undefined;
+    features?: undefined;
+    cards?: undefined;
+    tabs?: undefined;
+    stats?: undefined;
+} | null;