@sitecoreai-labs/sitecoreai-cli 0.0.4 → 0.1.0

package/dist/commands/brief/types.js

@@ -0,0 +1,129 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBriefTypesCommand = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const commander_1 = require("commander");
+const tasks_1 = require("../../brief/tasks");
+const brief_types_1 = require("../../brief/api/brief-types");
+const cli_tasks_1 = require("../../shared/cli-tasks");
+const shared_1 = require("../shared");
+const readJsonFile = (path) => {
+    try {
+        return JSON.parse(node_fs_1.default.readFileSync(path, "utf8"));
+    }
+    catch (error) {
+        throw (0, cli_tasks_1.inputError)(`Could not read JSON from ${path}: ${error instanceof Error ? error.message : String(error)}`, "Pass --file <path> pointing at a valid CreateBriefTypeInput JSON document.");
+    }
+};
+const createListCommand = () => {
+    const command = new commander_1.Command("list").description("List brief types — the schema templates that briefs are built against.");
+    (0, shared_1.addOrgScopeOptions)(command);
+    (0, shared_1.addConfigOption)(command);
+    (0, shared_1.addVerbosityOptions)(command);
+    command.action(async (options) => {
+        await (0, tasks_1.runBriefTypes)(options);
+    });
+    return command;
+};
+const createGetCommand = () => {
+    const command = new commander_1.Command("get")
+        .description("Read a single brief type by id.")
+        .argument("<briefTypeId>", "Brief type UUID");
+    (0, shared_1.addOrgScopeOptions)(command);
+    (0, shared_1.addConfigOption)(command);
+    (0, shared_1.addVerbosityOptions)(command);
+    command.action(async (briefTypeId, options) => {
+        await (0, tasks_1.runBriefTypeGet)({ ...options, briefTypeId });
+    });
+    return command;
+};
+const createCreateCommand = () => {
+    const command = new commander_1.Command("create")
+        .description("Create a new brief type from a JSON document.")
+        .addOption(new commander_1.Option("-f, --file <path>", "Path to a JSON file matching CreateBriefTypeInput").makeOptionMandatory(true));
+    (0, shared_1.addOrgScopeOptions)(command);
+    (0, shared_1.addConfigOption)(command);
+    (0, shared_1.addVerbosityOptions)(command);
+    (0, shared_1.addApplyOption)(command);
+    (0, shared_1.addWhatIfOption)(command);
+    command.action((0, shared_1.withApplyGate)(async (options) => {
+        const input = (0, brief_types_1.assertCreateBriefTypeInput)(readJsonFile(options.file));
+        await (0, tasks_1.runBriefTypeCreate)({ ...options, input });
+    }));
+    return command;
+};
+const createUpdateCommand = () => {
+    const command = new commander_1.Command("update")
+        .description("Replace a brief type via PUT (full-replacement). Read first if you only want to change one field.")
+        .argument("<briefTypeId>", "Brief type UUID")
+        .addOption(new commander_1.Option("-f, --file <path>", "Path to a JSON file matching CreateBriefTypeInput").makeOptionMandatory(true));
+    (0, shared_1.addOrgScopeOptions)(command);
+    (0, shared_1.addConfigOption)(command);
+    (0, shared_1.addVerbosityOptions)(command);
+    (0, shared_1.addApplyOption)(command);
+    (0, shared_1.addWhatIfOption)(command);
+    command.action(async (briefTypeId, options) => {
+        await (0, shared_1.withApplyGate)(async (opts) => {
+            const input = (0, brief_types_1.assertCreateBriefTypeInput)(readJsonFile(opts.file));
+            await (0, tasks_1.runBriefTypeUpdate)({ ...opts, briefTypeId, input });
+        })(options);
+    });
+    return command;
+};
+const createDeleteCommand = () => {
+    const command = new commander_1.Command("delete")
+        .description("Delete a brief type. Requires --apply; non-TTY callers must also pass --force.")
+        .argument("<briefTypeId>", "Brief type UUID")
+        .addOption(new commander_1.Option("--force", "Skip TTY confirmation prompt (required for non-TTY agents)."));
+    (0, shared_1.addOrgScopeOptions)(command);
+    (0, shared_1.addConfigOption)(command);
+    (0, shared_1.addVerbosityOptions)(command);
+    (0, shared_1.addApplyOption)(command);
+    (0, shared_1.addWhatIfOption)(command);
+    command.action(async (briefTypeId, options) => {
+        await (0, shared_1.withApplyGate)(async (opts) => {
+            if (!opts.whatIf) {
+                const confirmed = await (0, cli_tasks_1.confirmDestructive)(`Delete brief type ${briefTypeId}? This cannot be undone.`, opts.force);
+                if (!confirmed) {
+                    process.stderr.write("Aborted.\n");
+                    return;
+                }
+            }
+            await (0, tasks_1.runBriefTypeDelete)({ ...opts, briefTypeId });
+        })(options);
+    });
+    return command;
+};
+/**
+ * `scai ops brief types …` — full CRUD over Sitecore Content Operations
+ * Brief types (the schema templates briefs are built against).
+ *
+ * v1 surface (verified 2026-05-15):
+ *   - list                     — list types in the tenant
+ *   - get <briefTypeId>        — read one type
+ *   - create -f <file>         — POST new type (requires --apply)
+ *   - update <id> -f <file>    — PUT-replace type (requires --apply)
+ *   - delete <id>              — DELETE type (requires --apply; --force for non-TTY)
+ *
+ * Backward compat: `scai ops brief types` with no subcommand still lists,
+ * matching the pre-CRUD behaviour.
+ */
+const createBriefTypesCommand = () => {
+    const command = new commander_1.Command("types").description("Brief type operations (list, get, create, update, delete).");
+    command.addCommand(createListCommand(), { isDefault: true });
+    command.addCommand(createGetCommand());
+    command.addCommand(createCreateCommand());
+    command.addCommand(createUpdateCommand());
+    command.addCommand(createDeleteCommand());
+    command.addHelpText("after", "\nExamples:\n" +
+        "  $ scai ops brief types list -n agents\n" +
+        "  $ scai ops brief types get <id> -n agents\n" +
+        "  $ scai ops brief types create -f ./new-type.json -n agents --apply\n" +
+        "  $ scai ops brief types update <id> -f ./type.json -n agents --apply\n" +
+        "  $ scai ops brief types delete <id> -n agents --apply --force\n");
+    return command;
+};
+exports.createBriefTypesCommand = createBriefTypesCommand;

