@sitecoreai-labs/sitecoreai-cli 0.0.4 → 0.1.0

package/dist/campaigns/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Public entry for `@sitecoreai-labs/sitecoreai-cli/unstable/campaigns`.
+ *
+ * Sitecore **Orchestrate API** client. A "campaign" in the product UI
+ * is an Orchestrate `project`; a project owns deliverables, a
+ * deliverable owns tasks. Hosts are regional —
+ * `ai-workflows-<region>.sitecorecloud.io` — so callers normally pass
+ * `baseUrl` from per-env config.
+ *
+ * **Status**: built from a HAR capture of the Content Operations UI on
+ * 2026-05-15. Request/response shapes are observed-accurate. Unverified
+ * items, tracked in `docs/campaigns-followups.md`:
+ *   - the OAuth scope (the HAR stripped Authorization headers)
+ *   - project/deliverable/task update (only GET/POST were exercised; tasks have PUT)
+ *   - `deleteProject` / `deleteDeliverable` / `deleteTask` — DELETE was
+ *     never captured; wired optimistically per REST conventions.
+ *     Smoke-test with `scripts/_smoke-campaign-delete.ts` before relying
+ *     on them.
+ */
+export type { CampaignApiClientOptions, CampaignRequestInit, CampaignQueryValue, CampaignQueryRecord, } from "./api/types";
+export { CAMPAIGN_API_HOST_TEMPLATE, DEFAULT_CAMPAIGN_API_BASE } from "./api/types";
+export { campaignRequest } from "./api/request";
+export type { PagedResult, Project, ProjectMember, ProjectAttachment, Deliverable, Task, CampaignUser, } from "./api/schema";
+export { listProjects, getProject, createProject, deleteProject, type ListProjectsQuery, type CreateProjectInput, } from "./api/projects";
+export { createDeliverable, deleteDeliverable, type CreateDeliverableInput, } from "./api/deliverables";
+export { listTasks, getTask, createTask, updateTask, deleteTask, type CreateTaskInput, type UpdateTaskInput, } from "./api/tasks";
+export { listUsers } from "./api/users";
+export { acquireCampaignToken, type AcquireCampaignTokenOptions } from "./auth";
+export { resolveCampaignClient, type ResolveCampaignClientOptions, type ResolvedCampaignClient, } from "./client";

