@sitecoreai-labs/sitecoreai-cli 0.0.4 → 0.1.0

package/dist/brand/kits/sections.d.ts

@@ -0,0 +1,156 @@
+import { type BrandApiClientOptions } from "../api/client";
+/**
+ * Brand kit subsection (field) type, as returned by the API.
+ *   - `text` → free-form string value
+ *   - `array` → list of `{ name }` entries (bulleted lists, dos/don'ts,
+ *     checklist items, palette swatches)
+ *   - `richArray` → list of `{ name, tags[], restrictions }` entries
+ *     (tone scenarios, image-style scenarios — context-tagged guidance)
+ */
+export type BrandKitFieldType = "text" | "array" | "richArray";
+export interface BrandKitArrayEntry {
+    /** The entry's text. Required. */
+    name: string;
+    /** Server-assigned UUID. Omit when writing — the server fills it in. */
+    id?: string;
+}
+export interface BrandKitRichArrayEntry extends BrandKitArrayEntry {
+    /** Free-form tags ("Marketing", "Claims", "Self-Serve", …). */
+    tags?: string[];
+    /** Per-scenario constraints ("Never use scarcity in marketing copy"). */
+    restrictions?: string;
+}
+/**
+ * Value shape varies by `BrandKitFieldType`. Callers writing values
+ * must match the field's type — the server rejects mismatches with
+ * a 422 validation error. Inspect with `listBrandKitFields` first if
+ * you're unsure.
+ */
+export type BrandKitFieldValue = string | BrandKitArrayEntry[] | BrandKitRichArrayEntry[];
+export interface BrandKitSectionSummary {
+    /** Section UUID. */
+    id: string;
+    /** Display name (e.g. "Brand Context", "Tone of Voice"). */
+    name: string;
+    /** Sort order returned by the server. */
+    order?: number;
+    /** Whether the section can be deleted (predefined sections are not). */
+    deletable?: boolean;
+    createdOn?: string;
+    createdBy?: string;
+    updatedOn?: string;
+    updatedBy?: string;
+    deletedAt?: string | null;
+    properties?: unknown;
+    [extra: string]: unknown;
+}
+export interface BrandKitFieldSummary {
+    /** Field UUID. */
+    id: string;
+    /** Display name of the subsection. */
+    name: string;
+    /** Field type — `"text"`, `"array"`, or `"richArray"`. */
+    type?: BrandKitFieldType;
+    /** Sort order within the section. */
+    order?: number;
+    /**
+     * Content value populated by enrichment or operator edits.
+     *
+     * Shape depends on `type`:
+     *   - `text` → string
+     *   - `array` → `{ name: string; id?: string }[]`
+     *   - `richArray` → `{ name: string; tags?: string[]; restrictions?: string; id?: string }[]`
+     *
+     * Empty until the kit's EnrichSectionsPipeline runs, or until a
+     * direct PATCH via `updateBrandKitField` writes a value.
+     */
+    value?: BrandKitFieldValue;
+    /** AI-facing description of what this field is for. */
+    intent?: string;
+    /** Whether the AI Sections enrichment pipeline may overwrite this. */
+    aiEditable?: boolean;
+    /** Whether the field can be deleted. Predefined fields are not. */
+    deletable?: boolean;
+    /** Verification state (null = not verified). */
+    verified?: boolean | null;
+    /** Field-level references, often empty. */
+    references?: unknown[];
+    createdOn?: string;
+    createdBy?: string;
+    updatedOn?: string;
+    updatedBy?: string;
+    properties?: unknown;
+    [extra: string]: unknown;
+}
+export interface ListBrandKitSectionsOptions {
+    client: BrandApiClientOptions;
+    brandKitId: string;
+    signal?: AbortSignal;
+}
+/**
+ * List sections of a brand kit, with names and IDs.
+ *
+ * **Note:** the endpoint returns a bare JSON array (not the
+ * paginated `{ data, totalCount }` envelope `listBrandKits` uses).
+ * Verified empirically 2026-05-14.
+ *
+ * Sections are predefined per kit (Brand Context, Global Goals,
+ * Tone of Voice, Glossary and Localization, plus a few others
+ * created during enrichment). They only appear after the kit's
+ * `EnrichSectionsPipeline` has populated them — a freshly-created
+ * kit returns an empty array.
+ */
+export declare const listBrandKitSections: (options: ListBrandKitSectionsOptions) => Promise<BrandKitSectionSummary[]>;
+export interface ListBrandKitFieldsOptions {
+    client: BrandApiClientOptions;
+    brandKitId: string;
+    sectionId: string;
+    signal?: AbortSignal;
+}
+/**
+ * List subsections (fields) of a section. Like sections, returns a
+ * bare array. Field `value` is empty until enrichment has run; the
+ * `intent` describes what the field is supposed to capture.
+ */
+export declare const listBrandKitFields: (options: ListBrandKitFieldsOptions) => Promise<BrandKitFieldSummary[]>;
+export interface UpdateBrandKitFieldOptions {
+    client: BrandApiClientOptions;
+    brandKitId: string;
+    sectionId: string;
+    fieldId: string;
+    /**
+     * Content value. Shape must match the field's `type` — text for
+     * `text` fields, `BrandKitArrayEntry[]` for `array`,
+     * `BrandKitRichArrayEntry[]` for `richArray`. Omit to leave the
+     * value unchanged.
+     */
+    value?: BrandKitFieldValue;
+    /** Update the AI-facing intent string. Rarely set by operators. */
+    intent?: string;
+    /** Mark the field's content as operator-verified. */
+    verified?: boolean;
+    /** Whether the enrichment pipeline may overwrite this field. */
+    aiEditable?: boolean;
+    /** Reorder within the section. */
+    order?: number;
+    /** Rename the subsection. Only operator-created sections support this. */
+    name?: string;
+    signal?: AbortSignal;
+}
+/**
+ * Partially update a brand kit subsection (field). The reliable path
+ * for populating kits whose source PDF didn't survive Sitecore's AI
+ * ingestion pipeline — see `scai://help/brand-kit-generation` for
+ * when to prefer this over the seed-from-PDF flow.
+ *
+ * Wraps `PATCH /api/brands/v2/.../sections/{sectionId}/fields/{fieldId}`.
+ *
+ * Behavioural notes verified empirically:
+ *   - Only the keys present in the request body are touched; others
+ *     are left alone (true partial update).
+ *   - Server rejects `value` shape that doesn't match the field's
+ *     `type` (e.g. string for an `array` field) with HTTP 422.
+ *   - Returns the updated field with server-assigned `id`s on any
+ *     newly-added array entries.
+ */
+export declare const updateBrandKitField: (options: UpdateBrandKitFieldOptions) => Promise<BrandKitFieldSummary>;

