@avocadostudio-ai/orchestrator-core 0.1.0

package/dist/chat/decomposer.d.ts

@@ -0,0 +1,21 @@
+import type { PageDoc } from "@avocadostudio-ai/shared";
+export declare function isMultiStepCandidate(message: string): boolean;
+export type DecomposeResult = {
+    steps: string[];
+    labels: string[];
+};
+export declare function decomposeRequest(args: {
+    message: string;
+    currentPage: PageDoc;
+    slug: string;
+    model: string;
+    siteContextBlock?: string | null;
+    locale?: string;
+    client?: {
+        chat: {
+            completions: {
+                create: (a: unknown) => any;
+            };
+        };
+    };
+}): Promise<DecomposeResult>;

package/dist/chat/decomposer.js

@@ -0,0 +1,65 @@
+import OpenAI from "openai";
+import { buildDecomposerSystemPrompt } from "./prompts.js";
+// ---------------------------------------------------------------------------
+// Heuristic: does this message look like a multi-step request?
+// ---------------------------------------------------------------------------
+const MULTI_STEP_SIGNALS = [
+    // Plural "pages" + creation verb
+    /\b(?:create|generate|build|make|draft|add)\b[^.\n]{0,80}\bpages\b/,
+    // "for each" / "for every" / "for all" + action
+    /\bfor\s+(?:each|every|all)\b/,
+    // Count + "pages"/"blocks" + conjunction
+    /\b(?:\d+|two|three|four|five|six|seven|eight|nine|ten)\s+(?:new\s+)?pages\b/,
+    // Multiple distinct actions separated by "and"/"then"
+    /\b(?:create|add|build)\b.{5,80}\b(?:and|then)\b.{5,80}\b(?:update|link|change|set|connect)\b/,
+    // "page for each card/item/feature"
+    /\bpages?\s+for\s+(?:each|every)\b/,
+];
+export function isMultiStepCandidate(message) {
+    const m = message.toLowerCase().replace(/\s+/g, " ").trim();
+    return MULTI_STEP_SIGNALS.some((re) => re.test(m));
+}
+export async function decomposeRequest(args) {
+    const { message, currentPage, slug, model, siteContextBlock, locale } = args;
+    const blocksSummary = currentPage.blocks
+        .map((b) => {
+        const props = b.props;
+        const title = typeof props.title === "string" ? props.title
+            : typeof props.heading === "string" ? props.heading : "";
+        return `- ${b.type} (id: ${b.id})${title ? `: "${title}"` : ""}`;
+    })
+        .join("\n");
+    const systemPrompt = buildDecomposerSystemPrompt({
+        slug,
+        pageTitle: currentPage.title,
+        blocksSummary,
+        siteContextBlock,
+        locale,
+    });
+    const client = args.client ?? new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+    const response = await client.chat.completions.create({
+        model,
+        messages: [
+            { role: "system", content: systemPrompt },
+            { role: "user", content: message }
+        ],
+        temperature: 0,
+        response_format: { type: "json_object" }
+    });
+    const raw = response.choices?.[0]?.message?.content ?? "{}";
+    try {
+        const parsed = JSON.parse(raw);
+        const steps = Array.isArray(parsed.steps) ? parsed.steps.filter((s) => typeof s === "string") : [];
+        const labels = Array.isArray(parsed.labels) ? parsed.labels.filter((s) => typeof s === "string") : [];
+        if (steps.length === 0)
+            return { steps: [message], labels: [message.slice(0, 40)] };
+        // Ensure labels array matches steps length
+        while (labels.length < steps.length) {
+            labels.push(`Step ${labels.length + 1}`);
+        }
+        return { steps, labels: labels.slice(0, steps.length) };
+    }
+    catch {
+        return { steps: [message], labels: [message.slice(0, 40)] };
+    }
+}

package/dist/chat/gemini-planner.d.ts

@@ -0,0 +1,70 @@
+import { type BlockManifest, type EditPlan, type Operation, type PageDoc } from "@avocadostudio-ai/shared";
+import { type ParsedIntent, plannerContextPack } from "../nlp/deterministic-planner.ts";
+import { type TokenUsage } from "../telemetry/usage.ts";
+import { type ToolRuntime } from "../tools/runtime.ts";
+import type { ToolExecutionEvent } from "../tools/types.ts";
+import { type PlannerSchemaContextMeta } from "./planner.ts";
+import { type DeferredNativeImageCall } from "./chat-pipeline-shared.ts";
+export declare function parseIntentWithGemini(args: {
+    message: string;
+    slug: string;
+    currentPage: PageDoc;
+    activeBlockId?: string;
+    activeBlockType?: string;
+    activeEditablePath?: string;
+    model: string;
+    log?: {
+        warn: (obj: Record<string, unknown>, msg: string) => void;
+    };
+}): Promise<ParsedIntent>;
+export declare function generatePlanWithGemini(args: {
+    message: string;
+    slug: string;
+    currentPage: PageDoc;
+    contextPack: ReturnType<typeof plannerContextPack>;
+    model: string;
+    history?: Array<{
+        role: "user" | "assistant";
+        content: string;
+    }>;
+    feedback?: string;
+    onToken?: (token: string) => void;
+    onFieldDraft?: (draft: {
+        blockId: string;
+        editablePath: string;
+        value: string;
+        pageSlug?: string;
+    }) => void;
+    onPlannedOp?: (op: Operation, index: number) => void;
+    onSummaryChunk?: (text: string) => void;
+    onChangeLogEntry?: (entry: string) => void;
+    onToolExecution?: (event: ToolExecutionEvent) => void;
+    onStatusUpdate?: (message: string) => void;
+    onImageProgress?: (event: {
+        percent: number;
+        stage: string;
+    }) => void;
+    toolRuntime?: ToolRuntime;
+    toolCallContext?: {
+        siteId: string;
+        sessionId: string;
+        userId?: string;
+        traceId: string;
+        gdriveFolderId?: string;
+    };
+    siteContextBlock?: string | null;
+    log?: {
+        warn: (obj: Record<string, unknown>, msg: string) => void;
+    };
+    forceFullSchemaContracts?: boolean;
+    componentsManifest?: BlockManifest;
+    lightweight?: boolean;
+    signal?: AbortSignal;
+    locale?: string;
+    imageSourceChoiceOpen?: boolean;
+}): Promise<{
+    plan: EditPlan;
+    usage: TokenUsage;
+    schemaContext: PlannerSchemaContextMeta;
+    deferredNativeImageCalls?: DeferredNativeImageCall[];
+}>;