@sitecoreai-labs/sitecoreai-cli 0.0.4

package/dist/recipe/tasks/plan.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRecipePlan = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("../../shared/errors");
+const io_1 = require("../io");
+const plan_1 = require("../plan");
+const shared_1 = require("./shared");
+/**
+ * `scai recipe plan` — read-then-diff against a tenant, no mutations.
+ *
+ * Operates on a pre-compiled IR file (the artifact from `scai recipe
+ * compile`). For the recipe-source workflow, use `scai recipe push
+ * --what-if` instead — it compiles in-memory and runs the planner.
+ */
+const runRecipePlan = async (options) => {
+    const logger = (0, shared_1.toLogger)(options);
+    const tenant = (0, shared_1.resolveTenant)(options);
+    if (!options.input) {
+        throw (0, errors_1.createCliError)("--input <ir.json> is required for `recipe plan`.", "INPUT_INVALID", {
+            hint: "Run `scai recipe compile` first, or use `scai recipe push --what-if` to plan from a recipe source.",
+        });
+    }
+    const ir = await (0, io_1.loadIr)(options.input);
+    const plan = await (0, plan_1.buildPlan)(ir, tenant.client);
+    const inputPath = options.input;
+    const outputPath = options.output ?? (0, io_1.defaultPlanPath)(ir.recipeHandle, node_path_1.default.dirname(node_path_1.default.resolve(inputPath)));
+    await (0, io_1.writePlan)(outputPath, plan);
+    if (logger.isJson()) {
+        logger.json({
+            command: "recipe.plan",
+            environment: tenant.envName,
+            recipeHandle: ir.recipeHandle,
+            input: inputPath,
+            output: outputPath,
+            summary: plan.summary,
+            actions: plan.actions.map((action) => ({
+                index: action.index,
+                op: action.operation.op,
+                label: action.operation.label,
+                status: action.status,
+                reason: action.reason,
+                diff: action.diff,
+            })),
+        });
+        return plan;
+    }
+    logger.info(`Plan for ${ir.recipeHandle} on ${tenant.envName}`, "cyan");
+    for (const action of plan.actions) {
+        const tag = formatActionTag(action.status);
+        logger.info(`  ${tag} ${action.operation.label}${action.reason ? ` — ${action.reason}` : ""}`);
+    }
+    logger.info(`  Summary: ${plan.summary.create} create / ${plan.summary.update} update / ${plan.summary.skip} skip${plan.summary.error ? ` / ${plan.summary.error} error` : ""}`, plan.summary.error ? "yellow" : "green");
+    logger.info(`  Plan written to ${outputPath}`);
+    return plan;
+};
+exports.runRecipePlan = runRecipePlan;
+const formatActionTag = (status) => {
+    switch (status) {
+        case "create":
+            return "[+]";
+        case "update":
+            return "[~]";
+        case "skip":
+            return "[ ]";
+        case "error":
+            return "[!]";
+    }
+};

package/dist/recipe/tasks/prune-defaults.d.ts

