@sitecoreai-labs/sitecoreai-cli 0.0.4 → 0.1.0

package/dist/brief/index.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * Public entry for `@sitecoreai-labs/sitecoreai-cli/unstable/brief`.
+ *
+ * Sitecore Content Operations Brief API client. Hosts follow
+ * `co-brief-api-<region>.sitecorecloud.io`; the default is EU-West but
+ * callers normally pass `baseUrl` from per-env config.
+ *
+ * **Status**: UNSTABLE — ships under `./unstable/brief` and carries no
+ * SemVer stability promise; schemas and behavior may change in any
+ * release. Reverse-engineered against the Agents env. Read helpers
+ * (`listBriefs`, `getBrief`, `listBriefTypes`, `getBriefType`,
+ * `listBriefTasks`, `listBriefComments`) verified 2026-05-14. BriefType
+ * writes (`createBriefType`, `updateBriefType`, `deleteBriefType`) verified
+ * end-to-end 2026-05-15 by `scripts/_smoke-brief-types-write.ts`. Brief
+ * writes (`createBrief`, `updateBrief`, `deleteBrief`) are wired but
+ * not yet smoke-tested. `createBriefComment` is wired UNVERIFIED — the
+ * comment write body shape is a best guess (see `./api/comments.ts`).
+ *
+ * Required Auth0 scope: `co.briefs:r` (read) / `co.briefs:r co.briefs:w`
+ * (read+write). The Agents env client carries both by default.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveBriefClient = exports.BRIEF_SCOPES_REQUESTED = exports.acquireBriefToken = exports.createBriefComment = exports.listBriefComments = exports.getBriefTask = exports.listBriefTasks = exports.deleteBriefType = exports.updateBriefType = exports.createBriefType = exports.getBriefType = exports.listBriefTypes = exports.deleteBrief = exports.setBriefStatus = exports.updateBrief = exports.createBrief = exports.getBrief = exports.listBriefs = exports.briefRequest = exports.DEFAULT_BRIEF_API_BASE = exports.BRIEF_API_HOST_TEMPLATE = void 0;
+var types_1 = require("./api/types");
+Object.defineProperty(exports, "BRIEF_API_HOST_TEMPLATE", { enumerable: true, get: function () { return types_1.BRIEF_API_HOST_TEMPLATE; } });
+Object.defineProperty(exports, "DEFAULT_BRIEF_API_BASE", { enumerable: true, get: function () { return types_1.DEFAULT_BRIEF_API_BASE; } });
+var request_1 = require("./api/request");
+Object.defineProperty(exports, "briefRequest", { enumerable: true, get: function () { return request_1.briefRequest; } });
+var briefs_1 = require("./api/briefs");
+Object.defineProperty(exports, "listBriefs", { enumerable: true, get: function () { return briefs_1.listBriefs; } });
+Object.defineProperty(exports, "getBrief", { enumerable: true, get: function () { return briefs_1.getBrief; } });
+Object.defineProperty(exports, "createBrief", { enumerable: true, get: function () { return briefs_1.createBrief; } });
+Object.defineProperty(exports, "updateBrief", { enumerable: true, get: function () { return briefs_1.updateBrief; } });
+Object.defineProperty(exports, "setBriefStatus", { enumerable: true, get: function () { return briefs_1.setBriefStatus; } });
+Object.defineProperty(exports, "deleteBrief", { enumerable: true, get: function () { return briefs_1.deleteBrief; } });
+var brief_types_1 = require("./api/brief-types");
+Object.defineProperty(exports, "listBriefTypes", { enumerable: true, get: function () { return brief_types_1.listBriefTypes; } });
+Object.defineProperty(exports, "getBriefType", { enumerable: true, get: function () { return brief_types_1.getBriefType; } });
+Object.defineProperty(exports, "createBriefType", { enumerable: true, get: function () { return brief_types_1.createBriefType; } });
+Object.defineProperty(exports, "updateBriefType", { enumerable: true, get: function () { return brief_types_1.updateBriefType; } });
+Object.defineProperty(exports, "deleteBriefType", { enumerable: true, get: function () { return brief_types_1.deleteBriefType; } });
+var tasks_1 = require("./api/tasks");
+Object.defineProperty(exports, "listBriefTasks", { enumerable: true, get: function () { return tasks_1.listBriefTasks; } });
+Object.defineProperty(exports, "getBriefTask", { enumerable: true, get: function () { return tasks_1.getBriefTask; } });
+var comments_1 = require("./api/comments");
+Object.defineProperty(exports, "listBriefComments", { enumerable: true, get: function () { return comments_1.listBriefComments; } });
+Object.defineProperty(exports, "createBriefComment", { enumerable: true, get: function () { return comments_1.createBriefComment; } });
+var auth_1 = require("./auth");
+Object.defineProperty(exports, "acquireBriefToken", { enumerable: true, get: function () { return auth_1.acquireBriefToken; } });
+Object.defineProperty(exports, "BRIEF_SCOPES_REQUESTED", { enumerable: true, get: function () { return auth_1.BRIEF_SCOPES_REQUESTED; } });
+var client_1 = require("./client");
+Object.defineProperty(exports, "resolveBriefClient", { enumerable: true, get: function () { return client_1.resolveBriefClient; } });

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

