@avocadostudio-ai/orchestrator-core 0.1.0

package/dist/nlp/intent-helpers.d.ts

@@ -0,0 +1,15 @@
+export declare function toSeedSlug(raw: string): string;
+export declare function normalizeRouteCandidate(candidate: unknown): string | null;
+export declare function firstRouteMention(message?: string): string | null;
+export declare function extractRouteMentions(message?: string): string[];
+export declare function isLikelyClarificationFollowUp(message: string): boolean;
+export declare function isStandalonePageOperation(message: string): boolean;
+export declare function parseCreatePageRequest(message: string): string | null;
+export declare function parseDuplicatePageRequest(message: string, args?: {
+    currentSlug?: string;
+}): {
+    sourceSlug: string | null;
+    targetSlug: string;
+} | null;
+/** Returns true when the message asks for AI-generated content alongside a page create. */
+export declare function requestsContentGeneration(message: string): boolean;

package/dist/nlp/intent-helpers.js

@@ -0,0 +1,243 @@
+export function toSeedSlug(raw) {
+    return raw
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 48);
+}
+export function normalizeRouteCandidate(candidate) {
+    if (typeof candidate !== "string")
+        return null;
+    const trimmed = candidate.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed === "/")
+        return "/";
+    if (trimmed.startsWith("/"))
+        return trimmed;
+    if (/^[a-z0-9][a-z0-9/_-]*$/i.test(trimmed))
+        return `/${trimmed}`;
+    return null;
+}
+export function firstRouteMention(message) {
+    if (!message)
+        return null;
+    const match = message.match(/\/[a-z0-9/_-]*/i);
+    if (!match)
+        return null;
+    return normalizeRouteCandidate(match[0]);
+}
+export function extractRouteMentions(message) {
+    if (!message)
+        return [];
+    const matches = message.match(/\/[a-z0-9/_-]*/gi) ?? [];
+    const out = [];
+    for (const item of matches) {
+        const normalized = normalizeRouteCandidate(item);
+        if (!normalized)
+            continue;
+        if (out.includes(normalized))
+            continue;
+        out.push(normalized);
+    }
+    return out;
+}
+export function isLikelyClarificationFollowUp(message) {
+    const normalized = message.toLowerCase().trim().replace(/\s+/g, " ");
+    if (!normalized)
+        return false;
+    const words = normalized.split(" ").filter(Boolean);
+    // Detect common clarification openers regardless of length
+    const hasClarificationOpener = /^(i mean\b|i meant\b|no[,.]|sorry[,.]|what i mean|not that[,.]|i was (?:talking|asking) about\b)/.test(normalized);
+    if (hasClarificationOpener)
+        return true;
+    // Detect confirmation / go-ahead responses to a previous clarification offer
+    const hasConfirmationOpener = /^(yes\b|yeah\b|yep\b|sure\b|ok\b|okay\b|go ahead\b|do it\b|let'?s (?:see|go|do)\b|show me\b|sounds good\b|please\b)/.test(normalized);
+    if (hasConfirmationOpener)
+        return true;
+    if (isStandalonePageOperation(normalized))
+        return false;
+    const hasReferenceCue = /\b(selected|this|that|it|them|those|these|one|ones|same)\b/.test(normalized) ||
+        /\bfirst|second|third|last\b/.test(normalized) ||
+        /\b(?:all|the|both)\s+\d+\b/.test(normalized);
+    const hasActionVerb = /\b(add|update|change|edit|remove|delete|move|rename|create|duplicate|set|rewrite|replace|translate|redesign|refocus|overhaul|rebuild|make|hide|show|capitali[sz]e|bold|italici[sz]e|underline|uppercase|lowercase|format|align|cent(?:er|re)|resize|shorten|lengthen|expand|shrink|reword|reorder|sort|swap|enable|disable|increase|decrease|turn)\b/.test(normalized);
+    if (hasActionVerb && /\b(this|current|selected|the)\s+page\b/.test(normalized))
+        return false;
+    // A message that re-states a full action against a concrete target ("delete the last
+    // card in the grid", "capitalize all the headings") is a fresh, self-contained command
+    // — not an answer to a pending "which one?". Genuine clarification answers ("the first
+    // one", "yes, the blue") confirm or name an option without re-issuing the verb against a
+    // concrete block/content noun. Without this guard a stale or just-raised clarification
+    // hijacks the next unrelated command, composing two unrelated requests (#26).
+    const namesConcreteObject = /\b(cards?|sections?|blocks?|headings?|titles?|subheadings?|buttons?|images?|photos?|grids?|heroe?s?|footers?|headers?|paragraphs?|testimonials?|faqs?|ctas?|tabs?|columns?|rows?|prices?|menus?|navs?|logos?|galler(?:y|ies)|videos?)\b/.test(normalized);
+    if (hasActionVerb && namesConcreteObject)
+        return false;
+    return (words.length <= 8 && hasReferenceCue) || (!hasActionVerb && words.length <= 5);
+}
+export function isStandalonePageOperation(message) {
+    const normalized = message.toLowerCase().trim().replace(/\s+/g, " ");
+    if (/\b(create|generate|add|make|build|populate|fill|remove|delete|rename|move|translate|redesign|refocus|overhaul|rebuild)\b.*\bpage\b/.test(normalized))
+        return true;
+    // "rename to Olive oil" — implicit page rename even without "page" keyword
+    if (/\brename\b.*\bto\s+[a-z]/i.test(normalized) && !/\bto\s+(first|last|top|bottom|start|end|beginning)\b/i.test(normalized))
+        return true;
+    return false;
+}
+export function parseCreatePageRequest(message) {
+    // Strip [site context]...[/site context] metadata to prevent false route matches
+    const stripped = message.replace(/\n?\[site context\][\s\S]*?\[\/site context\]\s*$/i, "").trim();
+    const lower = stripped.toLowerCase().replace(/\s+/g, " ").trim();
+    // Don't treat "remove/delete new page" as a create request
+    if (/\b(remove|delete|drop|destroy)\b/.test(lower))
+        return null;
+    const mentionsCurrentPage = /\b(this|current|selected)\s+page\b/.test(lower);
+    const hasExplicitRoute = Boolean(firstRouteMention(stripped) ?? extractRouteMentions(stripped)[0]);
+    const asksNewPage = /\bnew\s+page\b/.test(lower);
+    const isCurrentPagePlacementPhrase = /\b(?:on|at|in|within|inside)\s+(?:this|the|current|selected)\s+page\b/.test(lower) ||
+        /\b(?:end|top|bottom|start|beginning)\s+of\s+(?:this|the|current|selected)\s+page\b/.test(lower);
+    if (mentionsCurrentPage && !asksNewPage && !hasExplicitRoute)
+        return null;
+    if (isCurrentPagePlacementPhrase && !asksNewPage && !hasExplicitRoute)
+        return null;
+    // Bare "the page" is a generic reference to the CURRENT page — "make the page
+    // copy shorter", "shorten the page" are edits, not creates. Without this the loose
+    // "make…page" create phrase extracted "the" as a page name → junk /the (issue #24).
+    // Excludes the create forms "the page called/named/titled/for/about X".
+    const editsBareCurrentPage = /\bthe\s+pages?\b/.test(lower) && !/\bthe\s+pages?\s+(?:called|named|titled|for|about|on|with)\b/.test(lower);
+    if (editsBareCurrentPage && !asksNewPage && !hasExplicitRoute)
+        return null;
+    // Definite reference to an EXISTING named page ("make the home page better",
+    // "polish the about page"). Like "this page", this is a create request ONLY when paired
+    // with an explicit new-page cue (a route or "new page"); otherwise it's an edit/improvement.
+    // Without this, "make the home page better" matched the loose `make…page` create phrase and
+    // was misread as "create a page named The Home" (issue #17C).
+    const refersExistingNamedPage = /\b(?:the|our|my)\s+[a-z][a-z0-9-]*(?:\s+[a-z][a-z0-9-]*){0,2}\s+pages?\b/.test(lower);
+    if (refersExistingNamedPage && !asksNewPage && !hasExplicitRoute)
+        return null;
+    const hasPageWord = /\bpages?\b/.test(lower);
+    if (!hasPageWord)
+        return null;
+    const explicitCreatePhrase = /\b(create|generate|make|build|draft)\b[^.\n]{0,24}\b(new\s+)?pages?\b/.test(lower) ||
+        /\badd\s+(a\s+)?(new\s+)?[^.\n]{0,24}\bpages?\b/.test(lower) ||
+        /\bnew\s+pages?\b/.test(lower);
+    const hasCreateVerb = /\b(create|generate|add|make|build|draft)\b/.test(lower);
+    const hasRouteHint = /\/[a-z0-9/_-]*/i.test(stripped);
+    if (!explicitCreatePhrase && !(hasCreateVerb && hasRouteHint && hasPageWord))
+        return null;
+    if (mentionsCurrentPage && !asksNewPage && !hasExplicitRoute)
+        return null;
+    const directRoute = firstRouteMention(stripped) ?? extractRouteMentions(stripped)[0];
+    if (directRoute) {
+        const normalized = normalizeRouteCandidate(directRoute);
+        if (normalized && normalized !== "/")
+            return normalized;
+    }
+    // Quoted page name: 'create a new page "Test"' → /test, "page called 'About Us'" → /about-us
+    const quotedName = stripped.match(/["'\u201C\u201D\u2018\u2019]([^"'\u201C\u201D\u2018\u2019]{1,60})["'\u201C\u201D\u2018\u2019]/);
+    if (quotedName) {
+        const seed = toSeedSlug(quotedName[1].trim());
+        if (seed)
+            return `/${seed}`;
+    }
+    const forAudience = lower.match(/\bpage\s+for\s+([a-z0-9 -]{2,60})$/)?.[1];
+    if (forAudience) {
+        const seed = toSeedSlug(forAudience);
+        if (seed)
+            return `/for-${seed}`;
+    }
+    const aboutTopic = lower.match(/\b(?:new\s+)?page\s+(?:about|on|for)\s+([a-z0-9 -]{2,60})\b/)?.[1];
+    if (aboutTopic) {
+        // Trim at structural words that introduce block layout ("with a Hero section...")
+        const trimmed = aboutTopic.replace(/\s+(?:with|including|containing|featuring|that\s+has|having)\s+.*$/, "").trim();
+        const seed = toSeedSlug(trimmed || aboutTopic);
+        if (seed)
+            return `/${seed}`;
+    }
+    // "create/add/make [a] [new] <PageName> page" — extract name before "page"
+    const namedPage = lower.match(/\b(?:create|add|make|build|generate)\b\s+(?:a\s+)?(?:new\s+)?([a-z][a-z0-9 ]{1,40}?)\s+pages?\b/);
+    if (namedPage) {
+        const namedPageName = namedPage[1].trim();
+        const seed = toSeedSlug(namedPageName);
+        // A bare determiner ("the"/"this"/"a") isn't a page name — "make the page …"
+        // must not become /the (#24). Let the "page called X" form below win instead.
+        const CREATE_NAME_STOPWORDS = new Set(["the", "this", "that", "a", "an", "our", "my", "your", "its", "current", "existing", "same"]);
+        if (seed && seed !== "new" && !CREATE_NAME_STOPWORDS.has(namedPageName))
+            return `/${seed}`;
+    }
+    // "page called/named/titled <PageName>"
+    const calledPage = lower.match(/\bpages?\s+(?:called|named|titled)\s+['"]?([a-z][a-z0-9 ]{1,40})['"]?$/);
+    if (calledPage) {
+        const seed = toSeedSlug(calledPage[1].trim());
+        if (seed)
+            return `/${seed}`;
+    }
+    return "/new-page";
+}
+export function parseDuplicatePageRequest(message, args) {
+    const stripped = message.replace(/\n?\[site context\][\s\S]*?\[\/site context\]\s*$/i, "").trim();
+    const lower = stripped.toLowerCase().replace(/\s+/g, " ").trim();
+    if (!/\b(duplicate|copy|clone)\b/.test(lower))
+        return null;
+    if (!/\bpage\b/.test(lower) && !/\b(this|current|selected)\b/.test(lower) && !/\/[a-z0-9/_-]+/i.test(stripped))
+        return null;
+    const routeMentions = extractRouteMentions(stripped);
+    const byCommandRoute = stripped.match(/\b(?:duplicate|copy|clone)\s+(?:the\s+)?(?:page\s+)?(\/[a-z0-9/_-]+)/i)?.[1];
+    const byToRoute = stripped.match(/\b(?:to|into|as)\s+(\/[a-z0-9/_-]+)/i)?.[1]
+        ?? stripped.match(/\b(?:with\s+)?(?:url|path|route|slug)\s+(\/[a-z0-9/_-]+)/i)?.[1];
+    const usesCurrentPage = /\b(this|current|selected)\s+page\b/.test(lower) ||
+        /\b(?:duplicate|copy|clone)\s+(this|current|selected)\b/.test(lower);
+    // When user says "this page", source is the current page — don't grab route mentions as source
+    const normalizedByTo = normalizeRouteCandidate(byToRoute ?? null);
+    const sourceRouteCandidate = usesCurrentPage
+        ? null
+        : byCommandRoute ?? routeMentions.find((r) => normalizeRouteCandidate(r) !== normalizedByTo) ?? null;
+    let sourceSlug = normalizeRouteCandidate(sourceRouteCandidate);
+    if (!sourceSlug && usesCurrentPage)
+        sourceSlug = normalizeRouteCandidate(args?.currentSlug ?? null);
+    let targetSlug = normalizeRouteCandidate(byToRoute ?? null);
+    if (!targetSlug) {
+        const secondRoute = routeMentions.length >= 2 ? normalizeRouteCandidate(routeMentions[1] ?? null) : null;
+        if (secondRoute && secondRoute !== sourceSlug)
+            targetSlug = secondRoute;
+    }
+    if (!targetSlug) {
+        const nameMatch = stripped.match(/\b(?:called|named)\s+["']?([a-z0-9][a-z0-9 _-]{1,60})["']?/i)?.[1]?.trim();
+        if (nameMatch) {
+            const seed = toSeedSlug(nameMatch);
+            if (seed)
+                targetSlug = `/${seed}`;
+        }
+    }
+    if (!targetSlug || targetSlug === "/")
+        return null;
+    if (!sourceSlug)
+        sourceSlug = normalizeRouteCandidate(args?.currentSlug ?? null);
+    if (!sourceSlug || sourceSlug === "/")
+        return {
+            sourceSlug: sourceSlug ?? null,
+            targetSlug
+        };
+    return { sourceSlug, targetSlug };
+}
+/** Returns true when the message asks for AI-generated content alongside a page create. */
+export function requestsContentGeneration(message) {
+    const stripped = message.replace(/\n?\[site context\][\s\S]*?\[\/site context\]\s*$/i, "").trim();
+    const lower = stripped.toLowerCase();
+    const asksContent = /\bcontent\b/.test(lower) ||
+        /\b(fill|populate)\b.*\b(page|it)\b/.test(lower) ||
+        /\b(write|describe|explain)\b.*\b(about|for|on)\b/.test(lower) ||
+        /\b(analyze|analyse|suggest|improve|rethink|rework)\b/.test(lower) ||
+        /\balternate\s+(version|layout)\b/.test(lower) ||
+        /\bbased\s+on\s+(the\s+)?(existing|current|original)\b/.test(lower);
+    // Strip route paths before checking for block types so /faq doesn't match "faq"
+    const withoutRoutes = lower.replace(/\/[a-z0-9/_-]+/g, "");
+    const hasExplicitBlockTypes = /\b(hero|cta|call to action|rich\s?text|text\s+(?:section|block)|feature|testimonial|faq|card)\b/.test(withoutRoutes);
+    // When a topic is specified AND multiple block types are enumerated
+    // (e.g. "page about avocado recipes with a Hero, CardGrid, FAQ"),
+    // defer to the LLM — the user wants AI-generated content, not empty scaffolds.
+    const hasTopic = /\bpage\s+(?:about|on|for)\s+[a-z]/.test(lower);
+    const blockTypeMatches = withoutRoutes.match(/\b(hero|cta|call to action|rich\s?text|text\s+(?:section|block)|feature|testimonial|faq|card)\b/g);
+    if (hasTopic && blockTypeMatches && blockTypeMatches.length >= 2)
+        return true;
+    return asksContent && !hasExplicitBlockTypes;
+}

package/dist/nlp/intent-patterns.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Consolidated intent-pattern registry.
+ *
+ * All regex/string-array constants used for intent classification live here.
+ * Functions that *use* the patterns stay in their original modules — only the
+ * pattern definitions are centralised.
+ */
+import type { BlockType } from "@avocadostudio-ai/shared";
+/** Matches "block(s)", "component(s)", "section(s)", "element(s)", "widget(s)" */
+export declare const UNIT: string;
+/** Matches "block type(s)", "component type(s)", etc. */
+export declare const UNIT_TYPE: string;
+/**
+ * Fuzzy "populate" — tolerates common typos (op-transposition "opoulate",
+ * insertion "popoulate", single-p omission "poulate", l/u transposition
+ * "popluate", l-insertion "polulate"). Used in batch / page-wide rewrite
+ * patterns so a typo doesn't silently downgrade a populate-the-page request
+ * to a single update_props (trace c245295d).
+ */
+export declare const POPULATE_FUZZY: string;
+export declare const BLOCK_CATALOG_PATTERNS: RegExp[];
+export declare const BATCH_ADD_PATTERNS: RegExp[];
+export declare const BATCH_UPDATE_PATTERNS: RegExp[];
+export declare const BATCH_PAGE_CREATE_PATTERNS: RegExp[];
+export declare const COUNTED_MULTI_BLOCK_ADD_PATTERN: RegExp;
+export declare const ADD_ACTION_PATTERN: RegExp;
+export declare const FIELD_CONTENT_UPDATE_PATTERN: RegExp;
+export declare const BLOCK_TYPE_KEYWORDS: Array<{
+    key: string;
+    pattern: RegExp;
+}>;
+export declare const KEYWORD_TO_BLOCK_TYPE: Record<string, BlockType>;
+export declare const EACH_BLOCK_TYPE_PATTERN: RegExp;
+export declare const PAGE_WIDE_REWRITE_PATTERNS: RegExp[];
+export declare const BATCH_REORDER_PATTERNS: RegExp[];
+export declare const PAGE_LIST_PATTERNS: RegExp[];
+export declare const CROSS_PAGE_SCOPE_PATTERN: RegExp;
+export declare const CONTENT_QUERY_PATTERNS: RegExp[];
+export declare const EXCEPT_PATTERN: RegExp;
+export declare const THIS_ONE_PATTERN: RegExp;

package/dist/nlp/intent-patterns.js

@@ -0,0 +1,223 @@
+/**
+ * Consolidated intent-pattern registry.
+ *
+ * All regex/string-array constants used for intent classification live here.
+ * Functions that *use* the patterns stay in their original modules — only the
+ * pattern definitions are centralised.
+ */
+// ---------------------------------------------------------------------------
+// Shared building-block fragments
+// ---------------------------------------------------------------------------
+/** Matches "block(s)", "component(s)", "section(s)", "element(s)", "widget(s)" */
+export const UNIT = String.raw `(?:blocks?|components?|sections?|elements?|widgets?)`;
+/** Matches "block type(s)", "component type(s)", etc. */
+export const UNIT_TYPE = String.raw `(?:block|component|section|element|widget)\s+types?`;
+/**
+ * Fuzzy "populate" — tolerates common typos (op-transposition "opoulate",
+ * insertion "popoulate", single-p omission "poulate", l/u transposition
+ * "popluate", l-insertion "polulate"). Used in batch / page-wide rewrite
+ * patterns so a typo doesn't silently downgrade a populate-the-page request
+ * to a single update_props (trace c245295d).
+ */
+export const POPULATE_FUZZY = String.raw `(?:populate|opoulate|popoulate|poulate|popluate|polulate)`;
+// ---------------------------------------------------------------------------
+// Block catalog — "what blocks can I add?"
+// ---------------------------------------------------------------------------
+export const BLOCK_CATALOG_PATTERNS = [
+    new RegExp(String.raw `\bwhat\s+(?:other\s+)?${UNIT}\s+(?:can|do)\s+(?:you|i|we)\s+(?:have|add)\b`),
+    new RegExp(String.raw `\bwhich\s+(?:other\s+)?${UNIT}\s+(?:can|do)\s+(?:you|i|we)\s+(?:have|add)\b`),
+    new RegExp(String.raw `\bwhat\s+(?:other\s+)?${UNIT_TYPE}\s+(?:can|do)\s+(?:you|i|we)\s+(?:have|add)\b`),
+    new RegExp(String.raw `\bwhich\s+(?:other\s+)?${UNIT_TYPE}\s+(?:can|do)\s+(?:you|i|we)\s+(?:have|add)\b`),
+    new RegExp(String.raw `\bwhat\s+${UNIT}\s+(?:are|is)\s+(?:available|supported)\b`),
+    new RegExp(String.raw `\bwhat\s+${UNIT}\s+are\b.{0,20}\badd\b`),
+    new RegExp(String.raw `\bavailabl\w*\s+${UNIT}\b`),
+    new RegExp(String.raw `\bavailabl\w*\s+${UNIT_TYPE}\b`),
+    /\bwhat\s+else\s+can\s+i\s+add\b/,
+    /\bwhat\s+other\s+content\b/,
+    /\blist\s+(all\s+)?(the\s+)?(?:blocks?|components?|sections?)\b/
+];
+// ---------------------------------------------------------------------------
+// Batch add — "add all available block types", "scaffold the page"
+// ---------------------------------------------------------------------------
+export const BATCH_ADD_PATTERNS = [
+    new RegExp(String.raw `\badd\s+(?:all|every|each|the\s+remaining|the\s+rest\s+of(?:\s+the)?)\s+${UNIT}\b`),
+    new RegExp(String.raw `\badd\s+(?:all|every|each|the\s+remaining|the\s+rest\s+of(?:\s+the)?)\s+${UNIT_TYPE}\b`),
+    /\bscaffold\b/,
+    /\bfill\s+(?:out\s+)?(?:the\s+)?page\b/,
+    /\badd\s+(?:all|every)\s+(?:available|missing|remaining)\b/,
+    new RegExp(String.raw `\b(?:all|every)\s+(?:available|missing|remaining)\s+${UNIT}\b`),
+    /\bbuild\s+(?:out|up)\s+(?:the\s+)?(?:whole\s+)?page\b/,
+    // "showcasing/featuring all (available) components/blocks" — page creation with all block types
+    new RegExp(String.raw `\b(?:showcas\w*|featuring|demonstrat\w*)\s+(?:all\s+)?(?:(?:the\s+)?available\s+)?${UNIT}\b`),
+    // "all available componenzs" and similar typos — fuzzy match for "all available" + unit-like word
+    /\ball\s+(?:available|existing)\s+\w*(?:componen|block|section|element|widget)\w*\b/,
+    // "add more content/sections to this page", "add content to the page"
+    /\badd\s+(?:more\s+)?(?:content|sections?)\s+(?:to\s+)?(?:this|the)\s+page\b/,
+    // "expand this page", "flesh out this page", "enrich this page"
+    /\b(?:expand|flesh\s+out|enrich|grow|extend|bulk\s+up)\s+(?:this|the)\s+page\b/
+];
+// ---------------------------------------------------------------------------
+// Batch update — "populate all components", "update all blocks"
+// ---------------------------------------------------------------------------
+export const BATCH_UPDATE_PATTERNS = [
+    new RegExp(String.raw `\b(?:${POPULATE_FUZZY}|update|edit|change|rewrite|refresh)\s+(?:all|every|each)\s+${UNIT}\b`),
+    new RegExp(String.raw `\b(?:${POPULATE_FUZZY}|update|edit|change|rewrite|refresh)\s+(?:all|every|each)\s+${UNIT_TYPE}\b`),
+    new RegExp(String.raw `\b(?:${POPULATE_FUZZY}|fill\s+in|fill)\s+(?:all|every|each)\s+(?:the\s+)?${UNIT}\b`),
+    new RegExp(String.raw `\b(?:${POPULATE_FUZZY}|update|edit|change|rewrite|refresh)\s+(?:all|every)\s+(?:existing\s+)?(?:content|blocks?|components?|sections?)\b`),
+    new RegExp(String.raw `\b${POPULATE_FUZZY}\s+(?:\w+\s+){0,2}page\b`),
+    new RegExp(String.raw `\b${POPULATE_FUZZY}\b.{0,60}\b(?:with|w[io]th)\b.{0,30}\bcontent\b`),
+    /\b(?:sample|placeholder|demo)\s+content\s+(?:for|to|in|on)\s+(?:all|every|each)\b/,
+    new RegExp(String.raw `\b(?:all|every|each)\s+(?:the\s+)?${UNIT}\s+with\s+(?:sample|placeholder|demo|real)\s+content\b`)
+];
+// ---------------------------------------------------------------------------
+// Batch page creation — "create pages for these audiences"
+// ---------------------------------------------------------------------------
+export const BATCH_PAGE_CREATE_PATTERNS = [
+    /\b(?:create|generate|build|make|draft|add)\b[^.\n]{0,140}\bpages\b/,
+    /\b(?:create|generate|build|make|draft)\b[^.\n]{0,140}\bonly\b[^.\n]{0,140}\bpages\b/,
+    /\bpages?\s+for\s+(?:these|those|the following|multiple|several)\b/,
+    /\bfor\s+.+\b(?:and|,|&)\b.+\bpages?\b/,
+    /\bfor\s+.+\b(?:and|,|&)\b.+\b(?:audiences|users?|customers?|buyers?|founders?|teams?|developers?|marketers?|parents?|students?)\b/
+];
+// ---------------------------------------------------------------------------
+// Counted multi-block add — "add 3 blocks", "add two sections"
+// ---------------------------------------------------------------------------
+export const COUNTED_MULTI_BLOCK_ADD_PATTERN = /\b(?:add|insert|include|create|generate|build)\s+(?:\d+|two|three|four|five|six|seven|eight|nine|ten)\s+(?:(?:\w+[-\s])*)(?:block\w*|component\w*|section\w*|element\w*|widget\w*)\b/;
+// ---------------------------------------------------------------------------
+// Generic add-action verb
+// ---------------------------------------------------------------------------
+export const ADD_ACTION_PATTERN = /\b(?:add|insert|include|create|generate|build)\b/;
+// ---------------------------------------------------------------------------
+// Field-content update disguised as add — "add X in/to [the Y] heading"
+// "add numbers in the Hero subheading" is an update to Hero.subheading,
+// NOT a batch add (even when "numbers"/"copy"/etc. alias block-type keywords).
+// ---------------------------------------------------------------------------
+const FIELD_NAMES = String.raw `(?:heading|subheading|sub-?title|title|copy|body|description|caption|label|paragraph|button\s*text|cta\s*text)`;
+export const FIELD_CONTENT_UPDATE_PATTERN = new RegExp(String.raw `\b(?:add|insert|include|append|put)\b[\s\S]*?\b(?:in|into|to|within|inside)\s+(?:the\s+|a\s+|an\s+)?(?:\w+[\s-]+){0,3}` +
+    FIELD_NAMES +
+    String.raw `\b`, "i");
+// ---------------------------------------------------------------------------
+// Block-type keyword lookup — maps natural language to BlockType values
+// ---------------------------------------------------------------------------
+export const BLOCK_TYPE_KEYWORDS = [
+    { key: "hero", pattern: /\bhero\b/ },
+    { key: "featuregrid", pattern: /\bfeature\s*grid\b|\bfeatures?\b/ },
+    { key: "testimonials", pattern: /\btestimonials?\b|\breviews?\b(?!\s+(?:the|this|it|my|our|heading|page|content|copy|text|block|section))|\bsocial proof\b/ },
+    { key: "faq", pattern: /\bfaq\b/ },
+    { key: "cta", pattern: /\bcta\b|\bcall to action\b/ },
+    { key: "cardgrid", pattern: /\bcard\s*grid\b|\bcardgrid\b|\bpricing\b/ },
+    { key: "card", pattern: /\bcard\b/ },
+    { key: "richtext", pattern: /\brich[\s-]?text\b|\btext block\b|\bparagraph\b|\bcopy\b(?!\s+(?:the|this|it|of|from|to))/ },
+    { key: "twocolumn", pattern: /\btwo\s*column\b|\btwocolumn\b|\b2\s*column\b/ },
+    { key: "stats", pattern: /\bstats?\b|\bstatistics\b|\bmetrics\b|\bnumbers\b/ },
+    { key: "carousel", pattern: /\bcarousel\b|\bslideshow\b|\bslider\b/ },
+    { key: "gallery", pattern: /\bgallery\b|\bimage grid\b/ },
+    { key: "tabs", pattern: /\btabs?\b|\btabbed\b/ },
+    { key: "table", pattern: /\btable\b/ },
+    { key: "quote", pattern: /\bblockquote\b/ },
+    { key: "video", pattern: /\bvideo\b/ },
+    { key: "embed", pattern: /\bembed\b|\biframe\b/ },
+    { key: "banner", pattern: /\bbanner\b|\bannouncement\b/ }
+];
+export const KEYWORD_TO_BLOCK_TYPE = {
+    hero: "Hero",
+    featuregrid: "FeatureGrid",
+    testimonials: "Testimonials",
+    faq: "FAQAccordion",
+    cta: "CTA",
+    cardgrid: "CardGrid",
+    card: "Card",
+    richtext: "RichText",
+    twocolumn: "TwoColumn",
+    stats: "Stats",
+    carousel: "Carousel",
+    gallery: "Gallery",
+    tabs: "Tabs",
+    table: "Table",
+    quote: "Quote",
+    video: "Video",
+    embed: "Embed",
+    banner: "Banner"
+};
+// ---------------------------------------------------------------------------
+// "each card", "every feature" — batch op across specific block type items
+// ---------------------------------------------------------------------------
+export const EACH_BLOCK_TYPE_PATTERN = new RegExp(String.raw `\b(?:each|every|all)\s+(?:` +
+    BLOCK_TYPE_KEYWORDS.map((entry) => entry.pattern.source).join("|") +
+    String.raw `)\b`);
+// ---------------------------------------------------------------------------
+// Page-wide rewrite / rebrand — "refocus this page on X"
+// ---------------------------------------------------------------------------
+export const PAGE_WIDE_REWRITE_PATTERNS = [
+    /\b(?:refocus|rebrand|retheme|overhaul|redesign|transform)\s+(?:this|the)\s+page\b/,
+    /\brewrite\s+(?:all|the|this)\s+(?:page|content)\b/,
+    /\bredo\s+(?:this|the)\s+(?:whole\s+|entire\s+)?page\b/,
+    /\b(?:update|change)\s+(?:this|the)\s+(?:whole|entire)\s+page\b/,
+    new RegExp(String.raw `\b(?:${POPULATE_FUZZY}|fill)\s+(?:this\s+|the\s+)?page\b`),
+    new RegExp(String.raw `\b(?:${POPULATE_FUZZY}|fill)\b.*\b(?:with|using|w[io]th)\b.*\bcontent\b`),
+    // Structural audit requests — "review heading hierarchy", "fix heading structure", "review Grapefruits page heading tag hierarchy"
+    /\b(?:review|audit|fix|check)\b[\s\w]*\bheadings?\s*(?:tags?\s*)?(?:hierarchy|structure|levels?|order)\b/,
+    // Tonal / stylistic sweeps — "make this page more playful", "make /about more professional"
+    // Any "make (this|the|/slug) (whole|entire)? page more|less <adjective>" triggers page-wide treatment.
+    /\bmake\s+(?:this|the|our|my)\s+(?:whole\s+|entire\s+)?page\s+(?:more|less|feel|sound|look)\s+\w+/,
+    /\bmake\s+\/\w[\w/-]*\s+(?:more|less|feel|sound|look)\s+\w+/,
+    // Emoji sweeps across many blocks — "add emojis to headings, card titles, and CTA text"
+    // Require a breadth signal (multiple targets or all/every/everything) to avoid catching narrow single-field asks.
+    /\badd\s+emoji(?:s)?\b[\s\S]*\b(?:all|every|everything|headings?|titles?|labels?)\b/,
+    /\badd\s+emoji(?:s)?\b[\s\S]*,[\s\S]*\band\b/,
+    // Multi-part sweeping edits — "<change X>, <change Y>, and <change Z>" combined with a tonal/sweeping verb
+    /\bmake\s+(?:this|the)\s+page\s+more\s+\w+[\s\S]*\b(?:add|insert|include|update|rewrite|refresh)\b/,
+];
+// ---------------------------------------------------------------------------
+// Batch reorder / rearrange — "reorder blocks", "rearrange sections"
+// ---------------------------------------------------------------------------
+export const BATCH_REORDER_PATTERNS = [
+    /\b(?:reorder|re-order|rearrange|reorganize|re-organize|sort|shuffle)\s+(?:the\s+|all\s+)?(?:blocks?|sections?|components?|elements?)\b/,
+    /\b(?:reorder|re-order|rearrange|reorganize|re-organize|sort|shuffle)\s+(?:blocks?|sections?|components?|elements?)?\s*(?:in|into|to|for)\b/,
+    /\b(?:move|reorder|rearrange)\s+(?:all|every|each)\s+(?:blocks?|sections?|components?)\b/,
+    /\breoder\b/, // common typo for "reorder"
+];
+// ---------------------------------------------------------------------------
+// Page listing — "list all pages", "what pages do I have"
+// ---------------------------------------------------------------------------
+export const PAGE_LIST_PATTERNS = [
+    /\blist\s+(all\s+)?(the\s+)?pages\b/,
+    /\bshow\s+(me\s+)?(all\s+)?(the\s+)?pages\b/,
+    /\bwhat\s+pages\s+(are|do|does|is)\b/,
+    /\bwhich\s+pages\s+(are|do|does|is)\b/,
+    /\bhow\s+many\s+pages\b/,
+    /\bwhat\s+pages\s+(do\s+)?(i|we)\s+(have|got)\b/,
+    /\b(all|my|the|our)\s+pages\b/
+];
+// ---------------------------------------------------------------------------
+// Cross-page scope — a mutation that should span the whole site, not just the
+// current page ("update the CTA on all pages", "make the footer site-wide").
+// The single-page deterministic path can't honor these, so they defer to the
+// LLM (whose ops carry pageSlug and can fan out). See planner-quality #29.
+// ---------------------------------------------------------------------------
+export const CROSS_PAGE_SCOPE_PATTERN = /\b(?:all|every|each)\s+(?:the\s+)?pages?\b|\bsite[\s-]?wide\b|\bacross\s+(?:the\s+)?(?:whole\s+|entire\s+)?site\b|\bthroughout\s+(?:the\s+)?(?:whole\s+|entire\s+)?site\b|\bon\s+(?:the\s+)?(?:whole|entire)\s+site\b|\beverywhere\b|\bglobally\b/i;
+// ---------------------------------------------------------------------------
+// Content queries — read-only questions about what's on the page
+// "list all CTA buttons", "what images are on this page", "show me all links"
+// ---------------------------------------------------------------------------
+export const CONTENT_QUERY_PATTERNS = [
+    /\b(?:list|show|display|enumerate|find|what are)\b.*\b(?:cta|buttons?|links?|images?|headings?|titles?|texts?|urls?|hrefs?|sections?|blocks?)/,
+    /\b(?:what|which|where|how many)\b.*\b(?:cta|buttons?|links?|images?|headings?|titles?|urls?|hrefs?)\b/,
+    /\b(?:list|show|find)\s+(?:me\s+)?(?:all|every|each)\b.*\b(?:on|in|across)\s+(?:this|the)\s+(?:page|site)\b/,
+    /\bhow\s+many\s+(?:cta|button|link|image|heading|section|block|card|feature|item|testimonial)/,
+    /\bwhat\s+(?:does|is)\s+(?:the|this)\s+(?:page|site)\s+(?:about|contain|have|include)\b/,
+    /\bwhat\s+(?:content|copy|text)\s+(?:is|does)\b.*\b(?:on|in)\s+(?:this|the)\s+page\b/,
+    /\bsummarize\s+(?:this|the)\s+(?:page|content)\b/,
+    /\bwhat\s+(?:blocks?|sections?)\s+(?:are|is)\s+(?:on|in)\s+(?:this|the)\s+page\b/,
+    /\b(?:list|show|tell me)\b.*\b(?:all|every)\b.*\b(?:blocks?|sections?|components?)\b.*\b(?:on|in)\b/,
+    /\b(?:audit|review|check|inspect|analyze)\s+(?:the\s+)?(?:page|content|copy|text|links?|images?|buttons?|hero|cta|testimonials?|faq|feature\s*grid|card\s*grid|stats?|footer|contact\s*form|rich\s*text|two\s*column|carousel|gallery|tabs?|table|quote|video|embed|banner|section|block)\b/,
+    /\bdescribe\s+(?:this|the|that)\s+(?:image|photo|picture|icon|logo|illustration|page|site|content|section)\b/,
+];
+// ---------------------------------------------------------------------------
+// Exception modifier — "except", "but not", "other than", "all but"
+// ---------------------------------------------------------------------------
+export const EXCEPT_PATTERN = /\b(except|but not|other than|besides|everything but)\b|\ball\s+but\b/i;
+// ---------------------------------------------------------------------------
+// "this one" / "this block" — refers to the currently-selected block
+// ---------------------------------------------------------------------------
+export const THIS_ONE_PATTERN = /\b(this\s+(?:one|block|section|component)|the\s+(?:selected|current|active)\s+(?:one|block|section|component))\b|\bthis\s*$/i;

package/dist/nlp/plan-normalizer.d.ts

@@ -0,0 +1,41 @@
+import { type BlockType, type PageDoc } from "@avocadostudio-ai/shared";
+export declare function extractJsonObject(input: string): string | null;
+/**
+ * Attempt to repair common JSON malformations from LLM output:
+ * - Bare `-` used as markdown bullets inside arrays: `[- "item"]` → `["item"]`
+ * - Trailing commas before `]` or `}`
+ * Returns repaired string or original if no repair was needed.
+ */
+export declare function repairJson(raw: string): string;
+export type JsonRepairStrategy = "basic_repair" | "bare_minus_fix" | "close_brackets" | "truncate_at_boundary" | "none";
+export type JsonRepairResult = {
+    parsed: unknown;
+    strategy: JsonRepairStrategy;
+    /** Number of character-level mutations applied (for bare_minus_fix). */
+    mutationCount?: number;
+    /** Bytes discarded by truncation strategies. */
+    discardedBytes?: number;
+};
+/**
+ * Attempt multiple JSON repair strategies. Returns the first one that
+ * produces parseable JSON along with metadata about what was done,
+ * or throws the original error.
+ */
+export declare function repairAndParseJsonWithMeta(raw: string): JsonRepairResult;
+/**
+ * Attempt multiple JSON repair strategies. Returns the first one that
+ * produces parseable JSON, or throws the original error.
+ */
+export declare function repairAndParseJson(raw: string): unknown;
+export declare function normalizeOpName(op: unknown): unknown;
+export declare function pageIdFromSlug(slug: string): string;
+export declare function pageTitleFromSlug(slug: string): string;
+export declare function inferBlockTypeFromText(text: string): BlockType | undefined;
+export declare function nextBlockId(type: BlockType, page: PageDoc): string;
+export declare function defaultPropsForType(type: BlockType): Record<string, unknown>;
+export declare function patchObject(rawPatch: unknown): Record<string, unknown> | null;
+export declare function normalizePlanCandidate(input: unknown, args?: {
+    defaultSlug?: string;
+    currentPage?: PageDoc;
+    userMessage?: string;
+}): unknown;