package/dist/brand/kits/sections.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateBrandKitField = exports.listBrandKitFields = exports.listBrandKitSections = void 0;
+const client_1 = require("../api/client");
+const types_1 = require("../api/types");
+/**
+ * List sections of a brand kit, with names and IDs.
+ *
+ * **Note:** the endpoint returns a bare JSON array (not the
+ * paginated `{ data, totalCount }` envelope `listBrandKits` uses).
+ * Verified empirically 2026-05-14.
+ *
+ * Sections are predefined per kit (Brand Context, Global Goals,
+ * Tone of Voice, Glossary and Localization, plus a few others
+ * created during enrichment). They only appear after the kit's
+ * `EnrichSectionsPipeline` has populated them — a freshly-created
+ * kit returns an empty array.
+ */
+const listBrandKitSections = async (options) => {
+    return (0, client_1.requestBrandApi)(options.client, {
+        basePath: types_1.BRAND_MANAGEMENT_BASE_PATH,
+        path: `/api/brands/v1/organizations/${options.client.orgId}/brandkits/${options.brandKitId}/sections`,
+        method: "GET",
+        signal: options.signal,
+    });
+};
+exports.listBrandKitSections = listBrandKitSections;
+/**
+ * List subsections (fields) of a section. Like sections, returns a
+ * bare array. Field `value` is empty until enrichment has run; the
+ * `intent` describes what the field is supposed to capture.
+ */
+const listBrandKitFields = async (options) => {
+    return (0, client_1.requestBrandApi)(options.client, {
+        basePath: types_1.BRAND_MANAGEMENT_BASE_PATH,
+        path: `/api/brands/v2/organizations/${options.client.orgId}/brandkits/${options.brandKitId}/sections/${options.sectionId}/fields`,
+        method: "GET",
+        signal: options.signal,
+    });
+};
+exports.listBrandKitFields = listBrandKitFields;
+/**
+ * Partially update a brand kit subsection (field). The reliable path
+ * for populating kits whose source PDF didn't survive Sitecore's AI
+ * ingestion pipeline — see `scai://help/brand-kit-generation` for
+ * when to prefer this over the seed-from-PDF flow.
+ *
+ * Wraps `PATCH /api/brands/v2/.../sections/{sectionId}/fields/{fieldId}`.
+ *
+ * Behavioural notes verified empirically:
+ *   - Only the keys present in the request body are touched; others
+ *     are left alone (true partial update).
+ *   - Server rejects `value` shape that doesn't match the field's
+ *     `type` (e.g. string for an `array` field) with HTTP 422.
+ *   - Returns the updated field with server-assigned `id`s on any
+ *     newly-added array entries.
+ */
+const updateBrandKitField = async (options) => {
+    const body = {};
+    if (options.value !== undefined)
+        body.value = options.value;
+    if (options.intent !== undefined)
+        body.intent = options.intent;
+    if (options.verified !== undefined)
+        body.verified = options.verified;
+    if (options.aiEditable !== undefined)
+        body.aiEditable = options.aiEditable;
+    if (options.order !== undefined)
+        body.order = options.order;
+    if (options.name !== undefined)
+        body.name = options.name;
+    return (0, client_1.requestBrandApi)(options.client, {
+        basePath: types_1.BRAND_MANAGEMENT_BASE_PATH,
+        path: `/api/brands/v2/organizations/${options.client.orgId}/brandkits/${options.brandKitId}/sections/${options.sectionId}/fields/${options.fieldId}`,
+        method: "PATCH",
+        body,
+        signal: options.signal,
+    });
+};
+exports.updateBrandKitField = updateBrandKitField;