@@ -0,0 +1,4 @@
+import type { BriefApiClientOptions } from "../../brief";
+import type { SyncContext } from "../../sync";
+/** Build the Brief API client for the context's environment. */
+export declare const resolveBriefClient: (ctx: SyncContext) => Promise<BriefApiClientOptions>;

package/dist/brief/recipe/client.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveBriefClient = void 0;
+/**
+ * Resolves a `BriefApiClientOptions` from a `SyncContext` — the
+ * `brief-type` kind's bridge between the generic `sync` engine and the
+ * Sitecore Content Operations Brief API.
+ *
+ * Unlike the Brand client (a synchronous config read), the Brief API has
+ * no interactive login: a token is always minted from the environment's
+ * M2M client credentials. `resolveBriefClient` is therefore async — it
+ * mirrors how `src/brief/tasks` builds its client, just driven off the
+ * generic `SyncContext` instead of CLI options: same shared region
+ * resolver, same `briefBaseUrl` override.
+ */
+const brief_1 = require("../../brief");
+const environment_1 = require("../../policy/environment");
+const region_1 = require("../../shared/region");
+const auth_1 = require("../../serialization/api/auth");
+const errors_1 = require("../../shared/errors");
+/** Build the Brief API client for the context's environment. */
+const resolveBriefClient = async (ctx) => {
+    const { environment, root } = (0, environment_1.resolveEnvironment)({
+        config: ctx.configPath,
+        environmentName: ctx.environmentName,
+    });
+    // The Brief API is org-scoped; the sync context always carries an
+    // explicit environment, so the org id comes off that env profile.
+    const orgId = environment.organizationId;
+    if (!orgId) {
+        throw (0, errors_1.createScaiError)(`Environment '${ctx.environmentName ?? "(default)"}' has no organizationId; the Brief API is org-scoped.`, "INPUT_INVALID", { hint: "Set organizationId on the env profile in sitecoreai.cli.json." });
+    }
+    // Carry the org-scoped automation client's non-secret `clientId` from
+    // the root config so `resolveClientCredential` can pair it with the
+    // org-client secret in the keychain (tier 3).
+    const orgClientId = root.orgClients[orgId]?.clientId;
+    const accessToken = await (0, brief_1.acquireBriefToken)({
+        orgId,
+        environment: { ...environment, orgClientId },
+    });
+    // Host is region-resolved from the org id; an env profile may pin
+    // `briefBaseUrl` to override it. The brief token is scoped to
+    // `co.briefs:*`, so the lookup mints a separate no-scope M2M token.
+    const baseUrl = await (0, region_1.resolveRegionalBaseUrl)({
+        hostTemplate: brief_1.BRIEF_API_HOST_TEMPLATE,
+        organizationId: environment.organizationId,
+        override: environment.briefBaseUrl,
+        acquireToken: async () => (await (0, auth_1.requestClientCredentialsToken)(environment)).accessToken,
+    });
+    return { accessToken, baseUrl };
+};
+exports.resolveBriefClient = resolveBriefClient;

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

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