package/dist/commands/campaign/index.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const createCampaignCommand: () => Command;

package/dist/commands/campaign/index.js

@@ -0,0 +1,309 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCampaignCommand = void 0;
+const commander_1 = require("commander");
+const tasks_1 = require("../../campaigns/tasks");
+const cli_tasks_1 = require("../../shared/cli-tasks");
+const sync_1 = require("./sync");
+const shared_1 = require("../shared");
+/**
+ * `scai ops campaign …` — Sitecore Orchestrate API surface.
+ *
+ * A campaign is an Orchestrate `project`; projects own deliverables,
+ * deliverables own tasks. Read verbs are always available; write verbs
+ * (`create`, `update`, `delete`) dry-run unless `--apply` is passed.
+ *
+ * `delete` verbs hit Orchestrate DELETE endpoints that were never
+ * captured during reverse-engineering — they are wired optimistically
+ * per REST conventions and marked UNVERIFIED. Smoke-test with
+ * `scripts/_smoke-campaign-delete.ts` before relying on them.
+ *
+ *   scai ops campaign list
+ *   scai ops campaign show <campaignId>
+ *   scai ops campaign create --name "Spring Launch" --apply
+ *   scai ops campaign delete <campaignId> --apply --force
+ *   scai ops campaign users
+ *   scai ops campaign deliverable create|delete <campaignId> …
+ *   scai ops campaign task list|show|create|update|delete …
+ */
+const createListCommand = () => {
+    const command = new commander_1.Command("list").description("List campaigns in the tenant.");
+    (0, shared_1.addOrgScopeOptions)(command);
+    (0, shared_1.addConfigOption)(command);
+    (0, shared_1.addVerbosityOptions)(command);
+    command.addOption(new commander_1.Option("--limit <n>", "Page size").argParser(Number));
+    command.action(async (options) => {
+        await (0, tasks_1.runCampaignList)(options);
+    });
+    return command;
+};
+const createShowCommand = () => {
+    const command = new commander_1.Command("show")
+        .description("Show a campaign with its deliverables and tasks.")
+        .argument("<campaignId>", "Campaign (project) UUID");
+    (0, shared_1.addOrgScopeOptions)(command);
+    (0, shared_1.addConfigOption)(command);
+    (0, shared_1.addVerbosityOptions)(command);
+    command.action(async (campaignId, options) => {
+        await (0, tasks_1.runCampaignShow)({ ...options, campaignId });
+    });
+    return command;
+};
+const createUsersCommand = () => {
+    const command = new commander_1.Command("users").description("List users available as campaign members / task assignees.");
+    (0, shared_1.addOrgScopeOptions)(command);
+    (0, shared_1.addConfigOption)(command);
+    (0, shared_1.addVerbosityOptions)(command);
+    command.action(async (options) => {
+        await (0, tasks_1.runCampaignUsers)(options);
+    });
+    return command;
+};
+const createCreateCommand = () => {
+    const command = new commander_1.Command("create")
+        .description("Create a campaign. Requires --apply.")
+        .requiredOption("--name <name>", "Campaign name")
+        .option("--description <text>", "Campaign description")
+        .option("--start-date <iso>", "Start date (ISO-8601)")
+        .option("--due-date <iso>", "Due date (ISO-8601)")
+        .option("--brandkit-id <id>", "Associated brand kit UUID")
+        .option("--status <status>", "Initial status", "NOT_STARTED");
+    (0, shared_1.addOrgScopeOptions)(command);
+    (0, shared_1.addConfigOption)(command);
+    (0, shared_1.addVerbosityOptions)(command);
+    (0, shared_1.addApplyOption)(command);
+    (0, shared_1.addWhatIfOption)(command);
+    command.action((0, shared_1.withApplyGate)(async (options) => {
+        await (0, tasks_1.runCampaignCreate)({
+            ...options,
+            input: {
+                name: options.name,
+                description: options.description,
+                start_date: options.startDate,
+                due_date: options.dueDate,
+                brandkit_id: options.brandkitId,
+                status: options.status,
+            },
+        });
+    }));
+    return command;
+};
+const createDeleteCommand = () => {
+    const command = new commander_1.Command("delete")
+        .description("Delete a campaign. UNVERIFIED — the Orchestrate DELETE endpoint was never " +
+        "captured; inferred from REST conventions. Requires --apply; non-TTY callers " +
+        "must also pass --force.")
+        .argument("<campaignId>", "Campaign (project) UUID")
+        .addOption(new commander_1.Option("--force", "Skip TTY confirmation prompt (required for non-TTY agents)."));
+    (0, shared_1.addOrgScopeOptions)(command);
+    (0, shared_1.addConfigOption)(command);
+    (0, shared_1.addVerbosityOptions)(command);
+    (0, shared_1.addApplyOption)(command);
+    (0, shared_1.addWhatIfOption)(command);
+    command.action(async (campaignId, options) => {
+        await (0, shared_1.withApplyGate)(async (opts) => {
+            if (!opts.whatIf) {
+                const confirmed = await (0, cli_tasks_1.confirmDestructive)(`Delete campaign ${campaignId}? This cannot be undone.`, opts.force);
+                if (!confirmed) {
+                    process.stderr.write("Aborted.\n");
+                    return;
+                }
+            }
+            await (0, tasks_1.runCampaignDelete)({ ...opts, campaignId });
+        })(options);
+    });
+    return command;
+};
+const createDeliverableCommand = () => {
+    const deliverable = new commander_1.Command("deliverable").description("Deliverable operations.");
+    const create = new commander_1.Command("create")
+        .description("Create a deliverable under a campaign. Requires --apply.")
+        .argument("<campaignId>", "Campaign (project) UUID")
+        .requiredOption("--name <name>", "Deliverable name")
+        .option("--due-date <iso>", "Due date (ISO-8601)")
+        .option("--funnel-stage <stage>", "Funnel stage, e.g. TOP")
+        .option("--funnel-tactics <csv>", "Comma-separated funnel tactics")
+        .option("--status <status>", "Initial status", "NOT_STARTED");
+    (0, shared_1.addOrgScopeOptions)(create);
+    (0, shared_1.addConfigOption)(create);
+    (0, shared_1.addVerbosityOptions)(create);
+    (0, shared_1.addApplyOption)(create);
+    (0, shared_1.addWhatIfOption)(create);
+    create.action(async (campaignId, options) => {
+        await (0, shared_1.withApplyGate)(async (opts) => {
+            await (0, tasks_1.runDeliverableCreate)({
+                ...opts,
+                campaignId,
+                input: {
+                    name: opts.name,
+                    due_date: opts.dueDate,
+                    funnel_stage: opts.funnelStage,
+                    funnel_tactics: opts.funnelTactics
+                        ? opts.funnelTactics.split(",").map((t) => t.trim())
+                        : undefined,
+                    status: opts.status,
+                },
+            });
+        })(options);
+    });
+    const remove = new commander_1.Command("delete")
+        .description("Delete a deliverable under a campaign. UNVERIFIED — the Orchestrate DELETE " +
+        "endpoint was never captured; inferred from REST conventions. Requires --apply; " +
+        "non-TTY callers must also pass --force.")
+        .argument("<campaignId>", "Campaign (project) UUID")
+        .argument("<deliverableId>", "Deliverable UUID")
+        .addOption(new commander_1.Option("--force", "Skip TTY confirmation prompt (required for non-TTY agents)."));
+    (0, shared_1.addOrgScopeOptions)(remove);
+    (0, shared_1.addConfigOption)(remove);
+    (0, shared_1.addVerbosityOptions)(remove);
+    (0, shared_1.addApplyOption)(remove);
+    (0, shared_1.addWhatIfOption)(remove);
+    remove.action(async (campaignId, deliverableId, options) => {
+        await (0, shared_1.withApplyGate)(async (opts) => {
+            if (!opts.whatIf) {
+                const confirmed = await (0, cli_tasks_1.confirmDestructive)(`Delete deliverable ${deliverableId}? This cannot be undone.`, opts.force);
+                if (!confirmed) {
+                    process.stderr.write("Aborted.\n");
+                    return;
+                }
+            }
+            await (0, tasks_1.runDeliverableDelete)({ ...opts, campaignId, deliverableId });
+        })(options);
+    });
+    deliverable.addCommand(create);
+    deliverable.addCommand(remove);
+    return deliverable;
+};
+const createTaskCommand = () => {
+    const task = new commander_1.Command("task").description("Task operations.");
+    const list = new commander_1.Command("list")
+        .description("List tasks under a deliverable.")
+        .argument("<campaignId>", "Campaign UUID")
+        .argument("<deliverableId>", "Deliverable UUID");
+    (0, shared_1.addOrgScopeOptions)(list);
+    (0, shared_1.addConfigOption)(list);
+    (0, shared_1.addVerbosityOptions)(list);
+    list.action(async (campaignId, deliverableId, options) => {
+        await (0, tasks_1.runTaskList)({ ...options, campaignId, deliverableId });
+    });
+    const show = new commander_1.Command("show")
+        .description("Show one task.")
+        .argument("<campaignId>", "Campaign UUID")
+        .argument("<deliverableId>", "Deliverable UUID")
+        .argument("<taskId>", "Task UUID");
+    (0, shared_1.addOrgScopeOptions)(show);
+    (0, shared_1.addConfigOption)(show);
+    (0, shared_1.addVerbosityOptions)(show);
+    show.action(async (campaignId, deliverableId, taskId, options) => {
+        await (0, tasks_1.runTaskShow)({ ...options, campaignId, deliverableId, taskId });
+    });
+    const create = new commander_1.Command("create")
+        .description("Create a task under a deliverable. Requires --apply.")
+        .argument("<campaignId>", "Campaign UUID")
+        .argument("<deliverableId>", "Deliverable UUID")
+        .requiredOption("--name <name>", "Task name")
+        .option("--due-date <iso>", "Due date (ISO-8601)")
+        .option("--status <status>", "Initial status", "NOT_STARTED");
+    (0, shared_1.addOrgScopeOptions)(create);
+    (0, shared_1.addConfigOption)(create);
+    (0, shared_1.addVerbosityOptions)(create);
+    (0, shared_1.addApplyOption)(create);
+    (0, shared_1.addWhatIfOption)(create);
+    create.action(async (campaignId, deliverableId, options) => {
+        await (0, shared_1.withApplyGate)(async (opts) => {
+            await (0, tasks_1.runTaskCreate)({
+                ...opts,
+                campaignId,
+                deliverableId,
+                input: { name: opts.name, due_date: opts.dueDate, status: opts.status },
+            });
+        })(options);
+    });
+    const update = new commander_1.Command("update")
+        .description("Replace a task via PUT (full-replacement). Requires --apply.")
+        .argument("<campaignId>", "Campaign UUID")
+        .argument("<deliverableId>", "Deliverable UUID")
+        .argument("<taskId>", "Task UUID")
+        .requiredOption("--name <name>", "Task name")
+        .option("--due-date <iso>", "Due date (ISO-8601)")
+        .option("--status <status>", "Status")
+        .option("--priority <priority>", "Priority")
+        .option("--description <html>", "Description (HTML)")
+        .option("--assignee <userId>", "Assignee — an Auth0 subject");
+    (0, shared_1.addOrgScopeOptions)(update);
+    (0, shared_1.addConfigOption)(update);
+    (0, shared_1.addVerbosityOptions)(update);
+    (0, shared_1.addApplyOption)(update);
+    (0, shared_1.addWhatIfOption)(update);
+    update.action(async (campaignId, deliverableId, taskId, options) => {
+        await (0, shared_1.withApplyGate)(async (opts) => {
+            await (0, tasks_1.runTaskUpdate)({
+                ...opts,
+                campaignId,
+                deliverableId,
+                taskId,
+                input: {
+                    name: opts.name,
+                    due_date: opts.dueDate,
+                    status: opts.status,
+                    priority: opts.priority,
+                    description: opts.description,
+                    assignee: opts.assignee,
+                },
+            });
+        })(options);
+    });
+    const remove = new commander_1.Command("delete")
+        .description("Delete a task under a deliverable. UNVERIFIED — the Orchestrate DELETE " +
+        "endpoint was never captured; inferred from REST conventions. Requires --apply; " +
+        "non-TTY callers must also pass --force.")
+        .argument("<campaignId>", "Campaign UUID")
+        .argument("<deliverableId>", "Deliverable UUID")
+        .argument("<taskId>", "Task UUID")
+        .addOption(new commander_1.Option("--force", "Skip TTY confirmation prompt (required for non-TTY agents)."));
+    (0, shared_1.addOrgScopeOptions)(remove);
+    (0, shared_1.addConfigOption)(remove);
+    (0, shared_1.addVerbosityOptions)(remove);
+    (0, shared_1.addApplyOption)(remove);
+    (0, shared_1.addWhatIfOption)(remove);
+    remove.action(async (campaignId, deliverableId, taskId, options) => {
+        await (0, shared_1.withApplyGate)(async (opts) => {
+            if (!opts.whatIf) {
+                const confirmed = await (0, cli_tasks_1.confirmDestructive)(`Delete task ${taskId}? This cannot be undone.`, opts.force);
+                if (!confirmed) {
+                    process.stderr.write("Aborted.\n");
+                    return;
+                }
+            }
+            await (0, tasks_1.runTaskDelete)({ ...opts, campaignId, deliverableId, taskId });
+        })(options);
+    });
+    task.addCommand(list);
+    task.addCommand(show);
+    task.addCommand(create);
+    task.addCommand(update);
+    task.addCommand(remove);
+    return task;
+};
+const createCampaignCommand = () => {
+    const command = new commander_1.Command("campaign").description("Sitecore Orchestrate campaigns — projects, deliverables, and tasks.");
+    command.addCommand(createListCommand());
+    command.addCommand(createShowCommand());
+    command.addCommand(createCreateCommand());
+    command.addCommand(createDeleteCommand());
+    command.addCommand(createUsersCommand());
+    command.addCommand(createDeliverableCommand());
+    command.addCommand(createTaskCommand());
+    command.addCommand((0, sync_1.createCampaignSyncCommand)());
+    command.addHelpText("after", "\nExamples:\n" +
+        "  $ scai ops campaign list -n agents\n" +
+        "  $ scai ops campaign show <campaignId> -n agents\n" +
+        "  $ scai ops campaign create --name 'Spring Launch' --apply -n agents\n" +
+        "  $ scai ops campaign delete <campaignId> --apply --force   # UNVERIFIED endpoint\n" +
+        "  $ scai ops campaign deliverable create <campaignId> --name 'Landing page' --apply\n" +
+        "  $ scai ops campaign deliverable delete <campaignId> <deliverableId> --apply --force\n" +
+        "  $ scai ops campaign task create <campaignId> <deliverableId> --name 'Draft copy' --apply\n" +
+        "  $ scai ops campaign task delete <campaignId> <deliverableId> <taskId> --apply --force\n");
+    return command;
+};
+exports.createCampaignCommand = createCampaignCommand;