package/dist/campaigns/index.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Public entry for `@sitecoreai-labs/sitecoreai-cli/unstable/campaigns`.
+ *
+ * Sitecore **Orchestrate API** client. A "campaign" in the product UI
+ * is an Orchestrate `project`; a project owns deliverables, a
+ * deliverable owns tasks. Hosts are regional —
+ * `ai-workflows-<region>.sitecorecloud.io` — so callers normally pass
+ * `baseUrl` from per-env config.
+ *
+ * **Status**: built from a HAR capture of the Content Operations UI on
+ * 2026-05-15. Request/response shapes are observed-accurate. Unverified
+ * items, tracked in `docs/campaigns-followups.md`:
+ *   - the OAuth scope (the HAR stripped Authorization headers)
+ *   - project/deliverable/task update (only GET/POST were exercised; tasks have PUT)
+ *   - `deleteProject` / `deleteDeliverable` / `deleteTask` — DELETE was
+ *     never captured; wired optimistically per REST conventions.
+ *     Smoke-test with `scripts/_smoke-campaign-delete.ts` before relying
+ *     on them.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCampaignClient = exports.acquireCampaignToken = exports.listUsers = exports.deleteTask = exports.updateTask = exports.createTask = exports.getTask = exports.listTasks = exports.deleteDeliverable = exports.createDeliverable = exports.deleteProject = exports.createProject = exports.getProject = exports.listProjects = exports.campaignRequest = exports.DEFAULT_CAMPAIGN_API_BASE = exports.CAMPAIGN_API_HOST_TEMPLATE = void 0;
+var types_1 = require("./api/types");
+Object.defineProperty(exports, "CAMPAIGN_API_HOST_TEMPLATE", { enumerable: true, get: function () { return types_1.CAMPAIGN_API_HOST_TEMPLATE; } });
+Object.defineProperty(exports, "DEFAULT_CAMPAIGN_API_BASE", { enumerable: true, get: function () { return types_1.DEFAULT_CAMPAIGN_API_BASE; } });
+var request_1 = require("./api/request");
+Object.defineProperty(exports, "campaignRequest", { enumerable: true, get: function () { return request_1.campaignRequest; } });
+var projects_1 = require("./api/projects");
+Object.defineProperty(exports, "listProjects", { enumerable: true, get: function () { return projects_1.listProjects; } });
+Object.defineProperty(exports, "getProject", { enumerable: true, get: function () { return projects_1.getProject; } });
+Object.defineProperty(exports, "createProject", { enumerable: true, get: function () { return projects_1.createProject; } });
+Object.defineProperty(exports, "deleteProject", { enumerable: true, get: function () { return projects_1.deleteProject; } });
+var deliverables_1 = require("./api/deliverables");
+Object.defineProperty(exports, "createDeliverable", { enumerable: true, get: function () { return deliverables_1.createDeliverable; } });
+Object.defineProperty(exports, "deleteDeliverable", { enumerable: true, get: function () { return deliverables_1.deleteDeliverable; } });
+var tasks_1 = require("./api/tasks");
+Object.defineProperty(exports, "listTasks", { enumerable: true, get: function () { return tasks_1.listTasks; } });
+Object.defineProperty(exports, "getTask", { enumerable: true, get: function () { return tasks_1.getTask; } });
+Object.defineProperty(exports, "createTask", { enumerable: true, get: function () { return tasks_1.createTask; } });
+Object.defineProperty(exports, "updateTask", { enumerable: true, get: function () { return tasks_1.updateTask; } });
+Object.defineProperty(exports, "deleteTask", { enumerable: true, get: function () { return tasks_1.deleteTask; } });
+var users_1 = require("./api/users");
+Object.defineProperty(exports, "listUsers", { enumerable: true, get: function () { return users_1.listUsers; } });
+var auth_1 = require("./auth");
+Object.defineProperty(exports, "acquireCampaignToken", { enumerable: true, get: function () { return auth_1.acquireCampaignToken; } });
+var client_1 = require("./client");
+Object.defineProperty(exports, "resolveCampaignClient", { enumerable: true, get: function () { return client_1.resolveCampaignClient; } });

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

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

package/dist/campaigns/recipe/client.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCampaignClient = void 0;
+/**
+ * Resolves a `CampaignApiClientOptions` from a `SyncContext` — the
+ * `campaign` kind's bridge between the generic `sync` engine and the
+ * Sitecore Orchestrate API.
+ *
+ * Mirrors `prepareCampaignClient` in `src/campaigns/tasks/index.ts`:
+ * resolve the environment, mint an Orchestrate-scoped token via
+ * `acquireCampaignToken`, and region-resolve the host through the
+ * shared resolver (`campaignBaseUrl` still overrides it outright).
+ * Unlike the brand kit's client resolver this is async — the
+ * Orchestrate API has no synchronous credential, the token is minted
+ * on demand.
+ */
+const campaigns_1 = require("../../campaigns");
+const environment_1 = require("../../policy/environment");
+const region_1 = require("../../shared/region");
+/** Build the Orchestrate API client for the context's environment. */
+const resolveCampaignClient = async (ctx) => {
+    const { environment, root } = (0, environment_1.resolveEnvironment)({
+        config: ctx.configPath,
+        environmentName: ctx.environmentName,
+    });
+    const orgId = environment.organizationId;
+    const accessToken = await (0, campaigns_1.acquireCampaignToken)({
+        organizationId: orgId,
+        brandCredential: orgId ? root.brand?.[orgId] : undefined,
+    });
+    // Host is region-resolved from the org id; resolution is best-effort
+    // and falls back to DEFAULT_REGION when the token can't list tenants.
+    const baseUrl = await (0, region_1.resolveRegionalBaseUrl)({
+        hostTemplate: campaigns_1.CAMPAIGN_API_HOST_TEMPLATE,
+        organizationId: environment.organizationId,
+        override: environment.campaignBaseUrl,
+        acquireToken: async () => accessToken,
+    });
+    return { accessToken, baseUrl };
+};
+exports.resolveCampaignClient = resolveCampaignClient;

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

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