package/dist/brief/recipe/diff.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffBriefType = void 0;
+/**
+ * The pure diff for the `brief-type` 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.
+ *
+ * Brief types are plain CRUD: no ingestion, no pipelines, no lifecycle
+ * orchestration. The diff therefore emits at most one writing change —
+ * `apply` resolves it to a single `create` or full-replacement `update`.
+ *
+ * Each change carries `meta` so `apply` never re-parses the `path`
+ * string. Both writing changes carry the full desired recipe, because
+ * the brief-type API only supports whole-record writes (POST / PUT):
+ *   - type creation → `{ stage: "type", recipe }`
+ *   - type update   → `{ stage: "type", recipe }`
+ *
+ * When the type exists, each top-level element (`label`, `description`,
+ * `icon`, `iconColor`, `fields`) is also reported as a per-element
+ * `update` / `noop` change so the plan reads element-by-element — those
+ * carry `meta.stage = "field"` and are descriptive only; `apply` acts on
+ * the single `stage: "type"` change.
+ *
+ * See docs/recipe-sync-architecture.md.
+ */
+const node_util_1 = require("node:util");
+/** The top-level recipe elements compared one-by-one when the type exists. */
+const COMPARED_ELEMENTS = ["label", "description", "icon", "iconColor", "fields"];
+/** Diff a desired brief-type recipe against captured current state. */
+const diffBriefType = (desired, current) => {
+    const changes = [];
+    if (current === null) {
+        changes.push({
+            kind: "create",
+            path: "briefType",
+            summary: `Create brief type "${desired.name}"`,
+            after: desired.name,
+            meta: { stage: "type", recipe: desired },
+        });
+        return { changes };
+    }
+    // The type exists — compare each top-level element so the plan reads
+    // element-by-element.
+    let anyElementChanged = false;
+    for (const element of COMPARED_ELEMENTS) {
+        const before = current[element];
+        const after = desired[element];
+        const path = `briefType.${element}`;
+        const meta = { stage: "field", element };
+        if ((0, node_util_1.isDeepStrictEqual)(before, after)) {
+            changes.push({ kind: "noop", path, summary: `${element} unchanged`, meta });
+        }
+        else {
+            anyElementChanged = true;
+            changes.push({ kind: "update", path, summary: `${element}`, before, after, meta });
+        }
+    }
+    // A single whole-record write converges every changed element at once
+    // (the API only supports full-replacement PUT). Emitted as the lead
+    // change so `apply` finds it without scanning.
+    if (anyElementChanged) {
+        changes.unshift({
+            kind: "update",
+            path: "briefType",
+            summary: `Update brief type "${desired.name}"`,
+            before: current.name,
+            after: desired.name,
+            meta: { stage: "type", recipe: desired },
+        });
+    }
+    return { changes };
+};
+exports.diffBriefType = diffBriefType;

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

@@ -0,0 +1,10 @@
+/**
+ * The `brief-type` recipe kind — declarative definition + `sync` support
+ * for Sitecore Content Operations brief types.
+ *
+ * See docs/recipe-sync-architecture.md.
+ */
+export { BriefTypeRecipeSchema, BriefFieldSchema, RichTextFieldSchema, DateTimeFieldSchema, TimelineFieldSchema, BudgetFieldSchema, LocalizedStringSchema, type BriefTypeRecipe, type BriefRecipeField, type RecipeLocalizedString, } from "./schema";
+export { diffBriefType } from "./diff";
+export { resolveBriefClient } from "./client";
+export { briefTypeKind } from "./kind";

package/dist/brief/recipe/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.briefTypeKind = exports.resolveBriefClient = exports.diffBriefType = exports.LocalizedStringSchema = exports.BudgetFieldSchema = exports.TimelineFieldSchema = exports.DateTimeFieldSchema = exports.RichTextFieldSchema = exports.BriefFieldSchema = exports.BriefTypeRecipeSchema = void 0;
+/**
+ * The `brief-type` recipe kind — declarative definition + `sync` support
+ * for Sitecore Content Operations brief types.
+ *
+ * See docs/recipe-sync-architecture.md.
+ */
+var schema_1 = require("./schema");
+Object.defineProperty(exports, "BriefTypeRecipeSchema", { enumerable: true, get: function () { return schema_1.BriefTypeRecipeSchema; } });
+Object.defineProperty(exports, "BriefFieldSchema", { enumerable: true, get: function () { return schema_1.BriefFieldSchema; } });
+Object.defineProperty(exports, "RichTextFieldSchema", { enumerable: true, get: function () { return schema_1.RichTextFieldSchema; } });
+Object.defineProperty(exports, "DateTimeFieldSchema", { enumerable: true, get: function () { return schema_1.DateTimeFieldSchema; } });
+Object.defineProperty(exports, "TimelineFieldSchema", { enumerable: true, get: function () { return schema_1.TimelineFieldSchema; } });
+Object.defineProperty(exports, "BudgetFieldSchema", { enumerable: true, get: function () { return schema_1.BudgetFieldSchema; } });
+Object.defineProperty(exports, "LocalizedStringSchema", { enumerable: true, get: function () { return schema_1.LocalizedStringSchema; } });
+var diff_1 = require("./diff");
+Object.defineProperty(exports, "diffBriefType", { enumerable: true, get: function () { return diff_1.diffBriefType; } });
+var client_1 = require("./client");
+Object.defineProperty(exports, "resolveBriefClient", { enumerable: true, get: function () { return client_1.resolveBriefClient; } });
+var kind_1 = require("./kind");
+Object.defineProperty(exports, "briefTypeKind", { enumerable: true, get: function () { return kind_1.briefTypeKind; } });

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

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