@@ -0,0 +1,90 @@
+import { Logger } from "../../shared/logger";
+import type { AuthoringApiClient } from "../api/client";
+import { type RecipeTenantOptions } from "./shared";
+/**
+ * `scai recipe prune-defaults` — remove the SXA Headless OOTB content
+ * that ships with every fresh site under `Available Renderings`,
+ * `Headless Variants`, and the per-site `Data` bucket. Registry installs
+ * ship their own renderings, variants, and datasources; the OOTB folders
+ * just noise up the authoring tree. Folder parents are preserved (we
+ * keep using `Available Renderings`, `Headless Variants`, and `Data`
+ * ourselves) — only the named child folders are removed. `Tags` under
+ * `Data` is left alone because authors typically populate it.
+ *
+ * Idempotent by design: each target is `getItem`-ed first, so a missing
+ * path is a clean skip rather than an error. Re-runs after a successful
+ * prune produce zero deletions. The deletion call itself also tolerates
+ * a "not found" / "may have been deleted by another user" response from
+ * the Authoring API — that race shows up when a parallel prune (or an
+ * author) removed the item between getItem and deleteItem.
+ */
+declare const DEFAULT_PRUNE_TARGETS: {
+    /**
+     * `Available Renderings` children to remove. SXA ships six default
+     * sections; we keep `FEaaS` (the Forms-as-a-Service rendering bucket)
+     * and `Forms` (the Sitecore Forms bucket) because they're not yet
+     * superseded by registry-side recipes.
+     */
+    readonly availableRenderings: readonly ["Media", "Navigation", "Page Content", "Page Structure"];
+    /**
+     * `Headless Variants` children to remove. SXA ships variants for each
+     * default rendering; registry-side recipes emit their own variants
+     * under `<headlessVariantsRoot>/<section>/<rendering>/<variant>` so
+     * the OOTB siblings just clutter the tree.
+     */
+    readonly headlessVariants: readonly ["Image", "LinkList", "Navigation", "PageContent", "Promo", "RichText", "Title"];
+    /**
+     * `Data` children to remove. SXA seeds these datasource buckets per
+     * site; registry recipes carry their own datasources, so the OOTB
+     * folders are pure clutter. `Tags` is intentionally omitted —
+     * authors populate it during normal content work.
+     */
+    readonly contentItems: readonly ["Images", "Link Lists", "Navigation Filters", "Promos", "Texts"];
+};
+export type PruneGroup = keyof typeof DEFAULT_PRUNE_TARGETS;
+export type PruneActionStatus = "deleted" | "missing" | "would-delete";
+export interface PruneAction {
+    group: PruneGroup;
+    path: string;
+    status: PruneActionStatus;
+    itemId?: string;
+}
+export interface RecipePruneDefaultsOptions extends RecipeTenantOptions {
+    /** Override `headlessVariantsRoot` from the env profile. */
+    headlessVariantsRoot?: string;
+    /** Override `availableRenderingsRoot` from the env profile. */
+    availableRenderingsRoot?: string;
+    /** Override `contentItemsRoot` from the env profile. */
+    contentItemsRoot?: string;
+    /** Print the deletions without applying them. */
+    whatIf?: boolean;
+    /** Bypass the env profile's `allowWrite` gate. */
+    allowWrite?: boolean;
+}
+export interface RecipePruneDefaultsResult {
+    environment: string;
+    whatIf: boolean;
+    actions: PruneAction[];
+    summary: {
+        deleted: number;
+        missing: number;
+        wouldDelete: number;
+    };
+}
+interface PruneCoreOptions {
+    client: AuthoringApiClient;
+    availableRenderingsRoot: string;
+    headlessVariantsRoot: string;
+    contentItemsRoot: string;
+    whatIf: boolean;
+    logger?: Logger;
+}
+/**
+ * Pure(ish) deletion loop — exposed for unit tests so they can drive
+ * the deletion contract against a fake `AuthoringApiClient` without
+ * threading a full sitecoreai.cli.json through `resolveTenant`.
+ */
+export declare const pruneDefaultsAgainstClient: (options: PruneCoreOptions) => Promise<PruneAction[]>;
+export declare const runRecipePruneDefaults: (options: RecipePruneDefaultsOptions) => Promise<RecipePruneDefaultsResult>;
+export {};
+//# sourceMappingURL=prune-defaults.d.ts.map