package/dist/commands/campaign/sync.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `scai ops campaign sync` — pull, diff, and push a campaign as a
+ * declarative recipe. The recipe / sync model — see
+ * docs/recipe-sync-architecture.md.
+ *
+ *   pull  capture a live campaign into a recipe file
+ *   diff  show the plan to converge a campaign onto a recipe
+ *   push  apply that plan (dry-run unless --allow-write)
+ */
+import { Command } from "commander";
+/** `scai ops campaign sync` — recipe pull / diff / push verbs for campaigns. */
+export declare const createCampaignSyncCommand: () => Command;

package/dist/commands/campaign/sync.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCampaignSyncCommand = void 0;
+/**
+ * `scai ops campaign sync` — pull, diff, and push a campaign as a
+ * declarative recipe. The recipe / sync model — see
+ * docs/recipe-sync-architecture.md.
+ *
+ *   pull  capture a live campaign into a recipe file
+ *   diff  show the plan to converge a campaign onto a recipe
+ *   push  apply that plan (dry-run unless --allow-write)
+ */
+const commander_1 = require("commander");
+const shared_1 = require("../shared");
+const recipe_1 = require("../../campaigns/recipe");
+const root_config_1 = require("../../config/root-config");
+const cli_tasks_1 = require("../../shared/cli-tasks");
+const sync_1 = require("../../sync");
+/** Slugify a campaign name for a default recipe filename. */
+const slug = (value) => value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "") || "campaign";
+/** Build the `SyncContext` for a campaign sync command invocation. */
+const buildContext = (options, logger) => {
+    const configPath = options.config ?? process.cwd();
+    const root = (0, root_config_1.readRootConfiguration)(configPath, options.environmentName);
+    return {
+        environmentName: options.environmentName ?? root.defaultEnvironment,
+        configPath,
+        logger,
+    };
+};
+const PLAN_MARK = { create: "+", update: "~", delete: "-", noop: "=" };
+/** Render a plan to the logger — one line per change, then a tally. */
+const printPlan = (logger, plan) => {
+    if (plan.changes.length === 0) {
+        logger.info("Plan: no changes.");
+        return;
+    }
+    for (const change of plan.changes) {
+        logger.info(`  ${PLAN_MARK[change.kind] ?? "?"} ${change.summary}`);
+    }
+    const tally = (0, sync_1.summarizePlan)(plan);
+    logger.info(`Plan: ${tally.create} create, ${tally.update} update, ${tally.delete} delete, ${tally.noop} unchanged.`);
+};
+const createPullCommand = () => {
+    const command = new commander_1.Command("pull")
+        .description("Capture a live campaign as a recipe file.")
+        .requiredOption("--campaign <name>", "Campaign display name")
+        .addOption(new commander_1.Option("--file <path>", "Output recipe file (default: <campaign>.campaign.yaml)"));
+    (0, shared_1.addEnvironmentOption)(command);
+    (0, shared_1.addConfigOption)(command);
+    (0, shared_1.addVerbosityOptions)(command);
+    command.action(async (options) => {
+        const logger = (0, cli_tasks_1.toLogger)(options);
+        const ctx = buildContext(options, logger);
+        const campaignName = options.campaign ?? "";
+        const recipe = await (0, sync_1.syncPull)(recipe_1.campaignKind, { kind: recipe_1.campaignKind.name, id: campaignName }, ctx);
+        if (!recipe) {
+            throw (0, cli_tasks_1.inputError)(`Campaign "${campaignName}" not found.`, "List campaigns with `scai ops campaign list`.");
+        }
+        const file = options.file ?? `${slug(campaignName)}.campaign.yaml`;
+        (0, sync_1.writeRecipe)(file, recipe);
+        logger.info(`Pulled "${campaignName}" -> ${file}`, "green");
+    });
+    return command;
+};
+const createDiffCommand = () => {
+    const command = new commander_1.Command("diff")
+        .description("Show the plan to converge a campaign onto a recipe file.")
+        .requiredOption("--file <path>", "Recipe file (.yaml / .json)");
+    (0, shared_1.addEnvironmentOption)(command);
+    (0, shared_1.addConfigOption)(command);
+    (0, shared_1.addVerbosityOptions)(command);
+    command.action(async (options) => {
+        const logger = (0, cli_tasks_1.toLogger)(options);
+        const ctx = buildContext(options, logger);
+        const recipe = (0, sync_1.loadRecipe)(options.file ?? "", recipe_1.campaignKind.schema);
+        const plan = await (0, sync_1.syncDiff)(recipe_1.campaignKind, recipe, { kind: recipe_1.campaignKind.name, id: recipe.name }, ctx);
+        printPlan(logger, plan);
+    });
+    return command;
+};
+const createPushCommand = () => {
+    const command = new commander_1.Command("push")
+        .description("Converge a campaign onto a recipe file. Dry-run unless --allow-write.")
+        .requiredOption("--file <path>", "Recipe file (.yaml / .json)")
+        .addOption(new commander_1.Option("--allow-write", "Apply the plan (default is a dry-run)"))
+        .addOption(new commander_1.Option("--prune", "Include delete changes (off by default)"));
+    (0, shared_1.addEnvironmentOption)(command);
+    (0, shared_1.addConfigOption)(command);
+    (0, shared_1.addVerbosityOptions)(command);
+    command.action(async (options) => {
+        const logger = (0, cli_tasks_1.toLogger)(options);
+        const ctx = buildContext(options, logger);
+        const recipe = (0, sync_1.loadRecipe)(options.file ?? "", recipe_1.campaignKind.schema);
+        const mode = options.allowWrite ? "apply" : "what-if";
+        const outcome = await (0, sync_1.syncPush)(recipe_1.campaignKind, recipe, { kind: recipe_1.campaignKind.name, id: recipe.name }, ctx, { mode, prune: options.prune });
+        printPlan(logger, outcome.plan);
+        if (outcome.result) {
+            logger.info(`Applied ${outcome.result.applied.length} change(s); ${outcome.result.skipped.length} skipped.`, "green");
+        }
+        else if ((0, sync_1.planIsNoop)(outcome.plan)) {
+            logger.info("Already converged — nothing to do.", "green");
+        }
+        else {
+            logger.info("Dry-run. Re-run with --allow-write to apply.");
+        }
+    });
+    return command;
+};
+/** `scai ops campaign sync` — recipe pull / diff / push verbs for campaigns. */
+const createCampaignSyncCommand = () => {
+    const command = new commander_1.Command("sync").description("Pull, diff, and push a campaign as a declarative recipe.");
+    command.addCommand(createPullCommand());
+    command.addCommand(createDiffCommand());
+    command.addCommand(createPushCommand());
+    return command;
+};
+exports.createCampaignSyncCommand = createCampaignSyncCommand;