package/dist/brief/recipe/kind.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.briefTypeKind = void 0;
+/**
+ * The `brief-type` recipe kind — wires the Sitecore Content Operations
+ * Brief API into the `sync` engine.
+ *
+ * `ref.id` is the brief type's NAME (its stable codename) — recipes
+ * identify a type by name, not UUID. `readCurrent` resolves it to a live
+ * brief type; `apply` is straight CRUD: `createBriefType` when the type
+ * is absent, `updateBriefType` (full-replacement PUT) to converge an
+ * existing one. Brief types have no ingestion/pipeline/orchestration,
+ * unlike brand kits — `apply` stays simple.
+ *
+ * See docs/recipe-sync-architecture.md.
+ */
+const brief_1 = require("../../brief");
+const errors_1 = require("../../shared/errors");
+const client_1 = require("./client");
+const diff_1 = require("./diff");
+const schema_1 = require("./schema");
+/** Find a brief type by its codename. `null` when none matches. */
+const findTypeByName = async (client, name) => {
+    const page = await (0, brief_1.listBriefTypes)(client);
+    return page.data.find((type) => type.name === name) ?? null;
+};
+/** Enumerate every brief type on the remote. */
+const list = async (ctx) => {
+    const client = await (0, client_1.resolveBriefClient)(ctx);
+    const page = await (0, brief_1.listBriefTypes)(client);
+    return page.data.map((type) => ({ kind: "brief-type", id: type.name }));
+};
+/** Project a live brief-type field into the clean recipe shape. */
+const toRecipeField = (field) => field;
+/** Project a live brief type into the recipe shape, dropping server ids. */
+const toRecipe = (type) => ({
+    name: type.name,
+    label: type.label,
+    description: type.description,
+    icon: type.icon,
+    iconColor: type.iconColor,
+    fields: type.fields.map(toRecipeField),
+});
+/** Convert a recipe into the Brief API's create/update write shape. */
+const toApiInput = (recipe) => ({
+    name: recipe.name,
+    label: recipe.label,
+    description: recipe.description,
+    icon: recipe.icon,
+    iconColor: recipe.iconColor,
+    fields: recipe.fields,
+});
+/** Capture a live brief type as a recipe. `null` when no type has the name. */
+const readCurrent = async (ref, ctx) => {
+    const client = await (0, client_1.resolveBriefClient)(ctx);
+    const type = await findTypeByName(client, ref.id);
+    return type ? toRecipe(type) : null;
+};
+/** Apply a plan — straight CRUD: create the type, or PUT-replace it. */
+const apply = async (plan, ref, ctx) => {
+    const client = await (0, client_1.resolveBriefClient)(ctx);
+    const applied = [];
+    const skipped = [];
+    // The single `stage: "type"` change carries the full desired recipe;
+    // per-element `stage: "field"` changes are descriptive only.
+    const typeChange = plan.changes.find((change) => change.meta?.stage === "type");
+    if (!typeChange) {
+        // Nothing to write — an all-noop plan.
+        for (const change of plan.changes)
+            skipped.push(change);
+        return { applied, skipped };
+    }
+    const recipe = typeChange.meta?.recipe;
+    if (!recipe) {
+        throw (0, errors_1.createScaiError)("Brief-type plan change is missing its recipe payload.", "INPUT_INVALID", { hint: "This is an internal diff error — the change.meta.recipe field was not set." });
+    }
+    const input = toApiInput(recipe);
+    if (typeChange.kind === "create") {
+        ctx.logger?.info(`Creating brief type "${recipe.name}".`);
+        await (0, brief_1.createBriefType)(client, input);
+    }
+    else {
+        const existing = await findTypeByName(client, ref.id);
+        if (!existing) {
+            throw (0, errors_1.createScaiError)(`Brief type "${ref.id}" not found.`, "INPUT_INVALID", {
+                hint: "The type was expected to exist for an update — check the name or push a create.",
+            });
+        }
+        ctx.logger?.info(`Updating brief type "${recipe.name}" (${existing.id}).`);
+        await (0, brief_1.updateBriefType)(client, existing.id, input);
+    }
+    applied.push(typeChange);
+    // Per-element changes are converged by the single whole-record write.
+    for (const change of plan.changes) {
+        if (change === typeChange)
+            continue;
+        if (change.kind === "noop")
+            skipped.push(change);
+        else
+            applied.push(change);
+    }
+    return { applied, skipped };
+};
+/** Compute the plan to converge a brief type onto `desired`. */
+const plan = async (desired, ref, ctx) => (0, diff_1.diffBriefType)(desired, await readCurrent(ref, ctx));
+/** The `brief-type` recipe kind. */
+exports.briefTypeKind = {
+    name: "brief-type",
+    schema: schema_1.BriefTypeRecipeSchema,
+    readCurrent,
+    plan,
+    apply,
+    list,
+};

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