package/dist/recipe/tasks/prune-defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prune-defaults.d.ts","sourceRoot":"","sources":["../../../src/recipe/tasks/prune-defaults.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAIL,KAAK,mBAAmB,EACzB,MAAM,UAAU,CAAC;AAElB;;;;;;;;;;;;;;;;GAgBG;AAEH,QAAA,MAAM,qBAAqB;IACzB;;;;;OAKG;;IAEH;;;;;OAKG;;IAUH;;;;;OAKG;;CAEK,CAAC;AAEX,MAAM,MAAM,UAAU,GAAG,MAAM,OAAO,qBAAqB,CAAC;AAE5D,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,SAAS,GAAG,cAAc,CAAC;AAEvE,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,UAAU,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,iBAAiB,CAAC;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,0BAA2B,SAAQ,mBAAmB;IACrE,4DAA4D;IAC5D,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,+DAA+D;IAC/D,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,wDAAwD;IACxD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,iDAAiD;IACjD,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,kDAAkD;IAClD,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,yBAAyB;IACxC,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;CACpE;AA0CD,UAAU,gBAAgB;IACxB,MAAM,EAAE,kBAAkB,CAAC;IAC3B,uBAAuB,EAAE,MAAM,CAAC;IAChC,oBAAoB,EAAE,MAAM,CAAC;IAC7B,gBAAgB,EAAE,MAAM,CAAC;IACzB,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,GACrC,SAAS,gBAAgB,KACxB,OAAO,CAAC,WAAW,EAAE,CAuCvB,CAAC;AAEF,eAAO,MAAM,sBAAsB,GACjC,SAAS,0BAA0B,KAClC,OAAO,CAAC,yBAAyB,CAwEnC,CAAC"}