package/dist/campaigns/recipe/diff.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffCampaign = void 0;
+/**
+ * The pure diff for the `campaign` 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:
+ *   - project creation  → `{ stage: "project" }`
+ *   - deliverable        → `{ stage: "deliverable", deliverable, deliverableName }`
+ *   - task               → `{ stage: "task", deliverableName, taskName, task }`
+ *
+ * A campaign's deliverables and tasks are plain CRUD children — there
+ * is no ingestion or pipeline orchestration (unlike brand). Apply is
+ * additive: a recipe omitting a deliverable or task never removes it.
+ *
+ * Per docs/campaigns-followups.md (A3), the Orchestrate API has no
+ * verified project-metadata update endpoint — so the project is
+ * create-only. When the campaign already exists, no `project` change
+ * is emitted even if recipe metadata (description, dates, …) differs.
+ *
+ * See docs/recipe-sync-architecture.md.
+ */
+const node_util_1 = require("node:util");
+/** Compare two recipe tasks ignoring undefined-vs-absent noise. */
+const tasksEqual = (a, b) => a.name === b.name &&
+    a.status === b.status &&
+    a.dueDate === b.dueDate &&
+    a.priority === b.priority &&
+    a.description === b.description &&
+    a.assignee === b.assignee &&
+    (0, node_util_1.isDeepStrictEqual)(a.labels, b.labels);
+/** Diff a deliverable's tasks against the current deliverable's tasks. */
+const diffTasks = (deliverableName, desiredTasks, currentTasks) => {
+    const changes = [];
+    const currentByName = new Map((currentTasks ?? []).map((task) => [task.name, task]));
+    for (const task of desiredTasks) {
+        const path = `deliverables.${deliverableName}.tasks.${task.name}`;
+        const meta = { stage: "task", deliverableName, taskName: task.name, task };
+        const currentTask = currentByName.get(task.name);
+        if (!currentTask) {
+            changes.push({
+                kind: "create",
+                path,
+                summary: `${deliverableName} / ${task.name}`,
+                after: task,
+                meta,
+            });
+        }
+        else if (tasksEqual(task, currentTask)) {
+            changes.push({
+                kind: "noop",
+                path,
+                summary: `${deliverableName} / ${task.name} unchanged`,
+                meta,
+            });
+        }
+        else {
+            changes.push({
+                kind: "update",
+                path,
+                summary: `${deliverableName} / ${task.name}`,
+                before: currentTask,
+                after: task,
+                meta,
+            });
+        }
+    }
+    return changes;
+};
+/** Diff a desired campaign recipe against captured current state. */
+const diffCampaign = (desired, current) => {
+    const changes = [];
+    if (current === null) {
+        changes.push({
+            kind: "create",
+            path: "project",
+            summary: `Create campaign "${desired.name}"`,
+            after: desired.name,
+            meta: {
+                stage: "project",
+                description: desired.description,
+                status: desired.status,
+                startDate: desired.startDate,
+                dueDate: desired.dueDate,
+                brandKitId: desired.brandKitId,
+                labels: desired.labels,
+            },
+        });
+    }
+    const currentDeliverables = new Map((current?.deliverables ?? []).map((deliverable) => [deliverable.name, deliverable]));
+    for (const deliverable of desired.deliverables) {
+        const path = `deliverables.${deliverable.name}`;
+        const currentDeliverable = currentDeliverables.get(deliverable.name);
+        const meta = {
+            stage: "deliverable",
+            deliverableName: deliverable.name,
+            deliverable,
+        };
+        if (!currentDeliverable) {
+            changes.push({
+                kind: "create",
+                path,
+                summary: `Create deliverable "${deliverable.name}"`,
+                after: deliverable.name,
+                meta,
+            });
+            // A brand-new deliverable's tasks are all created alongside it.
+            changes.push(...diffTasks(deliverable.name, deliverable.tasks, []));
+        }
+        else {
+            changes.push(...diffTasks(deliverable.name, deliverable.tasks, currentDeliverable.tasks));
+        }
+    }
+    return { changes };
+};
+exports.diffCampaign = diffCampaign;

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