@@ -0,0 +1,152 @@
+/**
+ * `BriefTypeRecipe` — the declarative definition of a Sitecore Content
+ * Operations brief type (the schema template a brief instance is built
+ * against).
+ *
+ * This schema is the single source of truth for the `brief-type` 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.
+ *
+ * Brief *instances* are runtime data and are out of scope — this kind
+ * covers only the type/config (its fields).
+ */
+import { z } from "zod";
+/** A localized label: BCP-47-ish locale (e.g. `en-us`) → string. */
+export declare const LocalizedStringSchema: z.ZodRecord<z.ZodString, z.ZodString>;
+/** A free-form rich-text field. */
+export declare const RichTextFieldSchema: z.ZodObject<{
+    name: z.ZodString;
+    label: z.ZodRecord<z.ZodString, z.ZodString>;
+    helpText: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    required: z.ZodBoolean;
+    aiEditable: z.ZodBoolean;
+    aiIntent: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"RichText">;
+}, z.core.$strip>;
+/** A single date-time field. */
+export declare const DateTimeFieldSchema: z.ZodObject<{
+    name: z.ZodString;
+    label: z.ZodRecord<z.ZodString, z.ZodString>;
+    helpText: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    required: z.ZodBoolean;
+    aiEditable: z.ZodBoolean;
+    aiIntent: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"DateTime">;
+}, z.core.$strip>;
+/** A timeline field — a schedule with holiday/weekend handling. */
+export declare const TimelineFieldSchema: z.ZodObject<{
+    calculation: z.ZodNumber;
+    skipHolidays: z.ZodBoolean;
+    skipWeekend: z.ZodBoolean;
+    timezone: z.ZodString;
+    name: z.ZodString;
+    label: z.ZodRecord<z.ZodString, z.ZodString>;
+    helpText: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    required: z.ZodBoolean;
+    aiEditable: z.ZodBoolean;
+    aiIntent: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"Timeline">;
+}, z.core.$strip>;
+/** A budget field — a monetary value constrained to a currency set. */
+export declare const BudgetFieldSchema: z.ZodObject<{
+    currencies: z.ZodArray<z.ZodString>;
+    name: z.ZodString;
+    label: z.ZodRecord<z.ZodString, z.ZodString>;
+    helpText: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    required: z.ZodBoolean;
+    aiEditable: z.ZodBoolean;
+    aiIntent: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"Budget">;
+}, z.core.$strip>;
+/** A brief-type field — discriminated on `type`. */
+export declare const BriefFieldSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    name: z.ZodString;
+    label: z.ZodRecord<z.ZodString, z.ZodString>;
+    helpText: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    required: z.ZodBoolean;
+    aiEditable: z.ZodBoolean;
+    aiIntent: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"RichText">;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodString;
+    label: z.ZodRecord<z.ZodString, z.ZodString>;
+    helpText: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    required: z.ZodBoolean;
+    aiEditable: z.ZodBoolean;
+    aiIntent: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"DateTime">;
+}, z.core.$strip>, z.ZodObject<{
+    calculation: z.ZodNumber;
+    skipHolidays: z.ZodBoolean;
+    skipWeekend: z.ZodBoolean;
+    timezone: z.ZodString;
+    name: z.ZodString;
+    label: z.ZodRecord<z.ZodString, z.ZodString>;
+    helpText: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    required: z.ZodBoolean;
+    aiEditable: z.ZodBoolean;
+    aiIntent: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"Timeline">;
+}, z.core.$strip>, z.ZodObject<{
+    currencies: z.ZodArray<z.ZodString>;
+    name: z.ZodString;
+    label: z.ZodRecord<z.ZodString, z.ZodString>;
+    helpText: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    required: z.ZodBoolean;
+    aiEditable: z.ZodBoolean;
+    aiIntent: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"Budget">;
+}, z.core.$strip>], "type">;
+/** The full brief-type recipe. */
+export declare const BriefTypeRecipeSchema: z.ZodObject<{
+    name: z.ZodString;
+    label: z.ZodRecord<z.ZodString, z.ZodString>;
+    description: z.ZodString;
+    icon: z.ZodString;
+    iconColor: z.ZodString;
+    fields: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        name: z.ZodString;
+        label: z.ZodRecord<z.ZodString, z.ZodString>;
+        helpText: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        required: z.ZodBoolean;
+        aiEditable: z.ZodBoolean;
+        aiIntent: z.ZodOptional<z.ZodString>;
+        type: z.ZodLiteral<"RichText">;
+    }, z.core.$strip>, z.ZodObject<{
+        name: z.ZodString;
+        label: z.ZodRecord<z.ZodString, z.ZodString>;
+        helpText: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        required: z.ZodBoolean;
+        aiEditable: z.ZodBoolean;
+        aiIntent: z.ZodOptional<z.ZodString>;
+        type: z.ZodLiteral<"DateTime">;
+    }, z.core.$strip>, z.ZodObject<{
+        calculation: z.ZodNumber;
+        skipHolidays: z.ZodBoolean;
+        skipWeekend: z.ZodBoolean;
+        timezone: z.ZodString;
+        name: z.ZodString;
+        label: z.ZodRecord<z.ZodString, z.ZodString>;
+        helpText: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        required: z.ZodBoolean;
+        aiEditable: z.ZodBoolean;
+        aiIntent: z.ZodOptional<z.ZodString>;
+        type: z.ZodLiteral<"Timeline">;
+    }, z.core.$strip>, z.ZodObject<{
+        currencies: z.ZodArray<z.ZodString>;
+        name: z.ZodString;
+        label: z.ZodRecord<z.ZodString, z.ZodString>;
+        helpText: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        required: z.ZodBoolean;
+        aiEditable: z.ZodBoolean;
+        aiIntent: z.ZodOptional<z.ZodString>;
+        type: z.ZodLiteral<"Budget">;
+    }, z.core.$strip>], "type">>>;
+}, z.core.$strip>;
+/** A validated brief-type recipe. */
+export type BriefTypeRecipe = z.infer<typeof BriefTypeRecipeSchema>;
+/** A brief-type field within a recipe (discriminated on `type`). */
+export type BriefRecipeField = z.infer<typeof BriefFieldSchema>;
+/** A localized string within a recipe. */
+export type RecipeLocalizedString = z.infer<typeof LocalizedStringSchema>;

