@avocadostudio-ai/orchestrator-core 0.1.0

package/dist/publish/diff-engine.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Computes a structured diff between the session's draft pages and the
+ * currently-published pages. Pure function — no I/O. Shared with the editor
+ * via the PublishDiff type in @avocadostudio-ai/shared.
+ */
+import type { PageDoc, SiteConfig } from "@avocadostudio-ai/shared";
+import type { PublishDiff } from "@avocadostudio-ai/shared";
+/**
+ * Compare drafts to published and produce a structured diff. Pages are
+ * matched by slug. Within a page, blocks are matched by id.
+ *
+ * The resulting `pages` list is ordered: changed pages first (added →
+ * modified → removed), unchanged last. This lets the UI collapse noise.
+ */
+export declare function computePublishDiff(draft: PageDoc[], published: PageDoc[], options?: {
+    draftSiteConfig?: SiteConfig | null;
+    publishedSiteConfig?: SiteConfig | null;
+}): PublishDiff;

package/dist/publish/diff-engine.js

@@ -0,0 +1,305 @@
+/**
+ * Computes a structured diff between the session's draft pages and the
+ * currently-published pages. Pure function — no I/O. Shared with the editor
+ * via the PublishDiff type in @avocadostudio-ai/shared.
+ */
+const IMAGE_PATH_HINT = /(^|\.)(imageUrl|image|src|poster|logo|avatar|thumbnail)$/i;
+function inferKind(path, before, after) {
+    if (IMAGE_PATH_HINT.test(path))
+        return "image";
+    if (typeof before === "string" || typeof after === "string")
+        return "text";
+    return "other";
+}
+function isPlainObject(v) {
+    return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function arraysShallowEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++)
+        if (!deepEqual(a[i], b[i]))
+            return false;
+    return true;
+}
+function deepEqual(a, b) {
+    if (Object.is(a, b))
+        return true;
+    if (Array.isArray(a) && Array.isArray(b))
+        return arraysShallowEqual(a, b);
+    if (isPlainObject(a) && isPlainObject(b)) {
+        const ka = Object.keys(a);
+        const kb = Object.keys(b);
+        if (ka.length !== kb.length)
+            return false;
+        for (const key of ka)
+            if (!deepEqual(a[key], b[key]))
+                return false;
+        return true;
+    }
+    return false;
+}
+/**
+ * Walks two prop trees and emits one FieldDiff per leaf that changed.
+ * - Plain objects: recurse key-by-key (union of keys).
+ * - Arrays of plain objects: recurse element-by-element by index.
+ * - Arrays of primitives or mixed: treated as single leaves.
+ */
+function diffProps(before, after, path, out) {
+    if (deepEqual(before, after))
+        return;
+    const bothObjects = isPlainObject(before) && isPlainObject(after);
+    if (bothObjects) {
+        const keys = new Set([...Object.keys(before), ...Object.keys(after)]);
+        for (const key of keys) {
+            // `id` on a list item is internal addressing metadata, not user content —
+            // never surface it as a published change (it would otherwise show up as
+            // noise the first time a pre-item-id baseline is diffed against a draft
+            // whose items have since been backfilled with ids).
+            if (key === "id")
+                continue;
+            const childPath = path ? `${path}.${key}` : key;
+            diffProps(before[key], after[key], childPath, out);
+        }
+        return;
+    }
+    const bothArrays = Array.isArray(before) && Array.isArray(after);
+    if (bothArrays) {
+        const allObjects = before.every((x) => isPlainObject(x)) &&
+            after.every((x) => isPlainObject(x));
+        if (allObjects) {
+            const maxLen = Math.max(before.length, after.length);
+            for (let i = 0; i < maxLen; i++) {
+                const childPath = `${path}[${i}]`;
+                diffProps(before[i], after[i], childPath, out);
+            }
+            return;
+        }
+        // Arrays of primitives / mixed: emit as a single leaf.
+        out.push({ path, before, after, kind: inferKind(path, before, after) });
+        return;
+    }
+    // Leaf — before !== after by deep equality check above.
+    out.push({ path, before, after, kind: inferKind(path, before, after) });
+}
+function diffBlocks(beforeBlocks, afterBlocks) {
+    const beforeById = new Map();
+    beforeBlocks.forEach((b, i) => beforeById.set(b.id, { block: b, index: i }));
+    const afterById = new Map();
+    afterBlocks.forEach((b, i) => afterById.set(b.id, { block: b, index: i }));
+    const out = [];
+    const seen = new Set();
+    // Iterate in draft (after) order so the diff reads top-to-bottom like the page.
+    for (const [id, { block, index }] of afterById) {
+        seen.add(id);
+        const prev = beforeById.get(id);
+        if (!prev) {
+            out.push({ blockId: id, type: block.type, status: "added", positionAfter: index });
+            continue;
+        }
+        const fieldDiffs = [];
+        // Type change: treat as modified with a synthetic "type" diff so the UI can show it.
+        if (prev.block.type !== block.type) {
+            fieldDiffs.push({ path: "type", before: prev.block.type, after: block.type, kind: "other" });
+        }
+        diffProps(prev.block.props, block.props, "", fieldDiffs);
+        const moved = prev.index !== index;
+        const changed = fieldDiffs.length > 0;
+        if (!moved && !changed) {
+            out.push({ blockId: id, type: block.type, status: "unchanged", positionBefore: prev.index, positionAfter: index });
+            continue;
+        }
+        out.push({
+            blockId: id,
+            type: block.type,
+            status: changed ? "modified" : "moved",
+            fieldDiffs: changed ? fieldDiffs : undefined,
+            positionBefore: prev.index,
+            positionAfter: index,
+        });
+    }
+    // Removed blocks — in published but not in draft.
+    for (const [id, { block, index }] of beforeById) {
+        if (seen.has(id))
+            continue;
+        out.push({ blockId: id, type: block.type, status: "removed", positionBefore: index });
+    }
+    return out;
+}
+function diffPage(before, after) {
+    if (!before && !after)
+        return null;
+    if (!before && after) {
+        return {
+            slug: after.slug,
+            status: "added",
+            titleAfter: after.title,
+            blockDiffs: after.blocks.map((b, i) => ({
+                blockId: b.id,
+                type: b.type,
+                status: "added",
+                positionAfter: i,
+            })),
+        };
+    }
+    if (before && !after) {
+        return {
+            slug: before.slug,
+            status: "removed",
+            titleBefore: before.title,
+            blockDiffs: before.blocks.map((b, i) => ({
+                blockId: b.id,
+                type: b.type,
+                status: "removed",
+                positionBefore: i,
+            })),
+        };
+    }
+    const b = before;
+    const a = after;
+    const blockDiffs = diffBlocks(b.blocks, a.blocks);
+    const titleChanged = b.title !== a.title;
+    const hasStructuralChange = blockDiffs.some((bd) => bd.status !== "unchanged");
+    return {
+        slug: a.slug,
+        status: titleChanged || hasStructuralChange ? "modified" : "unchanged",
+        titleBefore: titleChanged ? b.title : undefined,
+        titleAfter: titleChanged ? a.title : undefined,
+        blockDiffs,
+    };
+}
+// Keys of SiteConfig that drive the rendered SiteHeader chrome. We diff
+// only these to keep the publish UI focused on user-visible header changes;
+// `purpose`, `tone`, `constraints`, `themeOverrides` are AI/style context
+// that lives outside the published chrome (and shouldn't trigger a publish CTA).
+const SITE_HEADER_KEYS = ["name", "logo", "navLabels", "navGroups"];
+function pickHeaderFields(config) {
+    const out = {};
+    if (!config)
+        return out;
+    for (const key of SITE_HEADER_KEYS) {
+        const value = config[key];
+        if (value === undefined)
+            continue;
+        out[key] = value;
+    }
+    return out;
+}
+function emitMapDiff(rootKey, before, after, out) {
+    if (deepEqual(before, after))
+        return;
+    const keys = new Set([...Object.keys(before ?? {}), ...Object.keys(after ?? {})]);
+    for (const key of keys) {
+        const b = before?.[key];
+        const a = after?.[key];
+        if (deepEqual(b, a))
+            continue;
+        out.push({
+            path: `${rootKey}["${key}"]`,
+            before: b,
+            after: a,
+            kind: "other",
+        });
+    }
+}
+function diffSiteConfig(before, after) {
+    const beforeHeader = pickHeaderFields(before);
+    const afterHeader = pickHeaderFields(after);
+    const beforeEmpty = Object.keys(beforeHeader).length === 0;
+    const afterEmpty = Object.keys(afterHeader).length === 0;
+    if (beforeEmpty && afterEmpty) {
+        return { status: "unchanged", fieldDiffs: [] };
+    }
+    const fieldDiffs = [];
+    // Scalars: name, logo
+    if (!deepEqual(beforeHeader.name, afterHeader.name)) {
+        fieldDiffs.push({ path: "name", before: beforeHeader.name, after: afterHeader.name, kind: "text" });
+    }
+    if (!deepEqual(beforeHeader.logo, afterHeader.logo)) {
+        fieldDiffs.push({ path: "logo", before: beforeHeader.logo, after: afterHeader.logo, kind: "image" });
+    }
+    // Maps: navLabels (slug→label), navGroups (label→slug[])
+    emitMapDiff("navLabels", beforeHeader.navLabels, afterHeader.navLabels, fieldDiffs);
+    emitMapDiff("navGroups", beforeHeader.navGroups, afterHeader.navGroups, fieldDiffs);
+    if (fieldDiffs.length === 0)
+        return { status: "unchanged", fieldDiffs: [] };
+    // "added" / "removed" are useful signals when the entire chrome appears or
+    // disappears at once (e.g. first publish, or a site reset). Otherwise it's
+    // a `modified`.
+    if (beforeEmpty)
+        return { status: "added", fieldDiffs };
+    if (afterEmpty)
+        return { status: "removed", fieldDiffs };
+    return { status: "modified", fieldDiffs };
+}
+/**
+ * Compare drafts to published and produce a structured diff. Pages are
+ * matched by slug. Within a page, blocks are matched by id.
+ *
+ * The resulting `pages` list is ordered: changed pages first (added →
+ * modified → removed), unchanged last. This lets the UI collapse noise.
+ */
+export function computePublishDiff(draft, published, options) {
+    const draftBySlug = new Map();
+    for (const p of draft)
+        draftBySlug.set(p.slug, p);
+    const publishedBySlug = new Map();
+    for (const p of published)
+        publishedBySlug.set(p.slug, p);
+    const allSlugs = new Set([...draftBySlug.keys(), ...publishedBySlug.keys()]);
+    const pageDiffs = [];
+    let pagesAdded = 0;
+    let pagesRemoved = 0;
+    let pagesModified = 0;
+    let pagesUnchanged = 0;
+    let totalChangedFields = 0;
+    for (const slug of allSlugs) {
+        const diff = diffPage(publishedBySlug.get(slug), draftBySlug.get(slug));
+        if (!diff)
+            continue;
+        pageDiffs.push(diff);
+        switch (diff.status) {
+            case "added":
+                pagesAdded++;
+                break;
+            case "removed":
+                pagesRemoved++;
+                break;
+            case "modified":
+                pagesModified++;
+                break;
+            case "unchanged":
+                pagesUnchanged++;
+                break;
+        }
+        for (const bd of diff.blockDiffs) {
+            if (bd.fieldDiffs)
+                totalChangedFields += bd.fieldDiffs.length;
+        }
+    }
+    const statusOrder = {
+        added: 0,
+        modified: 1,
+        removed: 2,
+        unchanged: 3,
+    };
+    pageDiffs.sort((x, y) => {
+        const s = statusOrder[x.status] - statusOrder[y.status];
+        if (s !== 0)
+            return s;
+        return x.slug.localeCompare(y.slug);
+    });
+    const siteConfig = diffSiteConfig(options?.publishedSiteConfig, options?.draftSiteConfig);
+    return {
+        summary: {
+            pagesAdded,
+            pagesRemoved,
+            pagesModified,
+            pagesUnchanged,
+            totalChangedFields,
+            siteConfigChangedFields: siteConfig.fieldDiffs.length,
+        },
+        pages: pageDiffs,
+        siteConfig,
+    };
+}