package/dist/commands/cleanup/archive.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const createCleanupArchiveCommand: () => Command;

package/dist/commands/cleanup/archive.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCleanupArchiveCommand = void 0;
+const commander_1 = require("commander");
+const archive_purge_1 = require("../../hygiene/tasks/cleanup/archive-purge");
+const shared_1 = require("../shared");
+const shared_2 = require("./shared");
+const createCleanupArchiveCommand = () => {
+    const command = new commander_1.Command("archive").description("Operations against the Sitecore archive (recycle bin)");
+    const purge = new commander_1.Command("purge").description("Permanently delete archived items older than --older-than-days N");
+    (0, shared_2.addCleanupBaseOptions)(purge);
+    purge.option("--older-than-days <count>", "Only purge archived items older than N days (default: 30)", (v) => parseInt(v, 10));
+    purge.option("--limit <count>", "Cap on items purged in one run (default: 1000)", (v) => parseInt(v, 10));
+    purge.option("--archive-name <name>", "Limit to a specific archive (default: all archives)");
+    purge.option("--page-size <count>", "Page size for archive listing (default: 100)", (v) => parseInt(v, 10));
+    purge.option("--concurrency <count>", "Concurrency for delete calls (default: 4)", (v) => parseInt(v, 10));
+    purge.action((0, shared_1.withApplyGate)(archive_purge_1.runCleanupArchivePurge));
+    command.addCommand(purge);
+    return command;
+};
+exports.createCleanupArchiveCommand = createCleanupArchiveCommand;