package/dist/brand/pipeline/run.d.ts

@@ -0,0 +1,58 @@
+import { type BrandApiClientOptions } from "../api/client";
+import type { components as PipelineComponents } from "../api/schema.pipeline";
+/** Base path for the Brand Pipeline API. */
+export declare const PIPELINE_BASE_PATH = "/stream/ai-pipeline-api";
+type CreatePipelineRunResponse = PipelineComponents["schemas"]["CreatePipelineRunResponse"];
+export interface RunBrandIngestionOptions {
+    client: BrandApiClientOptions;
+    brandKitId: string;
+    /**
+     * Whether the pipeline should populate the brand kit's sections with
+     * the ingested content. Defaults to `true` — without it, sections
+     * stay empty and `scai brand review` will keep crashing with the
+     * 500 'name' bug ([[project-scai-brand-review-empty-kit-500]]).
+     */
+    populateSections?: boolean;
+    /**
+     * Restrict ingestion to specific document IDs. The API wants this as
+     * a single comma-separated string. When omitted, every unprocessed
+     * document attached to the kit gets ingested.
+     */
+    documentIds?: string[];
+    signal?: AbortSignal;
+}
+export interface RunEnrichSectionsOptions {
+    client: BrandApiClientOptions;
+    brandKitId: string;
+    /** Restrict enrichment to specific section UUIDs. */
+    sectionIds?: string[];
+    /** Restrict enrichment to specific field UUIDs within those sections. */
+    fieldIds?: string[];
+    signal?: AbortSignal;
+}
+/**
+ * Trigger the brand ingestion pipeline against a brand kit.
+ *
+ * The pipeline processes brand documents (uploaded via the Documents
+ * API) and chunks them into knowledge pieces that drive brand-review
+ * compliance scoring. When `populateSections: true` (the default),
+ * the resulting brand knowledge also populates the kit's sections and
+ * fields.
+ *
+ * The endpoint is fire-and-forget: it returns a run id + timestamps
+ * but no completion status. There is no documented GET endpoint for
+ * pipeline run status as of 2026-05-14 — callers waiting for
+ * completion should poll the brand kit's sections list and watch for
+ * section count to go from 0 to > 0.
+ */
+export declare const runBrandIngestionPipeline: (options: RunBrandIngestionOptions) => Promise<CreatePipelineRunResponse>;
+/**
+ * Trigger the enrichment pipeline for an already-ingested brand kit.
+ * Useful after the operator manually edits a brand kit field and
+ * wants the AI to re-derive related sections.
+ *
+ * Same fire-and-forget shape as brand ingestion — no run-status GET
+ * endpoint exists; poll the section/field contents to detect changes.
+ */
+export declare const runEnrichSectionsPipeline: (options: RunEnrichSectionsOptions) => Promise<CreatePipelineRunResponse>;
+export {};