@@ -0,0 +1,10 @@
+/**
+ * The `campaign` recipe kind — declarative definition + `sync` support
+ * for Sitecore Orchestrate campaigns (projects, deliverables, tasks).
+ *
+ * See docs/recipe-sync-architecture.md.
+ */
+export { CampaignRecipeSchema, CampaignDeliverableSchema, CampaignTaskSchema, type CampaignRecipe, type CampaignDeliverable, type CampaignTask, } from "./schema";
+export { diffCampaign } from "./diff";
+export { resolveCampaignClient } from "./client";
+export { campaignKind } from "./kind";

package/dist/campaigns/recipe/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.campaignKind = exports.resolveCampaignClient = exports.diffCampaign = exports.CampaignTaskSchema = exports.CampaignDeliverableSchema = exports.CampaignRecipeSchema = void 0;
+/**
+ * The `campaign` recipe kind — declarative definition + `sync` support
+ * for Sitecore Orchestrate campaigns (projects, deliverables, tasks).
+ *
+ * See docs/recipe-sync-architecture.md.
+ */
+var schema_1 = require("./schema");
+Object.defineProperty(exports, "CampaignRecipeSchema", { enumerable: true, get: function () { return schema_1.CampaignRecipeSchema; } });
+Object.defineProperty(exports, "CampaignDeliverableSchema", { enumerable: true, get: function () { return schema_1.CampaignDeliverableSchema; } });
+Object.defineProperty(exports, "CampaignTaskSchema", { enumerable: true, get: function () { return schema_1.CampaignTaskSchema; } });
+var diff_1 = require("./diff");
+Object.defineProperty(exports, "diffCampaign", { enumerable: true, get: function () { return diff_1.diffCampaign; } });
+var client_1 = require("./client");
+Object.defineProperty(exports, "resolveCampaignClient", { enumerable: true, get: function () { return client_1.resolveCampaignClient; } });
+var kind_1 = require("./kind");
+Object.defineProperty(exports, "campaignKind", { enumerable: true, get: function () { return kind_1.campaignKind; } });

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

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