package/dist/commands/cleanup/dead-templates.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const createCleanupDeadTemplatesCommand: () => Command;

package/dist/commands/cleanup/dead-templates.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCleanupDeadTemplatesCommand = void 0;
+const commander_1 = require("commander");
+const dead_templates_1 = require("../../hygiene/tasks/cleanup/dead-templates");
+const shared_1 = require("../shared");
+const shared_2 = require("./shared");
+const createCleanupDeadTemplatesCommand = () => {
+    const command = new commander_1.Command("dead-templates").description("Delete templates that have zero items derived from them");
+    const purge = new commander_1.Command("purge").description("Delete dead templates, optionally cleaning up empty template folders left behind");
+    (0, shared_2.addCleanupBaseOptions)(purge);
+    purge.option("--root <path>", "Template-tree root (default: /sitecore/templates/Project)");
+    purge.option("--limit <count>", "Cap on templates inspected (default: 5000)", (v) => parseInt(v, 10));
+    purge.option("--concurrency <count>", "Delete concurrency (default: 4)", (v) => parseInt(v, 10));
+    purge.option("--no-cleanup-empty-folders", "Skip the recursive empty-folder cleanup after templates are deleted (default: clean up)");
+    purge.option("--index <name>", "Override the search index name (default: sitecore_master_index)");
+    purge.action((0, shared_1.withApplyGate)(dead_templates_1.runCleanupDeadTemplates));
+    command.addCommand(purge);
+    return command;
+};
+exports.createCleanupDeadTemplatesCommand = createCleanupDeadTemplatesCommand;

package/dist/commands/cleanup/duplicates.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const createCleanupDuplicatesCommand: () => Command;