package/dist/recipe/tasks/prune-defaults.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRecipePruneDefaults = exports.pruneDefaultsAgainstClient = void 0;
+const errors_1 = require("../../shared/errors");
+const shared_1 = require("./shared");
+/**
+ * `scai recipe prune-defaults` — remove the SXA Headless OOTB content
+ * that ships with every fresh site under `Available Renderings`,
+ * `Headless Variants`, and the per-site `Data` bucket. Registry installs
+ * ship their own renderings, variants, and datasources; the OOTB folders
+ * just noise up the authoring tree. Folder parents are preserved (we
+ * keep using `Available Renderings`, `Headless Variants`, and `Data`
+ * ourselves) — only the named child folders are removed. `Tags` under
+ * `Data` is left alone because authors typically populate it.
+ *
+ * Idempotent by design: each target is `getItem`-ed first, so a missing
+ * path is a clean skip rather than an error. Re-runs after a successful
+ * prune produce zero deletions. The deletion call itself also tolerates
+ * a "not found" / "may have been deleted by another user" response from
+ * the Authoring API — that race shows up when a parallel prune (or an
+ * author) removed the item between getItem and deleteItem.
+ */
+const DEFAULT_PRUNE_TARGETS = {
+    /**
+     * `Available Renderings` children to remove. SXA ships six default
+     * sections; we keep `FEaaS` (the Forms-as-a-Service rendering bucket)
+     * and `Forms` (the Sitecore Forms bucket) because they're not yet
+     * superseded by registry-side recipes.
+     */
+    availableRenderings: ["Media", "Navigation", "Page Content", "Page Structure"],
+    /**
+     * `Headless Variants` children to remove. SXA ships variants for each
+     * default rendering; registry-side recipes emit their own variants
+     * under `<headlessVariantsRoot>/<section>/<rendering>/<variant>` so
+     * the OOTB siblings just clutter the tree.
+     */
+    headlessVariants: [
+        "Image",
+        "LinkList",
+        "Navigation",
+        "PageContent",
+        "Promo",
+        "RichText",
+        "Title",
+    ],
+    /**
+     * `Data` children to remove. SXA seeds these datasource buckets per
+     * site; registry recipes carry their own datasources, so the OOTB
+     * folders are pure clutter. `Tags` is intentionally omitted —
+     * authors populate it during normal content work.
+     */
+    contentItems: ["Images", "Link Lists", "Navigation Filters", "Promos", "Texts"],
+};
+const buildTargets = (availableRenderingsRoot, headlessVariantsRoot, contentItemsRoot) => {
+    const ar = availableRenderingsRoot.replace(/\/+$/, "");
+    const hv = headlessVariantsRoot.replace(/\/+$/, "");
+    const ci = contentItemsRoot.replace(/\/+$/, "");
+    return [
+        ...DEFAULT_PRUNE_TARGETS.availableRenderings.map((name) => ({
+            group: "availableRenderings",
+            path: `${ar}/${name}`,
+        })),
+        ...DEFAULT_PRUNE_TARGETS.headlessVariants.map((name) => ({
+            group: "headlessVariants",
+            path: `${hv}/${name}`,
+        })),
+        ...DEFAULT_PRUNE_TARGETS.contentItems.map((name) => ({
+            group: "contentItems",
+            path: `${ci}/${name}`,
+        })),
+    ];
+};
+/**
+ * Detect the Authoring GraphQL "item is gone" response. The shared
+ * graphql.ts wrapper joins all error.message strings into a single
+ * `Authoring GraphQL errors: <messages>` payload on a NETWORK CliError;
+ * we match the canonical Sitecore phrasing that fires when an itemId
+ * doesn't resolve at delete time.
+ */
+const isItemNotFoundError = (error) => {
+    if (!(error instanceof Error))
+        return false;
+    const message = error.message;
+    return (message.includes("was not found") ||
+        message.includes("may have been deleted by another user"));
+};
+/**
+ * Pure(ish) deletion loop — exposed for unit tests so they can drive
+ * the deletion contract against a fake `AuthoringApiClient` without
+ * threading a full sitecoreai.cli.json through `resolveTenant`.
+ */
+const pruneDefaultsAgainstClient = async (options) => {
+    const { client, availableRenderingsRoot, headlessVariantsRoot, contentItemsRoot, whatIf, logger } = options;
+    const targets = buildTargets(availableRenderingsRoot, headlessVariantsRoot, contentItemsRoot);
+    const actions = [];
+    for (const target of targets) {
+        const existing = await client.getItem({ path: target.path });
+        if (!existing) {
+            actions.push({ ...target, status: "missing" });
+            logger?.info(`  [skip] ${target.path} — not present`, "gray");
+            continue;
+        }
+        if (whatIf) {
+            actions.push({ ...target, status: "would-delete", itemId: existing.itemId });
+            logger?.info(`  [dry-run] would delete ${target.path}`, "yellow");
+            continue;
+        }
+        // Delete by itemId — `deleteItem({ path })` works too, but we
+        // already have the itemId from the existence check, and itemId
+        // selectors avoid Sitecore's leaf-path resolution edge cases.
+        try {
+            await client.deleteItem({ itemId: existing.itemId });
+            actions.push({ ...target, status: "deleted", itemId: existing.itemId });
+            logger?.info(`  [deleted] ${target.path}`, "green");
+        }
+        catch (error) {
+            // Authoring GraphQL surfaces concurrent-delete as a "was not found"
+            // / "may have been deleted by another user" message wrapped in a
+            // NETWORK CliError. Treat as a clean skip — the post-condition
+            // (item gone) is satisfied either way.
+            if (isItemNotFoundError(error)) {
+                actions.push({ ...target, status: "missing", itemId: existing.itemId });
+                logger?.info(`  [skip] ${target.path} — already deleted`, "gray");
+                continue;
+            }
+            throw error;
+        }
+    }
+    return actions;
+};
+exports.pruneDefaultsAgainstClient = pruneDefaultsAgainstClient;
+const runRecipePruneDefaults = async (options) => {
+    const logger = (0, shared_1.toLogger)(options);
+    const tenant = (0, shared_1.resolveTenant)(options);
+    const isDryRun = Boolean(options.whatIf);
+    if (!isDryRun) {
+        (0, shared_1.ensureAllowWrite)(tenant.root, tenant.envName, options.allowWrite);
+    }
+    const headlessVariantsRoot = options.headlessVariantsRoot ?? tenant.environment.headlessVariantsRoot;
+    const availableRenderingsRoot = options.availableRenderingsRoot ?? tenant.environment.availableRenderingsRoot;
+    const contentItemsRoot = options.contentItemsRoot ?? tenant.environment.contentItemsRoot;
+    if (!headlessVariantsRoot || !availableRenderingsRoot || !contentItemsRoot) {
+        const missing = [
+            !headlessVariantsRoot && "headlessVariantsRoot",
+            !availableRenderingsRoot && "availableRenderingsRoot",
+            !contentItemsRoot && "contentItemsRoot",
+        ]
+            .filter(Boolean)
+            .join(", ");
+        throw (0, errors_1.createCliError)(`Recipe prune-defaults missing root path(s): ${missing} not configured for environment '${tenant.envName}'.`, "INPUT_INVALID", {
+            hint: `Add 'headlessVariantsRoot', 'availableRenderingsRoot', and 'contentItemsRoot' to envProfiles.${tenant.envName} in sitecoreai.cli.json (or pass --headless-variants-root / --available-renderings-root / --content-items-root).`,
+        });
+    }
+    if (!logger.isJson()) {
+        logger.info(`${isDryRun ? "Dry-run prune-defaults" : "Pruning SXA defaults"} on ${tenant.envName}`, "cyan");
+    }
+    const actions = await (0, exports.pruneDefaultsAgainstClient)({
+        client: tenant.client,
+        availableRenderingsRoot,
+        headlessVariantsRoot,
+        contentItemsRoot,
+        whatIf: isDryRun,
+        logger: logger.isJson() ? undefined : logger,
+    });
+    const summary = {
+        deleted: actions.filter((a) => a.status === "deleted").length,
+        missing: actions.filter((a) => a.status === "missing").length,
+        wouldDelete: actions.filter((a) => a.status === "would-delete").length,
+    };
+    if (logger.isJson()) {
+        logger.json({
+            command: "recipe.prune-defaults",
+            environment: tenant.envName,
+            whatIf: isDryRun,
+            summary,
+            actions,
+        });
+    }
+    else {
+        logger.info(`Summary: ${summary.deleted} deleted / ${summary.missing} not present${summary.wouldDelete ? ` / ${summary.wouldDelete} would-delete` : ""}`, summary.deleted > 0 || summary.wouldDelete > 0 ? "green" : "gray");
+    }
+    return { environment: tenant.envName, whatIf: isDryRun, actions, summary };
+};
+exports.runRecipePruneDefaults = runRecipePruneDefaults;