package/dist/brief/recipe/schema.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BriefTypeRecipeSchema = exports.BriefFieldSchema = exports.BudgetFieldSchema = exports.TimelineFieldSchema = exports.DateTimeFieldSchema = exports.RichTextFieldSchema = exports.LocalizedStringSchema = void 0;
+/**
+ * `BriefTypeRecipe` — the declarative definition of a Sitecore Content
+ * Operations brief type (the schema template a brief instance is built
+ * against).
+ *
+ * This schema is the single source of truth for the `brief-type` 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.
+ *
+ * Brief *instances* are runtime data and are out of scope — this kind
+ * covers only the type/config (its fields).
+ */
+const zod_1 = require("zod");
+/** A localized label: BCP-47-ish locale (e.g. `en-us`) → string. */
+exports.LocalizedStringSchema = zod_1.z
+    .record(zod_1.z.string(), zod_1.z.string())
+    .describe('Localized text, keyed by BCP-47-ish locale, e.g. { "en-us": "Creative Brief" }.');
+/** Properties every brief-type field carries, regardless of `type`. */
+const briefFieldBaseShape = {
+    name: zod_1.z
+        .string()
+        .min(1)
+        .describe("Stable field codename — the key a brief instance stores its value under."),
+    label: exports.LocalizedStringSchema.describe("Localized human label shown in the brief authoring UI."),
+    helpText: exports.LocalizedStringSchema.optional().describe("Optional localized help text for the field."),
+    required: zod_1.z.boolean().describe("Whether the field must be filled before the brief can advance."),
+    aiEditable: zod_1.z
+        .boolean()
+        .describe("Whether AI assistants may write this field. `aiIntent` is read either way."),
+    aiIntent: zod_1.z
+        .string()
+        .optional()
+        .describe("Free-form prompt describing to AI clients how to fill the field."),
+};
+/** A free-form rich-text field. */
+exports.RichTextFieldSchema = zod_1.z
+    .object({
+    type: zod_1.z.literal("RichText").describe("Discriminator — a rich-text field."),
+    ...briefFieldBaseShape,
+})
+    .describe("A rich-text field.");
+/** A single date-time field. */
+exports.DateTimeFieldSchema = zod_1.z
+    .object({
+    type: zod_1.z.literal("DateTime").describe("Discriminator — a date-time field."),
+    ...briefFieldBaseShape,
+})
+    .describe("A date-time field.");
+/** A timeline field — a schedule with holiday/weekend handling. */
+exports.TimelineFieldSchema = zod_1.z
+    .object({
+    type: zod_1.z.literal("Timeline").describe("Discriminator — a timeline/schedule field."),
+    ...briefFieldBaseShape,
+    calculation: zod_1.z
+        .number()
+        .describe("Schedule calculation strategy enum — observed value `0`; semantics TBD."),
+    skipHolidays: zod_1.z.boolean().describe("Whether the schedule skips public holidays."),
+    skipWeekend: zod_1.z.boolean().describe("Whether the schedule skips weekends."),
+    timezone: zod_1.z.string().describe("IANA timezone string for the schedule; may be empty."),
+})
+    .describe("A timeline/schedule field.");
+/** A budget field — a monetary value constrained to a currency set. */
+exports.BudgetFieldSchema = zod_1.z
+    .object({
+    type: zod_1.z.literal("Budget").describe("Discriminator — a budget/currency field."),
+    ...briefFieldBaseShape,
+    currencies: zod_1.z
+        .array(zod_1.z.string())
+        .describe('ISO-4217 currency codes the field accepts, e.g. ["USD", "EUR"].'),
+})
+    .describe("A budget/currency field.");
+/** A brief-type field — discriminated on `type`. */
+exports.BriefFieldSchema = zod_1.z
+    .discriminatedUnion("type", [
+    exports.RichTextFieldSchema,
+    exports.DateTimeFieldSchema,
+    exports.TimelineFieldSchema,
+    exports.BudgetFieldSchema,
+])
+    .describe("A field definition: one of RichText, DateTime, Timeline, or Budget.");
+/** The full brief-type recipe. */
+exports.BriefTypeRecipeSchema = zod_1.z.object({
+    name: zod_1.z
+        .string()
+        .regex(/^[A-Za-z][A-Za-z0-9_]*$/, "Must start with a letter and contain only letters, digits, or underscores.")
+        .describe("Stable codename of the brief type, e.g. `CreativeBrief`. Identifies the type when pushing."),
+    label: exports.LocalizedStringSchema.describe("Localized human label for the brief type."),
+    description: zod_1.z.string().describe("Human description of what the brief type is for."),
+    icon: zod_1.z.string().describe("mdi icon codepoint name shown in the brief authoring UI."),
+    iconColor: zod_1.z.string().describe("Hex or named color paired with the icon."),
+    fields: zod_1.z
+        .array(exports.BriefFieldSchema)
+        .default([])
+        .describe("Field definitions in display order. An empty list is valid."),
+});