package/dist/publish/publish-helpers.d.ts

@@ -0,0 +1,87 @@
+import type { Logger } from "../logger.ts";
+import { type PageDoc } from "@avocadostudio-ai/shared";
+import { type PublishTracker } from "../state/session-state.ts";
+export declare function deploymentIdFromAny(input: string): string | undefined;
+export declare function refreshPublishStatusFromVercel(current: PublishTracker): Promise<PublishTracker>;
+export declare function requirePublishToken(request: {
+    headers: Record<string, unknown>;
+}): boolean;
+export type SnapshotDescriptor = {
+    commit: string;
+    committedAt: string;
+    message: string;
+    pageCount: number;
+    homeHeading: string;
+};
+export declare function loadPublishedSnapshotFromCommit(commit: string): Promise<PageDoc[]>;
+export declare function listRestoreSnapshots(limit?: number, siteId?: string): Promise<SnapshotDescriptor[]>;
+/**
+ * Delete a publish snapshot by reverting its git commit.
+ * Uses `git revert --no-commit` + `git commit` to keep history linear.
+ * Returns true if the revert succeeded, false otherwise.
+ */
+export declare function deletePublishSnapshot(commit: string): Promise<boolean>;
+export declare function isTemplateFallbackSession(sessionDraft: Map<string, PageDoc>): boolean;
+export declare function ensurePresetRestoreSessions(log: Logger): Promise<void>;
+export declare function findLocalhostImageUrls(pages: PageDoc[]): Map<string, string>;
+export type InlineAsset = {
+    /** base64-encoded image bytes */
+    data: string;
+    /** MIME type, e.g. "image/png" */
+    mimeType: string;
+    /** Original filename */
+    fileName: string;
+};
+/**
+ * Collect generated/gdrive images referenced by localhost URLs in pages,
+ * read them from disk, and return a map of originalUrl → base64 InlineAsset.
+ * Missing files are silently skipped.
+ */
+export declare function collectInlineAssets(pages: PageDoc[], generatedImageDir: string): Promise<Record<string, InlineAsset>>;
+/**
+ * Record a publish snapshot in git history (commit only, no push).
+ * Used after site-contract publishes so version history can find them.
+ * Best-effort: failures are silently ignored.
+ */
+export declare function recordPublishSnapshot(session: string, pages: PageDoc[], log?: Logger, siteConfig?: Record<string, unknown>): Promise<string | undefined>;
+export declare function publishViaGit(session: string): Promise<{
+    status: "failed";
+    session: string;
+    slugs: string[];
+    reason: string;
+    details: string[];
+    branch?: undefined;
+    message?: undefined;
+    commitSha?: undefined;
+    vercelState?: undefined;
+} | {
+    status: "ready";
+    session: string;
+    slugs: string[];
+    branch: string;
+    message: string;
+    reason?: undefined;
+    details?: undefined;
+    commitSha?: undefined;
+    vercelState?: undefined;
+} | {
+    status: "triggered";
+    session: string;
+    slugs: string[];
+    branch: string;
+    commitSha: string | undefined;
+    vercelState: string;
+    reason?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    status: "failed";
+    session: string;
+    slugs: string[];
+    branch: string;
+    commitSha: string | undefined;
+    reason: string;
+    details: string[];
+    message?: undefined;
+    vercelState?: undefined;
+}>;