package/dist/brand/pipeline/run.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runEnrichSectionsPipeline = exports.runBrandIngestionPipeline = exports.PIPELINE_BASE_PATH = void 0;
+const client_1 = require("../api/client");
+/** Base path for the Brand Pipeline API. */
+exports.PIPELINE_BASE_PATH = "/stream/ai-pipeline-api";
+const buildOrgScopedPath = (orgId, pipelineName) => `/api/data/v1/organizations/${orgId}/pipeline/${pipelineName}`;
+/**
+ * Trigger the brand ingestion pipeline against a brand kit.
+ *
+ * The pipeline processes brand documents (uploaded via the Documents
+ * API) and chunks them into knowledge pieces that drive brand-review
+ * compliance scoring. When `populateSections: true` (the default),
+ * the resulting brand knowledge also populates the kit's sections and
+ * fields.
+ *
+ * The endpoint is fire-and-forget: it returns a run id + timestamps
+ * but no completion status. There is no documented GET endpoint for
+ * pipeline run status as of 2026-05-14 — callers waiting for
+ * completion should poll the brand kit's sections list and watch for
+ * section count to go from 0 to > 0.
+ */
+const runBrandIngestionPipeline = async (options) => {
+    const documentIds = options.documentIds?.length ? options.documentIds.join(",") : undefined;
+    return (0, client_1.requestBrandApi)(options.client, {
+        basePath: exports.PIPELINE_BASE_PATH,
+        path: buildOrgScopedPath(options.client.orgId, "BrandIngestionPipeline"),
+        method: "POST",
+        body: {
+            parameters: {
+                brand_kit_id: options.brandKitId,
+                populateSections: options.populateSections ?? true,
+                documentIdsList: documentIds,
+            },
+        },
+        signal: options.signal,
+    });
+};
+exports.runBrandIngestionPipeline = runBrandIngestionPipeline;
+/**
+ * Trigger the enrichment pipeline for an already-ingested brand kit.
+ * Useful after the operator manually edits a brand kit field and
+ * wants the AI to re-derive related sections.
+ *
+ * Same fire-and-forget shape as brand ingestion — no run-status GET
+ * endpoint exists; poll the section/field contents to detect changes.
+ */
+const runEnrichSectionsPipeline = async (options) => {
+    return (0, client_1.requestBrandApi)(options.client, {
+        basePath: exports.PIPELINE_BASE_PATH,
+        path: buildOrgScopedPath(options.client.orgId, "EnrichSectionsPipeline"),
+        method: "POST",
+        body: {
+            parameters: {
+                brand_kit_id: options.brandKitId,
+                sectionIdsList: options.sectionIds?.length ? options.sectionIds.join(",") : undefined,
+                fieldIdsList: options.fieldIds?.length ? options.fieldIds.join(",") : undefined,
+            },
+        },
+        signal: options.signal,
+    });
+};
+exports.runEnrichSectionsPipeline = runEnrichSectionsPipeline;

package/dist/brand/recipe/client.d.ts

@@ -0,0 +1,4 @@
+import type { BrandApiClientOptions } from "../../brand";
+import type { SyncContext } from "../../sync";
+/** Build the Brand Management API client for the context's environment. */
+export declare const resolveBrandClient: (ctx: SyncContext) => BrandApiClientOptions;