package/dist/campaigns/recipe/kind.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.campaignKind = void 0;
+/**
+ * The `campaign` recipe kind — wires the Sitecore Orchestrate API into
+ * the `sync` engine.
+ *
+ * A "campaign" in the product UI is an Orchestrate `project`; a project
+ * owns deliverables, a deliverable owns tasks. `ref.id` is the
+ * campaign's display NAME — recipes identify a campaign by name, not
+ * UUID, exactly as `brand-kit` identifies a kit.
+ *
+ * `apply` is straight CRUD — `createProject` when the campaign is
+ * absent, `createDeliverable` / `createTask` for missing children, and
+ * `updateTask` to converge existing tasks. There is no ingestion or
+ * pipeline orchestration (unlike brand). Per docs/campaigns-followups.md
+ * (A3), the Orchestrate API has no verified project-metadata update, so
+ * the project is create-only: deliverables and tasks are converged, and
+ * anything inapplicable (a task whose parent deliverable never resolves)
+ * is surfaced as `skipped`, never silently dropped.
+ *
+ * See docs/recipe-sync-architecture.md.
+ */
+const campaigns_1 = require("../../campaigns");
+const errors_1 = require("../../shared/errors");
+const client_1 = require("./client");
+const diff_1 = require("./diff");
+const schema_1 = require("./schema");
+/** Find a campaign (project) by display name, paging the list endpoint. */
+const findProjectByName = async (client, name) => {
+    let cursor;
+    for (;;) {
+        const page = await (0, campaigns_1.listProjects)(client, { next: cursor });
+        const match = page.data.find((project) => project.name === name);
+        if (match)
+            return match;
+        if (!page.next || page.data.length === 0)
+            return null;
+        cursor = page.next;
+    }
+};
+/** Project a live task into the clean recipe shape (server ids dropped). */
+const toRecipeTask = (task) => ({
+    name: task.name,
+    status: task.status,
+    dueDate: task.due_date ?? undefined,
+    priority: task.priority ?? undefined,
+    description: task.description ?? undefined,
+    assignee: task.assignee ?? undefined,
+    labels: task.labels ?? [],
+});
+/** Project a live deliverable into the clean recipe shape. */
+const toRecipeDeliverable = (deliverable) => ({
+    name: deliverable.name,
+    status: deliverable.status,
+    dueDate: deliverable.due_date ?? undefined,
+    funnelStage: deliverable.funnel_stage,
+    funnelTactics: deliverable.funnel_tactics ?? [],
+    labels: deliverable.labels ?? [],
+    tasks: (deliverable.tasks ?? []).map(toRecipeTask),
+});
+/** Capture a live campaign as a recipe. `null` when no project has the name. */
+const readCurrent = async (ref, ctx) => {
+    const client = await (0, client_1.resolveCampaignClient)(ctx);
+    const found = await findProjectByName(client, ref.id);
+    if (!found)
+        return null;
+    // The list endpoint omits inlined children; re-read by id to get the
+    // full deliverable + task tree.
+    const project = await (0, campaigns_1.getProject)(client, found.id);
+    return {
+        name: project.name,
+        description: project.description || undefined,
+        status: project.status || undefined,
+        startDate: project.start_date ?? undefined,
+        dueDate: project.due_date ?? undefined,
+        brandKitId: project.brandkit_id ?? undefined,
+        labels: project.labels ?? [],
+        deliverables: (project.deliverables ?? []).map(toRecipeDeliverable),
+    };
+};
+/** Apply a plan — create the project, then converge deliverables and tasks. */
+const apply = async (plan, ref, ctx) => {
+    const client = await (0, client_1.resolveCampaignClient)(ctx);
+    const applied = [];
+    const skipped = [];
+    const projectChange = plan.changes.find((change) => change.meta?.stage === "project");
+    const deliverableChanges = plan.changes.filter((change) => change.meta?.stage === "deliverable");
+    const taskChanges = plan.changes.filter((change) => change.meta?.stage === "task");
+    // Resolve the campaign (project) id — creating it when the plan says so.
+    let project;
+    if (projectChange) {
+        const name = String(projectChange.after);
+        ctx.logger?.info(`Creating campaign "${name}".`);
+        project = await (0, campaigns_1.createProject)(client, {
+            name,
+            description: projectChange.meta?.description,
+            status: projectChange.meta?.status,
+            start_date: projectChange.meta?.startDate,
+            due_date: projectChange.meta?.dueDate,
+            brandkit_id: projectChange.meta?.brandKitId,
+            labels: projectChange.meta?.labels ?? [],
+        });
+        applied.push(projectChange);
+    }
+    else {
+        const found = await findProjectByName(client, ref.id);
+        if (!found) {
+            throw (0, errors_1.createScaiError)(`Campaign "${ref.id}" not found`, "INPUT_INVALID", {
+                hint: "Push a recipe that creates the campaign, or check the name.",
+            });
+        }
+        project = await (0, campaigns_1.getProject)(client, found.id);
+    }
+    // Index existing deliverables by name so task changes can resolve
+    // their parent — and so already-present deliverables are skipped.
+    const deliverablesByName = new Map((project.deliverables ?? []).map((deliverable) => [deliverable.name, deliverable]));
+    // Create missing deliverables. Their tasks are created in the task
+    // pass below, which resolves against this freshly-populated index.
+    for (const change of deliverableChanges) {
+        if (change.kind !== "create") {
+            skipped.push(change);
+            continue;
+        }
+        const deliverable = change.meta?.deliverable;
+        if (!deliverable) {
+            skipped.push(change);
+            continue;
+        }
+        ctx.logger?.info(`Creating deliverable "${deliverable.name}".`);
+        const created = await (0, campaigns_1.createDeliverable)(client, project.id, {
+            name: deliverable.name,
+            due_date: deliverable.dueDate,
+            status: deliverable.status,
+            funnel_stage: deliverable.funnelStage,
+            funnel_tactics: deliverable.funnelTactics,
+            labels: deliverable.labels,
+        });
+        deliverablesByName.set(created.name, created);
+        applied.push(change);
+    }
+    // Converge tasks — create the missing ones, PUT-replace changed ones.
+    for (const change of taskChanges) {
+        if (change.kind === "noop") {
+            skipped.push(change);
+            continue;
+        }
+        const deliverableName = String(change.meta?.deliverableName);
+        const task = change.meta?.task;
+        const parent = deliverablesByName.get(deliverableName);
+        if (!parent || !task) {
+            // The parent deliverable never resolved — surface, do not drop.
+            skipped.push(change);
+            continue;
+        }
+        if (change.kind === "create") {
+            const created = await (0, campaigns_1.createTask)(client, project.id, parent.id, {
+                name: task.name,
+                due_date: task.dueDate,
+                status: task.status,
+            });
+            // createTask only accepts name/due_date/status — converge the
+            // remaining fields with a follow-up update so a freshly-created
+            // task does not silently lose its priority/description/assignee/labels.
+            if (task.priority !== undefined ||
+                task.description !== undefined ||
+                task.assignee !== undefined ||
+                (task.labels ?? []).length > 0) {
+                await (0, campaigns_1.updateTask)(client, project.id, parent.id, created.id, {
+                    name: task.name,
+                    due_date: task.dueDate,
+                    status: task.status,
+                    priority: task.priority ?? null,
+                    description: task.description ?? null,
+                    assignee: task.assignee ?? null,
+                    labels: task.labels ?? [],
+                });
+            }
+            applied.push(change);
+        }
+        else if (change.kind === "update") {
+            // PUT is full-replacement — the recipe carries the whole task.
+            await (0, campaigns_1.updateTask)(client, project.id, parent.id, resolveTaskId(parent, task), {
+                name: task.name,
+                due_date: task.dueDate,
+                status: task.status,
+                priority: task.priority ?? null,
+                description: task.description ?? null,
+                assignee: task.assignee ?? null,
+                labels: task.labels,
+            });
+            applied.push(change);
+        }
+        else {
+            skipped.push(change);
+        }
+    }
+    return { applied, skipped };
+};
+/** Resolve a recipe task to its server id within a live deliverable. */
+const resolveTaskId = (deliverable, task) => {
+    const match = (deliverable.tasks ?? []).find((candidate) => candidate.name === task.name);
+    if (!match) {
+        throw (0, errors_1.createScaiError)(`Task "${task.name}" not found on deliverable "${deliverable.name}"`, "INPUT_INVALID");
+    }
+    return match.id;
+};
+/** Compute the plan to converge a campaign onto `desired`. */
+const plan = async (desired, ref, ctx) => (0, diff_1.diffCampaign)(desired, await readCurrent(ref, ctx));
+/** The `campaign` recipe kind. */
+exports.campaignKind = {
+    name: "campaign",
+    schema: schema_1.CampaignRecipeSchema,
+    readCurrent,
+    plan,
+    apply,
+};

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

