@embeddables/cli 0.9.5 → 0.10.0

package/dist/commands/diff.js

@@ -0,0 +1,738 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import pc from 'picocolors';
+import { compileAllPages } from '../compiler/index.js';
+import { getAccessToken } from '../auth/index.js';
+import { captureException, createLogger, exit } from '../logger.js';
+import * as stdout from '../stdout.js';
+import { inferEmbeddableFromCwd } from '../helpers/utils.js';
+import { promptForLocalEmbeddable } from '../prompts/index.js';
+import { getSentryContextFromEmbeddableConfig, getSentryContextFromProjectConfig, setSentryContext, } from '../sentry-context.js';
+// ─── Stable serialization (key-order-independent) ─────────────────────────────
+/**
+ * JSON.stringify with sorted object keys at every nesting level.
+ * Produces identical output for semantically equal objects regardless of
+ * property insertion order, while preserving array element order.
+ */
+export function stableStringify(value) {
+    return JSON.stringify(value, (_key, val) => {
+        if (val && typeof val === 'object' && !Array.isArray(val)) {
+            const sorted = {};
+            for (const k of Object.keys(val).sort()) {
+                sorted[k] = val[k];
+            }
+            return sorted;
+        }
+        return val;
+    });
+}
+function createColorizer(useColor) {
+    if (!useColor) {
+        const id = (s) => s;
+        return { red: id, green: id, yellow: id, gray: id, bold: id, cyan: id, dim: id, white: id };
+    }
+    return pc;
+}
+// ─── Normalization (same as inspect/pull) ─────────────────────────────────────
+function normalizeCustomValidationFunctionsInFlow(flow) {
+    function walkComponent(comp) {
+        const v = comp.custom_validation_function;
+        if (typeof v === 'string') {
+            comp.custom_validation_function = v.replace(/\\n/g, '\n');
+        }
+        const children = comp.components ?? comp.buttons;
+        if (Array.isArray(children)) {
+            for (const c of children) {
+                if (c && typeof c === 'object')
+                    walkComponent(c);
+            }
+        }
+    }
+    const pages = flow.pages;
+    if (Array.isArray(pages)) {
+        for (const page of pages) {
+            if (page && typeof page === 'object' && Array.isArray(page.components)) {
+                for (const comp of page.components) {
+                    if (comp && typeof comp === 'object')
+                        walkComponent(comp);
+                }
+            }
+        }
+    }
+    const components = flow.components;
+    if (Array.isArray(components)) {
+        for (const comp of components) {
+            if (comp && typeof comp === 'object')
+                walkComponent(comp);
+        }
+    }
+}
+// ─── Version specifier parsing ────────────────────────────────────────────────
+const NAMED_SPECIFIERS = new Set(['local', 'latest', 'staging', 'prod']);
+function parseBaseVersion(raw) {
+    const lower = raw.toLowerCase().trim();
+    if (NAMED_SPECIFIERS.has(lower))
+        return lower;
+    const num = parseInt(lower, 10);
+    if (!isNaN(num) && String(num) === lower)
+        return String(num);
+    throw new Error(`Invalid version specifier: "${raw}". Use a version number, "latest", "staging", "prod", or "local". Prefix with branch@ to target a specific branch.`);
+}
+export function parseVersionSpecifier(spec) {
+    const trimmed = spec.trim();
+    const atIndex = trimmed.lastIndexOf('@');
+    if (atIndex > 0) {
+        const branch = trimmed.slice(0, atIndex);
+        const versionPart = trimmed.slice(atIndex + 1);
+        const version = parseBaseVersion(versionPart);
+        if (version === 'local') {
+            throw new Error(`Cannot use "local" with a branch specifier: "${spec}". "local" always compiles from local files.`);
+        }
+        return { version, branch };
+    }
+    return { version: parseBaseVersion(trimmed) };
+}
+export function versionLabel(spec) {
+    const base = NAMED_SPECIFIERS.has(spec.version) ? spec.version : `v${spec.version}`;
+    if (spec.branch)
+        return `${spec.branch}@${base}`;
+    return base;
+}
+// ─── Version resolution ───────────────────────────────────────────────────────
+export async function resolveLocalVersion(embeddableId) {
+    const pagesGlob = `embeddables/${embeddableId}/pages/**/*.page.tsx`;
+    const outPath = path.join('embeddables', embeddableId, '.generated', 'embeddable-diff-local.json');
+    const stylesDir = path.join('embeddables', embeddableId, 'styles');
+    await compileAllPages({
+        pagesGlob,
+        outPath,
+        pageKeyFrom: 'filename',
+        stylesDir,
+        embeddableId,
+        fixLint: true,
+    });
+    const content = fs.readFileSync(outPath, 'utf8');
+    try {
+        fs.unlinkSync(outPath);
+    }
+    catch {
+        /* ignore cleanup errors */
+    }
+    return JSON.parse(content);
+}
+export async function fetchCloudVersion(embeddableId, version, opts) {
+    const engineOrigin = opts.engine || 'https://engine.embeddables.com';
+    let url = `${engineOrigin}/${embeddableId}?version=${version}`;
+    if (opts.branch)
+        url += `&embeddable_branch=${opts.branch}`;
+    const accessToken = getAccessToken();
+    const headers = {};
+    if (accessToken) {
+        headers['Authorization'] = `Bearer ${accessToken}`;
+    }
+    const response = await fetch(url, { headers });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch version "${version}": ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (!data.flow) {
+        throw new Error(`Response for version "${version}" does not contain a 'flow' property`);
+    }
+    const flow = data.flow;
+    normalizeCustomValidationFunctionsInFlow(flow);
+    return flow;
+}
+async function resolveVersion(spec, embeddableId, opts) {
+    if (spec === 'local')
+        return resolveLocalVersion(embeddableId);
+    return fetchCloudVersion(embeddableId, spec, opts);
+}
+// ─── Diff computation ─────────────────────────────────────────────────────────
+export function computeDiff(from, to, depth, filters = { page: null, component: null }) {
+    const pages = diffPages(from, to, depth, filters);
+    const globalComponents = diffGlobalComponents(from, to, depth, filters);
+    const sections = diffOtherSections(from, to);
+    const summary = computeSummary(pages, globalComponents);
+    return { pages, globalComponents, sections, summary };
+}
+function diffPages(from, to, depth, filters) {
+    const fromPages = (Array.isArray(from.pages) ? from.pages : []);
+    const toPages = (Array.isArray(to.pages) ? to.pages : []);
+    const fromByKey = new Map();
+    for (const p of fromPages)
+        fromByKey.set(p.key ?? p.id, p);
+    const toByKey = new Map();
+    for (const p of toPages)
+        toByKey.set(p.key ?? p.id, p);
+    const diffs = [];
+    for (const [key, page] of fromByKey) {
+        if (!toByKey.has(key)) {
+            if (!pageMatchesFilter(filters.page, key, page))
+                continue;
+            const diff = { key, title: page.title, status: 'removed' };
+            if (depth !== 'pages' && Array.isArray(page.components)) {
+                diff.components = page.components
+                    .map((comp) => ({
+                    id: comp.id,
+                    key: comp.key,
+                    type: comp.type,
+                    status: 'removed',
+                }))
+                    .filter((comp) => componentMatchesFilter(filters.component, comp));
+            }
+            if (shouldIncludePageDiff(diff, depth, filters)) {
+                diffs.push(diff);
+            }
+        }
+    }
+    for (const [key, page] of toByKey) {
+        if (!fromByKey.has(key)) {
+            if (!pageMatchesFilter(filters.page, key, page))
+                continue;
+            const diff = { key, title: page.title, status: 'added' };
+            if (depth !== 'pages' && Array.isArray(page.components)) {
+                diff.components = page.components
+                    .map((comp) => ({
+                    id: comp.id,
+                    key: comp.key,
+                    type: comp.type,
+                    status: 'added',
+                    ...(depth === 'props'
+                        ? {
+                            props: Object.entries(comp)
+                                .filter(([k]) => !['id', 'key', 'type', 'tags', 'components', 'buttons'].includes(k))
+                                .map(([name, value]) => ({
+                                name,
+                                status: 'added',
+                                to: value,
+                            })),
+                        }
+                        : {}),
+                }))
+                    .filter((comp) => componentMatchesFilter(filters.component, comp));
+            }
+            if (shouldIncludePageDiff(diff, depth, filters)) {
+                diffs.push(diff);
+            }
+        }
+    }
+    for (const [key, fromPage] of fromByKey) {
+        const toPage = toByKey.get(key);
+        if (!toPage)
+            continue;
+        if (stableStringify(fromPage) === stableStringify(toPage))
+            continue;
+        if (!pageMatchesFilter(filters.page, key, fromPage, toPage))
+            continue;
+        const diff = {
+            key,
+            title: toPage.title ?? fromPage.title,
+            status: 'modified',
+        };
+        if (depth !== 'pages') {
+            diff.components = diffComponentArrays(Array.isArray(fromPage.components) ? fromPage.components : [], Array.isArray(toPage.components) ? toPage.components : [], depth, filters);
+        }
+        if (shouldIncludePageDiff(diff, depth, filters)) {
+            diffs.push(diff);
+        }
+    }
+    return diffs;
+}
+function shouldIncludePageDiff(diff, depth, filters) {
+    if (depth === 'pages')
+        return true;
+    if (!filters.component)
+        return true;
+    return (diff.components?.length ?? 0) > 0;
+}
+function componentMatchesFilter(componentFilter, comp) {
+    if (!componentFilter)
+        return true;
+    if (typeof comp.id === 'string' && componentFilter.has(comp.id))
+        return true;
+    if (typeof comp.key === 'string' && componentFilter.has(comp.key))
+        return true;
+    return false;
+}
+function pageMatchesFilter(pageFilter, pageKey, fromPage, toPage) {
+    if (!pageFilter)
+        return true;
+    if (pageFilter.has(pageKey))
+        return true;
+    const fromId = typeof fromPage?.id === 'string' ? fromPage.id : null;
+    const toId = typeof toPage?.id === 'string' ? toPage.id : null;
+    return (fromId !== null && pageFilter.has(fromId)) || (toId !== null && pageFilter.has(toId));
+}
+function diffComponentArrays(fromComps, toComps, depth, filters) {
+    const fromById = new Map();
+    for (const c of fromComps)
+        fromById.set(c.id, c);
+    const toById = new Map();
+    for (const c of toComps)
+        toById.set(c.id, c);
+    const diffs = [];
+    for (const [id, comp] of fromById) {
+        if (!toById.has(id)) {
+            const diff = { id, key: comp.key, type: comp.type, status: 'removed' };
+            if (componentMatchesFilter(filters.component, diff)) {
+                diffs.push(diff);
+            }
+        }
+    }
+    for (const [id, comp] of toById) {
+        if (!fromById.has(id)) {
+            const diff = { id, key: comp.key, type: comp.type, status: 'added' };
+            if (depth === 'props') {
+                diff.props = Object.entries(comp)
+                    .filter(([k]) => !['id', 'key', 'type', 'tags', 'components', 'buttons'].includes(k))
+                    .map(([name, value]) => ({ name, status: 'added', to: value }));
+            }
+            if (componentMatchesFilter(filters.component, diff)) {
+                diffs.push(diff);
+            }
+        }
+    }
+    for (const [id, fromComp] of fromById) {
+        const toComp = toById.get(id);
+        if (!toComp)
+            continue;
+        if (stableStringify(fromComp) === stableStringify(toComp))
+            continue;
+        const diff = {
+            id,
+            key: toComp.key ?? fromComp.key,
+            type: toComp.type ?? fromComp.type,
+            status: 'modified',
+        };
+        if (depth === 'props') {
+            diff.props = diffProps(fromComp, toComp);
+        }
+        if (componentMatchesFilter(filters.component, diff)) {
+            diffs.push(diff);
+        }
+    }
+    return diffs;
+}
+const COMPONENT_META_KEYS = new Set(['id', 'key', 'type', 'tags', 'components', 'buttons']);
+function diffProps(fromComp, toComp) {
+    const allKeys = new Set([...Object.keys(fromComp), ...Object.keys(toComp)]);
+    const diffs = [];
+    for (const key of allKeys) {
+        if (COMPONENT_META_KEYS.has(key))
+            continue;
+        const inFrom = key in fromComp;
+        const inTo = key in toComp;
+        if (!inFrom && inTo) {
+            diffs.push({ name: key, status: 'added', to: toComp[key] });
+        }
+        else if (inFrom && !inTo) {
+            diffs.push({ name: key, status: 'removed', from: fromComp[key] });
+        }
+        else if (stableStringify(fromComp[key]) !== stableStringify(toComp[key])) {
+            diffs.push({ name: key, status: 'changed', from: fromComp[key], to: toComp[key] });
+        }
+    }
+    return diffs;
+}
+function diffGlobalComponents(from, to, depth, filters) {
+    if (depth === 'pages')
+        return [];
+    const fromComps = (Array.isArray(from.components) ? from.components : []);
+    const toComps = (Array.isArray(to.components) ? to.components : []);
+    if (fromComps.length === 0 && toComps.length === 0)
+        return [];
+    return diffComponentArrays(fromComps, toComps, depth, filters);
+}
+function diffOtherSections(from, to) {
+    const skipKeys = new Set(['pages', 'components']);
+    const allKeys = new Set([...Object.keys(from), ...Object.keys(to)]);
+    const sections = [];
+    for (const key of allKeys) {
+        if (skipKeys.has(key))
+            continue;
+        const inFrom = key in from;
+        const inTo = key in to;
+        if (!inFrom && inTo) {
+            sections.push({ name: key, status: 'added' });
+        }
+        else if (inFrom && !inTo) {
+            sections.push({ name: key, status: 'removed' });
+        }
+        else if (stableStringify(from[key]) !== stableStringify(to[key])) {
+            sections.push({ name: key, status: 'modified', from: from[key], to: to[key] });
+        }
+    }
+    return sections;
+}
+function computeSummary(pages, globalComponents) {
+    const summary = {
+        pagesAdded: 0,
+        pagesRemoved: 0,
+        pagesModified: 0,
+        componentsAdded: 0,
+        componentsRemoved: 0,
+        componentsModified: 0,
+        propsAdded: 0,
+        propsRemoved: 0,
+        propsChanged: 0,
+    };
+    function countComponent(comp) {
+        if (comp.status === 'added')
+            summary.componentsAdded++;
+        else if (comp.status === 'removed')
+            summary.componentsRemoved++;
+        else
+            summary.componentsModified++;
+        if (comp.props) {
+            for (const prop of comp.props) {
+                if (prop.status === 'added')
+                    summary.propsAdded++;
+                else if (prop.status === 'removed')
+                    summary.propsRemoved++;
+                else
+                    summary.propsChanged++;
+            }
+        }
+    }
+    for (const page of pages) {
+        if (page.status === 'added')
+            summary.pagesAdded++;
+        else if (page.status === 'removed')
+            summary.pagesRemoved++;
+        else
+            summary.pagesModified++;
+        if (page.components) {
+            for (const comp of page.components)
+                countComponent(comp);
+        }
+    }
+    for (const comp of globalComponents)
+        countComponent(comp);
+    return summary;
+}
+// ─── Display formatting ──────────────────────────────────────────────────────
+function formatValue(value) {
+    if (value === null || value === undefined)
+        return 'null';
+    if (typeof value === 'string') {
+        if (value.length > 50)
+            return `"${value.slice(0, 47)}..."`;
+        return `"${value}"`;
+    }
+    if (typeof value === 'boolean' || typeof value === 'number')
+        return String(value);
+    if (Array.isArray(value))
+        return `[${value.length} item${value.length !== 1 ? 's' : ''}]`;
+    if (typeof value === 'object') {
+        const keys = Object.keys(value);
+        return `{${keys.length} key${keys.length !== 1 ? 's' : ''}}`;
+    }
+    return String(value);
+}
+export function renderDiff(diff, depth, c) {
+    const lines = [];
+    const hasChanges = diff.pages.length > 0 || diff.globalComponents.length > 0 || diff.sections.length > 0;
+    if (!hasChanges) {
+        lines.push('');
+        lines.push(`  ${c.green('No differences found.')}`);
+        return lines;
+    }
+    for (const page of diff.pages) {
+        lines.push('');
+        renderPage(page, depth, c, lines);
+    }
+    if (diff.globalComponents.length > 0) {
+        lines.push('');
+        lines.push(`  ${c.bold('Global Components:')}`);
+        for (const comp of diff.globalComponents) {
+            renderComponentLine(comp, depth, c, lines, '  ');
+        }
+    }
+    if (diff.sections.length > 0) {
+        lines.push('');
+        lines.push(`  ${c.bold('Other changes:')}`);
+        for (const section of diff.sections) {
+            const icon = section.status === 'added'
+                ? c.green('+')
+                : section.status === 'removed'
+                    ? c.red('-')
+                    : c.yellow('~');
+            const name = section.status === 'added'
+                ? c.green(section.name)
+                : section.status === 'removed'
+                    ? c.red(section.name)
+                    : c.yellow(section.name);
+            if (section.status === 'modified') {
+                lines.push(`    ${icon} ${name}: ${c.yellow(`${formatValue(section.from)} → ${formatValue(section.to)}`)}`);
+            }
+            else {
+                lines.push(`    ${icon} ${name}`);
+            }
+        }
+    }
+    lines.push('');
+    lines.push(renderSummary(diff.summary, depth, c));
+    return lines;
+}
+function renderPage(page, depth, c, lines) {
+    const label = page.title ? `${page.key} "${page.title}"` : page.key;
+    if (page.status === 'added') {
+        const compCount = page.components?.length ?? 0;
+        const detail = depth !== 'pages' && compCount > 0 ? c.dim(` (${compCount} components)`) : '';
+        lines.push(`  ${c.green(`+ Page: ${label}`)}${detail}`);
+        if (depth === 'props' && page.components) {
+            for (const comp of page.components) {
+                renderComponentLine(comp, depth, c, lines, '  ');
+            }
+        }
+    }
+    else if (page.status === 'removed') {
+        const compCount = page.components?.length ?? 0;
+        const detail = depth !== 'pages' && compCount > 0 ? c.dim(` (${compCount} components)`) : '';
+        lines.push(`  ${c.red(`- Page: ${label}`)}${detail}`);
+    }
+    else {
+        lines.push(`  ${c.yellow(`~ Page: ${label}`)}`);
+        if (page.components && depth !== 'pages') {
+            for (const comp of page.components) {
+                renderComponentLine(comp, depth, c, lines, '  ');
+            }
+        }
+    }
+}
+function renderComponentLine(comp, depth, c, lines, indent) {
+    const typeLabel = comp.type ? `${comp.type} ` : '';
+    const keyLabel = comp.key ? `"${comp.key}"` : comp.id;
+    if (comp.status === 'added') {
+        lines.push(`${indent}    ${c.green(`+ ${typeLabel}${keyLabel}`)}`);
+        if (depth === 'props' && comp.props) {
+            for (const prop of comp.props) {
+                renderPropLine(prop, c, lines, indent + '    ');
+            }
+        }
+    }
+    else if (comp.status === 'removed') {
+        lines.push(`${indent}    ${c.red(`- ${typeLabel}${keyLabel}`)}`);
+    }
+    else {
+        lines.push(`${indent}    ${c.yellow(`~ ${typeLabel}${keyLabel}`)}`);
+        if (depth === 'props' && comp.props) {
+            for (const prop of comp.props) {
+                renderPropLine(prop, c, lines, indent + '    ');
+            }
+        }
+    }
+}
+function renderPropLine(prop, c, lines, indent) {
+    if (prop.status === 'added') {
+        lines.push(`${indent}    ${c.green(`+ ${prop.name}: ${formatValue(prop.to)}`)}`);
+    }
+    else if (prop.status === 'removed') {
+        lines.push(`${indent}    ${c.red(`- ${prop.name}: ${formatValue(prop.from)}`)}`);
+    }
+    else {
+        lines.push(`${indent}    ${c.yellow(`~ ${prop.name}: ${formatValue(prop.from)} → ${formatValue(prop.to)}`)}`);
+    }
+}
+function renderSummary(summary, depth, c) {
+    const parts = [];
+    const totalPages = summary.pagesAdded + summary.pagesRemoved + summary.pagesModified;
+    if (totalPages > 0) {
+        const details = [];
+        if (summary.pagesModified > 0)
+            details.push(`${summary.pagesModified} modified`);
+        if (summary.pagesAdded > 0)
+            details.push(`${summary.pagesAdded} added`);
+        if (summary.pagesRemoved > 0)
+            details.push(`${summary.pagesRemoved} removed`);
+        parts.push(`${totalPages} page${totalPages !== 1 ? 's' : ''} changed (${details.join(', ')})`);
+    }
+    if (depth !== 'pages') {
+        const totalComps = summary.componentsAdded + summary.componentsRemoved + summary.componentsModified;
+        if (totalComps > 0) {
+            const details = [];
+            if (summary.componentsModified > 0)
+                details.push(`${summary.componentsModified} modified`);
+            if (summary.componentsAdded > 0)
+                details.push(`${summary.componentsAdded} added`);
+            if (summary.componentsRemoved > 0)
+                details.push(`${summary.componentsRemoved} removed`);
+            parts.push(`${totalComps} component${totalComps !== 1 ? 's' : ''} (${details.join(', ')})`);
+        }
+    }
+    if (depth === 'props') {
+        const totalProps = summary.propsAdded + summary.propsRemoved + summary.propsChanged;
+        if (totalProps > 0) {
+            const details = [];
+            if (summary.propsChanged > 0)
+                details.push(`${summary.propsChanged} changed`);
+            if (summary.propsAdded > 0)
+                details.push(`${summary.propsAdded} added`);
+            if (summary.propsRemoved > 0)
+                details.push(`${summary.propsRemoved} removed`);
+            parts.push(`${totalProps} prop${totalProps !== 1 ? 's' : ''} (${details.join(', ')})`);
+        }
+    }
+    if (parts.length === 0)
+        return `  ${c.dim('No structural differences.')}`;
+    return `  ${c.bold('Summary:')} ${parts.join(', ')}`;
+}
+// ─── Config helper ────────────────────────────────────────────────────────────
+function getBranchFromConfig(embeddableId) {
+    const configPath = path.join('embeddables', embeddableId, 'config.json');
+    if (!fs.existsSync(configPath))
+        return null;
+    try {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        const branchId = config._branch_id;
+        if (typeof branchId !== 'string' || !branchId)
+            return null;
+        const branchName = config._branch_name;
+        return { branchId, branchName: typeof branchName === 'string' ? branchName : undefined };
+    }
+    catch {
+        return null;
+    }
+}
+// ─── Main entry point ─────────────────────────────────────────────────────────
+export async function runDiff(opts) {
+    const logger = createLogger('runDiff');
+    const totalTimer = stdout.timer();
+    const fromSpec = parseVersionSpecifier(opts.from || 'local');
+    const toSpec = parseVersionSpecifier(opts.to || 'latest');
+    const depth = opts.depth || 'components';
+    const useColor = opts.color !== false;
+    const c = createColorizer(useColor);
+    const filters = {
+        page: parseCsvFilter(opts.page),
+        component: parseCsvFilter(opts.component),
+    };
+    const inferred = inferEmbeddableFromCwd();
+    let embeddableId = opts.id ?? inferred?.embeddableId;
+    if (inferred && !opts.id && embeddableId) {
+        process.chdir(inferred.projectRoot);
+    }
+    setSentryContext(getSentryContextFromProjectConfig());
+    if (!embeddableId) {
+        const selected = await promptForLocalEmbeddable({
+            message: 'Select an embeddable to diff:',
+        });
+        if (!selected) {
+            logger.error('no embeddable selected');
+            await exit(1);
+            return;
+        }
+        embeddableId = selected;
+    }
+    if (embeddableId) {
+        setSentryContext({
+            embeddable: { id: embeddableId },
+            ...getSentryContextFromEmbeddableConfig(embeddableId),
+        });
+    }
+    const currentBranch = opts.branch ? null : getBranchFromConfig(embeddableId);
+    const defaultBranch = opts.branch ?? currentBranch?.branchId;
+    const defaultBranchName = currentBranch?.branchName;
+    const fromBranch = fromSpec.branch ?? defaultBranch;
+    const toBranch = toSpec.branch ?? defaultBranch;
+    const branchesMatch = fromBranch === toBranch;
+    const branchLabel = branchesMatch
+        ? fromBranch
+            ? defaultBranchName && !fromSpec.branch
+                ? `${defaultBranchName} (${fromBranch})`
+                : fromBranch
+            : 'main'
+        : null;
+    if (defaultBranch) {
+        setSentryContext({ branch: { id: defaultBranch, name: defaultBranchName ?? null } });
+    }
+    const fromLabel = versionLabel(fromSpec);
+    const toLabel = versionLabel(toSpec);
+    const subtitle = branchLabel
+        ? `Embeddable: ${embeddableId} \u00b7 Branch: ${branchLabel} \u00b7 Depth: ${depth}`
+        : `Embeddable: ${embeddableId} \u00b7 Depth: ${depth}`;
+    stdout.header(`Diff: ${fromLabel} \u2194 ${toLabel}`, subtitle);
+    let fromJson;
+    let toJson;
+    try {
+        const fromResolveOpts = { engine: opts.engine, branch: fromBranch };
+        const toResolveOpts = { engine: opts.engine, branch: toBranch };
+        if (fromSpec.version === 'local' && toSpec.version === 'local') {
+            fromJson = await stdout.withSpinner('Compiling local files\u2026', async () => {
+                stdout.mute();
+                try {
+                    return await resolveVersion('local', embeddableId, fromResolveOpts);
+                }
+                finally {
+                    stdout.unmute();
+                }
+            }, { successText: 'Local files compiled' });
+            toJson = fromJson;
+        }
+        else if (fromSpec.version !== 'local' && toSpec.version !== 'local') {
+            const [from, to] = await stdout.withSpinner(`Fetching ${fromLabel} and ${toLabel}\u2026`, async () => Promise.all([
+                resolveVersion(fromSpec.version, embeddableId, fromResolveOpts),
+                resolveVersion(toSpec.version, embeddableId, toResolveOpts),
+            ]), { successText: 'Both versions fetched' });
+            fromJson = from;
+            toJson = to;
+        }
+        else if (fromSpec.version === 'local') {
+            fromJson = await stdout.withSpinner('Compiling local files\u2026', async () => {
+                stdout.mute();
+                try {
+                    return await resolveVersion('local', embeddableId, fromResolveOpts);
+                }
+                finally {
+                    stdout.unmute();
+                }
+            }, { successText: 'Local files compiled' });
+            toJson = await stdout.withSpinner(`Fetching ${toLabel}\u2026`, async () => resolveVersion(toSpec.version, embeddableId, toResolveOpts), { successText: `Fetched ${toLabel}` });
+        }
+        else {
+            fromJson = await stdout.withSpinner(`Fetching ${fromLabel}\u2026`, async () => resolveVersion(fromSpec.version, embeddableId, fromResolveOpts), { successText: `Fetched ${fromLabel}` });
+            toJson = await stdout.withSpinner('Compiling local files\u2026', async () => {
+                stdout.mute();
+                try {
+                    return await resolveVersion('local', embeddableId, toResolveOpts);
+                }
+                finally {
+                    stdout.unmute();
+                }
+            }, { successText: 'Local files compiled' });
+        }
+    }
+    catch (error) {
+        captureException(error);
+        stdout.error(`Failed to resolve versions: ${error instanceof Error ? error.message : String(error)}`);
+        logger.error('diff version resolution failed', {
+            message: error instanceof Error ? error.message : String(error),
+        });
+        await exit(1);
+        return;
+    }
+    const diff = computeDiff(fromJson, toJson, depth, filters);
+    const output = renderDiff(diff, depth, c);
+    for (const line of output) {
+        stdout.print(line);
+    }
+    stdout.gap();
+    stdout.dim(`  Completed in ${totalTimer()}`);
+    logger.info('diff complete', {
+        from: fromLabel,
+        to: toLabel,
+        depth,
+        embeddableId,
+        branch: branchLabel ?? `${fromBranch ?? 'main'} / ${toBranch ?? 'main'}`,
+    });
+}
+function parseCsvFilter(value) {
+    if (!value)
+        return null;
+    const values = value
+        .split(',')
+        .map((v) => v.trim())
+        .filter((v) => v.length > 0);
+    return values.length > 0 ? new Set(values) : null;
+}
+//# sourceMappingURL=diff.js.map