package/dist/brand/recipe/client.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveBrandClient = void 0;
+/**
+ * Resolves a `BrandApiClientOptions` from a `SyncContext` — the
+ * `brand-kit` kind's bridge between the generic `sync` engine and the
+ * Brand Management API.
+ */
+const root_config_1 = require("../../config/root-config");
+const errors_1 = require("../../shared/errors");
+/** Build the Brand Management API client for the context's environment. */
+const resolveBrandClient = (ctx) => {
+    const root = (0, root_config_1.readRootConfiguration)(ctx.configPath ?? process.cwd(), ctx.environmentName);
+    const orgId = root.environments[ctx.environmentName]?.organizationId;
+    if (!orgId) {
+        throw (0, errors_1.createScaiError)(`Cannot resolve organizationId for environment "${ctx.environmentName}".`, "INPUT_INVALID", { hint: "Set organizationId on the env profile in sitecoreai.cli.json." });
+    }
+    const credential = root.brand?.[orgId];
+    if (!credential) {
+        throw (0, errors_1.createScaiError)(`No Brand credential configured for org "${orgId}".`, "AUTH_BRAND_REQUIRED", { hint: `Run \`scai setup login brand -n ${ctx.environmentName}\` to provision one.` });
+    }
+    return { orgId, credential };
+};
+exports.resolveBrandClient = resolveBrandClient;

package/dist/brand/recipe/diff.d.ts

@@ -0,0 +1,4 @@
+import type { RecipePlan } from "../../sync";
+import type { BrandKitRecipe } from "./schema";
+/** Diff a desired brand-kit recipe against captured current state. */
+export declare const diffBrandKit: (desired: BrandKitRecipe, current: BrandKitRecipe | null) => RecipePlan;

package/dist/brand/recipe/diff.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffBrandKit = void 0;
+/**
+ * The pure diff for the `brand-kit` recipe kind — desired recipe vs.
+ * captured current state → a `RecipePlan`. No I/O, so it is cheap to
+ * unit-test and is the testable core of the kind.
+ *
+ * Each change carries `meta` so `apply` can act on it without parsing
+ * the `path` string:
+ *   - kit creation   → `{ stage: "kit", description, industry }`
+ *   - document ingest → `{ stage: "document", document }`
+ *   - field value     → `{ stage: "field", section, field }`
+ *
+ * A brand kit's sections/fields are created by the enrichment pipeline,
+ * so a kit-absent diff also emits the desired field values as `create`
+ * changes — `apply` resolves them once enrichment has populated the kit.
+ *
+ * See docs/recipe-sync-architecture.md.
+ */
+const node_util_1 = require("node:util");
+/** Diff a desired brand-kit recipe against captured current state. */
+const diffBrandKit = (desired, current) => {
+    const changes = [];
+    if (current === null) {
+        changes.push({
+            kind: "create",
+            path: "kit",
+            summary: `Create brand kit "${desired.name}"`,
+            after: desired.name,
+            meta: { stage: "kit", description: desired.description, industry: desired.industry },
+        });
+        desired.documents.forEach((document, index) => {
+            changes.push({
+                kind: "create",
+                path: `documents[${index}]`,
+                summary: `Upload + ingest ${document.url}`,
+                after: document.url,
+                meta: { stage: "document", document },
+            });
+        });
+    }
+    for (const [section, fields] of Object.entries(desired.sections)) {
+        for (const [field, value] of Object.entries(fields)) {
+            const path = `sections.${section}.${field}`;
+            const meta = { stage: "field", section, field };
+            const currentValue = current?.sections[section]?.[field];
+            if (current === null || currentValue === undefined) {
+                changes.push({
+                    kind: "create",
+                    path,
+                    summary: `${section} / ${field}`,
+                    after: value,
+                    meta,
+                });
+            }
+            else if ((0, node_util_1.isDeepStrictEqual)(currentValue, value)) {
+                changes.push({ kind: "noop", path, summary: `${section} / ${field} unchanged`, meta });
+            }
+            else {
+                changes.push({
+                    kind: "update",
+                    path,
+                    summary: `${section} / ${field}`,
+                    before: currentValue,
+                    after: value,
+                    meta,
+                });
+            }
+        }
+    }
+    return { changes };
+};
+exports.diffBrandKit = diffBrandKit;