@@ -0,0 +1,79 @@
+/**
+ * `CampaignRecipe` — the declarative definition of a Sitecore
+ * Orchestrate campaign (a `project`, with its nested deliverables and
+ * tasks).
+ *
+ * This schema is the single source of truth for the `campaign` 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 task — the leaf work item of a campaign. Owned by a deliverable.
+ * Identified within its deliverable by `name`; server ids are dropped
+ * from a captured recipe.
+ */
+export declare const CampaignTaskSchema: z.ZodObject<{
+    name: z.ZodString;
+    status: z.ZodOptional<z.ZodString>;
+    dueDate: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    assignee: z.ZodOptional<z.ZodString>;
+    labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * A deliverable — a funnel-stage grouping of tasks under a campaign.
+ * Identified within its campaign by `name`.
+ */
+export declare const CampaignDeliverableSchema: z.ZodObject<{
+    name: z.ZodString;
+    status: z.ZodOptional<z.ZodString>;
+    dueDate: z.ZodOptional<z.ZodString>;
+    funnelStage: z.ZodOptional<z.ZodString>;
+    funnelTactics: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    tasks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        status: z.ZodOptional<z.ZodString>;
+        dueDate: z.ZodOptional<z.ZodString>;
+        priority: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        assignee: z.ZodOptional<z.ZodString>;
+        labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/** The full campaign recipe — a project plus its nested deliverables. */
+export declare const CampaignRecipeSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    startDate: z.ZodOptional<z.ZodString>;
+    dueDate: z.ZodOptional<z.ZodString>;
+    brandKitId: z.ZodOptional<z.ZodString>;
+    labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    deliverables: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        status: z.ZodOptional<z.ZodString>;
+        dueDate: z.ZodOptional<z.ZodString>;
+        funnelStage: z.ZodOptional<z.ZodString>;
+        funnelTactics: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        tasks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            status: z.ZodOptional<z.ZodString>;
+            dueDate: z.ZodOptional<z.ZodString>;
+            priority: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            assignee: z.ZodOptional<z.ZodString>;
+            labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/** A validated campaign recipe. */
+export type CampaignRecipe = z.infer<typeof CampaignRecipeSchema>;
+/** A deliverable within a campaign recipe. */
+export type CampaignDeliverable = z.infer<typeof CampaignDeliverableSchema>;
+/** A task within a campaign recipe. */
+export type CampaignTask = z.infer<typeof CampaignTaskSchema>;

package/dist/campaigns/recipe/schema.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CampaignRecipeSchema = exports.CampaignDeliverableSchema = exports.CampaignTaskSchema = void 0;
+/**
+ * `CampaignRecipe` — the declarative definition of a Sitecore
+ * Orchestrate campaign (a `project`, with its nested deliverables and
+ * tasks).
+ *
+ * This schema is the single source of truth for the `campaign` 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 task — the leaf work item of a campaign. Owned by a deliverable.
+ * Identified within its deliverable by `name`; server ids are dropped
+ * from a captured recipe.
+ */
+exports.CampaignTaskSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1).describe("Task name. Identifies the task within its deliverable."),
+    status: zod_1.z.string().optional().describe('Task status — a server enum, e.g. "NOT_STARTED".'),
+    dueDate: zod_1.z.string().optional().describe("Task due date (ISO-8601)."),
+    priority: zod_1.z.string().optional().describe("Task priority — a server enum."),
+    description: zod_1.z.string().optional().describe("Task description. HTML."),
+    assignee: zod_1.z.string().optional().describe('Assignee — an Auth0 user subject (e.g. "auth0|...").'),
+    labels: zod_1.z.array(zod_1.z.string()).default([]).describe("Free-form labels on the task."),
+});
+/**
+ * A deliverable — a funnel-stage grouping of tasks under a campaign.
+ * Identified within its campaign by `name`.
+ */
+exports.CampaignDeliverableSchema = zod_1.z.object({
+    name: zod_1.z
+        .string()
+        .min(1)
+        .describe("Deliverable name. Identifies the deliverable within its campaign."),
+    status: zod_1.z.string().optional().describe('Deliverable status — a server enum, e.g. "NOT_STARTED".'),
+    dueDate: zod_1.z.string().optional().describe("Deliverable due date (ISO-8601)."),
+    funnelStage: zod_1.z.string().optional().describe('Funnel stage — a server enum, e.g. "TOP".'),
+    funnelTactics: zod_1.z.array(zod_1.z.string()).default([]).describe("Funnel tactics for the deliverable."),
+    labels: zod_1.z.array(zod_1.z.string()).default([]).describe("Free-form labels on the deliverable."),
+    tasks: zod_1.z
+        .array(exports.CampaignTaskSchema)
+        .default([])
+        .describe("Tasks under this deliverable. On push, missing tasks are created and existing ones converged."),
+});
+/** The full campaign recipe — a project plus its nested deliverables. */
+exports.CampaignRecipeSchema = zod_1.z.object({
+    name: zod_1.z
+        .string()
+        .min(1)
+        .describe("Display name of the campaign (project). Identifies the campaign when pushing."),
+    description: zod_1.z.string().optional().describe("Human description of the campaign."),
+    status: zod_1.z.string().optional().describe('Campaign status — a server enum, e.g. "NOT_STARTED".'),
+    startDate: zod_1.z.string().optional().describe("Campaign start date (ISO-8601)."),
+    dueDate: zod_1.z.string().optional().describe("Campaign due date (ISO-8601)."),
+    brandKitId: zod_1.z
+        .string()
+        .optional()
+        .describe("Associated brand kit UUID. A cross-reference, not an embedded object."),
+    labels: zod_1.z.array(zod_1.z.string()).default([]).describe("Free-form labels on the campaign."),
+    deliverables: zod_1.z
+        .array(exports.CampaignDeliverableSchema)
+        .default([])
+        .describe("Deliverables under the campaign. On push, missing deliverables (and their tasks) are created; existing tasks are converged."),
+});