package/dist/recipe/tasks/push.d.ts

@@ -0,0 +1,18 @@
+import { type ExecutionResult } from "../execute";
+import { type RecipePushOptions } from "./shared";
+/**
+ * `scai recipe push` — apply recipes to a tenant.
+ *
+ * Input resolution:
+ *   - `--input <file>` — single recipe (`.recipe.ts/.recipe.json`) or IR
+ *     (`.ir.json`). The file extension picks the path: recipes are
+ *     compiled in-memory, IRs are loaded directly.
+ *   - default: expand the config `recipes` glob and push each match in
+ *     turn (one IR per recipe; per-recipe events).
+ *
+ * Honors `--what-if` (becomes plan-only) and `--allow-write` (the
+ * scai-wide safety gate). Streams progress as `task-progress`-style
+ * events in JSON mode; renders a per-op summary in human mode.
+ */
+export declare const runRecipePush: (options: RecipePushOptions) => Promise<ExecutionResult[]>;
+//# sourceMappingURL=push.d.ts.map

package/dist/recipe/tasks/push.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"push.d.ts","sourceRoot":"","sources":["../../../src/recipe/tasks/push.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAkC,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAIlF,OAAO,EAML,KAAK,iBAAiB,EACvB,MAAM,UAAU,CAAC;AAiDlB;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,aAAa,GAAU,SAAS,iBAAiB,KAAG,OAAO,CAAC,eAAe,EAAE,CA0YzF,CAAC"}