package/dist/brand/recipe/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The `brand-kit` recipe kind — declarative definition + `sync` support
+ * for Sitecore brand kits.
+ *
+ * See docs/recipe-sync-architecture.md.
+ */
+export { BrandKitRecipeSchema, BrandFieldValueSchema, BrandDocumentSchema, BrandRichEntrySchema, type BrandKitRecipe, type BrandFieldValue, type BrandDocument, } from "./schema";
+export { diffBrandKit } from "./diff";
+export { resolveBrandClient } from "./client";
+export { brandKitKind } from "./kind";

package/dist/brand/recipe/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.brandKitKind = exports.resolveBrandClient = exports.diffBrandKit = exports.BrandRichEntrySchema = exports.BrandDocumentSchema = exports.BrandFieldValueSchema = exports.BrandKitRecipeSchema = void 0;
+/**
+ * The `brand-kit` recipe kind — declarative definition + `sync` support
+ * for Sitecore brand kits.
+ *
+ * See docs/recipe-sync-architecture.md.
+ */
+var schema_1 = require("./schema");
+Object.defineProperty(exports, "BrandKitRecipeSchema", { enumerable: true, get: function () { return schema_1.BrandKitRecipeSchema; } });
+Object.defineProperty(exports, "BrandFieldValueSchema", { enumerable: true, get: function () { return schema_1.BrandFieldValueSchema; } });
+Object.defineProperty(exports, "BrandDocumentSchema", { enumerable: true, get: function () { return schema_1.BrandDocumentSchema; } });
+Object.defineProperty(exports, "BrandRichEntrySchema", { enumerable: true, get: function () { return schema_1.BrandRichEntrySchema; } });
+var diff_1 = require("./diff");
+Object.defineProperty(exports, "diffBrandKit", { enumerable: true, get: function () { return diff_1.diffBrandKit; } });
+var client_1 = require("./client");
+Object.defineProperty(exports, "resolveBrandClient", { enumerable: true, get: function () { return client_1.resolveBrandClient; } });
+var kind_1 = require("./kind");
+Object.defineProperty(exports, "brandKitKind", { enumerable: true, get: function () { return kind_1.brandKitKind; } });

package/dist/brand/recipe/kind.d.ts

@@ -0,0 +1,4 @@
+import type { RecipeKind } from "../../sync";
+import { type BrandKitRecipe } from "./schema";
+/** The `brand-kit` recipe kind. */
+export declare const brandKitKind: RecipeKind<BrandKitRecipe>;

package/dist/brand/recipe/schema.d.ts

@@ -0,0 +1,54 @@
+/**
+ * `BrandKitRecipe` — the declarative definition of a Sitecore Brand
+ * brand kit.
+ *
+ * This schema is the single source of truth for the `brand-kit` recipe
+ * kind: it validates recipe files, drives the `sync` CLI, and becomes
+ * the MCP tool input schema. Keep the `.describe()` text accurate — the
+ * model reads it. See docs/recipe-sync-architecture.md.
+ */
+import { z } from "zod";
+/** A `richArray`-field entry: text plus optional tags and a constraint. */
+export declare const BrandRichEntrySchema: z.ZodObject<{
+    name: z.ZodString;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    restrictions: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * A brand-kit field value. The shape that is valid depends on the live
+ * field's type — `text` → string, `array` → string list, `richArray` →
+ * rich entries — which the kind resolves against the kit at diff time.
+ */
+export declare const BrandFieldValueSchema: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    restrictions: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>]>;
+/** A brand document to ingest. Sitecore fetches the URL server-side. */
+export declare const BrandDocumentSchema: z.ZodObject<{
+    url: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    summary: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** The full brand-kit recipe. */
+export declare const BrandKitRecipeSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    industry: z.ZodOptional<z.ZodString>;
+    documents: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        summary: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    sections: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        restrictions: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>]>>>>;
+}, z.core.$strip>;
+/** A validated brand-kit recipe. */
+export type BrandKitRecipe = z.infer<typeof BrandKitRecipeSchema>;
+/** A brand-kit field value (text / name list / rich entries). */
+export type BrandFieldValue = z.infer<typeof BrandFieldValueSchema>;
+/** A brand document reference within a recipe. */
+export type BrandDocument = z.infer<typeof BrandDocumentSchema>;

package/dist/brand/recipe/schema.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrandKitRecipeSchema = exports.BrandDocumentSchema = exports.BrandFieldValueSchema = exports.BrandRichEntrySchema = void 0;
+/**
+ * `BrandKitRecipe` — the declarative definition of a Sitecore Brand
+ * brand kit.
+ *
+ * This schema is the single source of truth for the `brand-kit` recipe
+ * kind: it validates recipe files, drives the `sync` CLI, and becomes
+ * the MCP tool input schema. Keep the `.describe()` text accurate — the
+ * model reads it. See docs/recipe-sync-architecture.md.
+ */
+const zod_1 = require("zod");
+/** A `richArray`-field entry: text plus optional tags and a constraint. */
+exports.BrandRichEntrySchema = zod_1.z.object({
+    name: zod_1.z.string().min(1).describe("The entry's text."),
+    tags: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .describe('Free-form tags, e.g. "Marketing", "Claims", "Self-Serve".'),
+    restrictions: zod_1.z
+        .string()
+        .optional()
+        .describe('Per-scenario constraint, e.g. "Never use scarcity in marketing copy".'),
+});
+/**
+ * A brand-kit field value. The shape that is valid depends on the live
+ * field's type — `text` → string, `array` → string list, `richArray` →
+ * rich entries — which the kind resolves against the kit at diff time.
+ */
+exports.BrandFieldValueSchema = zod_1.z
+    .union([zod_1.z.string(), zod_1.z.array(zod_1.z.string()), zod_1.z.array(exports.BrandRichEntrySchema)])
+    .describe("A text value, a list of names, or a list of rich entries.");
+/** A brand document to ingest. Sitecore fetches the URL server-side. */
+exports.BrandDocumentSchema = zod_1.z.object({
+    url: zod_1.z
+        .string()
+        .min(1)
+        .describe("Publicly reachable URL of a brand document (PDF). Sitecore fetches it server-side."),
+    title: zod_1.z.string().optional().describe('Document title. Defaults to "brand guidelines".'),
+    summary: zod_1.z.string().optional().describe("Short document summary."),
+});
+/** The full brand-kit recipe. */
+exports.BrandKitRecipeSchema = zod_1.z.object({
+    name: zod_1.z
+        .string()
+        .min(1)
+        .describe("Display name of the brand kit. Identifies the kit when pushing."),
+    description: zod_1.z.string().optional().describe("Human description of the kit."),
+    industry: zod_1.z.string().optional().describe('Industry label, e.g. "retail" or "developer-tools".'),
+    documents: zod_1.z
+        .array(exports.BrandDocumentSchema)
+        .default([])
+        .describe("Brand documents to ingest. On push, when the kit has no populated sections, each is uploaded and run through the ingestion + enrichment pipelines."),
+    sections: zod_1.z
+        .record(zod_1.z.string(), zod_1.z.record(zod_1.z.string(), exports.BrandFieldValueSchema))
+        .default({})
+        .describe("Desired field values, keyed by section name then field name. Sections and fields are created by enrichment; push converges their values."),
+});

package/dist/brand/review/format-json.d.ts

@@ -0,0 +1,33 @@
+import type { BrandReviewScore } from "../api/types";
+import { type OutcomeSummary, type ReviewOutcome } from "./outcomes";
+export interface BrandReviewJsonReport {
+    schemaVersion: 1;
+    threshold?: BrandReviewScore;
+    summary: OutcomeSummary;
+    results: Array<{
+        kind: "ok";
+        label: string;
+        overallScore: BrandReviewScore;
+        sectionResults: Array<{
+            section: string;
+            field?: string;
+            score: BrandReviewScore;
+            explanation?: string;
+            suggestions?: string[];
+        }>;
+    } | {
+        kind: "error";
+        label: string;
+        message: string;
+    }>;
+}
+/**
+ * Aggregated JSON payload for a batch review run. Order matches the
+ * input order; `kind: "error"` entries preserve the per-file failure
+ * message so consumers don't have to cross-reference exit codes.
+ *
+ * `raw` server fields from each `BrandReviewResult` are intentionally
+ * dropped here — they're useful for ad-hoc inspection but bloat the
+ * payload and aren't part of the stable contract.
+ */
+export declare const buildJsonReport: (outcomes: readonly ReviewOutcome[], threshold?: BrandReviewScore) => BrandReviewJsonReport;