@sitecoreai-labs/sitecoreai-cli 0.0.4 → 0.1.0

package/dist/mcp/tools/campaign.js

@@ -0,0 +1,342 @@
+"use strict";
+/**
+ * Campaign domain — read + write tools over the Sitecore Orchestrate API.
+ *
+ * Two tools, workflow-shaped:
+ *
+ *   - `campaign_inspect` (read) discriminates on `verb` — list campaigns,
+ *     show one campaign (deliverables/tasks inline), list tasks under a
+ *     deliverable, show one task, or list the member directory.
+ *   - `campaign_manage` (write) discriminates on `resource` + `verb` —
+ *     create a campaign/deliverable/task, update a task, or delete a
+ *     campaign/deliverable/task.
+ *
+ * A campaign is an Orchestrate `project`. Built from a HAR capture
+ * 2026-05-15; the OAuth scope is unverified — see
+ * `docs/campaigns-followups.md`. The `delete` verb hits Orchestrate
+ * DELETE endpoints that were never captured: they are wired
+ * optimistically per REST conventions and remain UNVERIFIED.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCampaignTools = void 0;
+const zod_1 = require("zod");
+const tasks_1 = require("../../campaigns/tasks");
+const errors_1 = require("../../shared/errors");
+const descriptions_1 = require("../descriptions");
+const common_1 = require("../schemas/common");
+const baseTaskOptions = (config, envName, overrides = {}) => ({
+    config,
+    environmentName: envName,
+    quiet: true,
+    json: false,
+    ...overrides,
+});
+const registerCampaignTools = (registry) => {
+    registry.registerTool({
+        name: "campaign_inspect",
+        description: descriptions_1.TOOL_DESCRIPTIONS.campaign_inspect,
+        auth: "read",
+        annotations: {
+            title: "Inspect Sitecore Orchestrate campaigns",
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            verb: zod_1.z
+                .enum(["list", "show", "tasks", "task", "users"])
+                .describe("Read operation: list (campaigns), show (one campaign), tasks (list under a deliverable), task (one task), users (member directory)."),
+            campaignId: zod_1.z
+                .string()
+                .uuid()
+                .optional()
+                .describe("Campaign UUID. Required for verb='show', 'tasks', 'task'."),
+            deliverableId: zod_1.z
+                .string()
+                .uuid()
+                .optional()
+                .describe("Deliverable UUID. Required for verb='tasks' and verb='task'."),
+            taskId: zod_1.z.string().uuid().optional().describe("Task UUID. Required for verb='task'."),
+            limit: zod_1.z.number().int().positive().max(200).optional().describe("Page size for verb='list'."),
+        },
+        handler: async (input, context) => {
+            const taskOpts = baseTaskOptions(context.configPath, context.envName);
+            switch (input.verb) {
+                case "list": {
+                    const result = await (0, tasks_1.runCampaignList)({
+                        ...taskOpts,
+                        ...(input.limit !== undefined && { limit: input.limit }),
+                    });
+                    return {
+                        content: [{ type: "text", text: `${result.totalCount} campaign(s) in tenant.` }],
+                        structuredContent: { verb: input.verb, result },
+                    };
+                }
+                case "show": {
+                    if (!input.campaignId) {
+                        throw (0, errors_1.createScaiError)("verb='show' requires `campaignId`.", "INPUT_INVALID");
+                    }
+                    const result = await (0, tasks_1.runCampaignShow)({
+                        ...taskOpts,
+                        campaignId: input.campaignId,
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Campaign ${result.id}: '${result.name}' (${result.status}, ${result.deliverables.length} deliverable(s)).`,
+                            },
+                        ],
+                        structuredContent: { verb: input.verb, result },
+                    };
+                }
+                case "tasks": {
+                    if (!input.campaignId || !input.deliverableId) {
+                        throw (0, errors_1.createScaiError)("verb='tasks' requires `campaignId` and `deliverableId`.", "INPUT_INVALID");
+                    }
+                    const result = await (0, tasks_1.runTaskList)({
+                        ...taskOpts,
+                        campaignId: input.campaignId,
+                        deliverableId: input.deliverableId,
+                    });
+                    return {
+                        content: [{ type: "text", text: `${result.totalCount} task(s).` }],
+                        structuredContent: { verb: input.verb, result },
+                    };
+                }
+                case "task": {
+                    if (!input.campaignId || !input.deliverableId || !input.taskId) {
+                        throw (0, errors_1.createScaiError)("verb='task' requires `campaignId`, `deliverableId`, and `taskId`.", "INPUT_INVALID");
+                    }
+                    const result = await (0, tasks_1.runTaskShow)({
+                        ...taskOpts,
+                        campaignId: input.campaignId,
+                        deliverableId: input.deliverableId,
+                        taskId: input.taskId,
+                    });
+                    return {
+                        content: [
+                            { type: "text", text: `Task ${result.id}: '${result.name}' (${result.status}).` },
+                        ],
+                        structuredContent: { verb: input.verb, result },
+                    };
+                }
+                case "users": {
+                    const result = await (0, tasks_1.runCampaignUsers)(taskOpts);
+                    return {
+                        content: [{ type: "text", text: `${result.totalCount} user(s).` }],
+                        structuredContent: { verb: input.verb, result },
+                    };
+                }
+            }
+        },
+    });
+    registry.registerTool({
+        name: "campaign_manage",
+        description: descriptions_1.TOOL_DESCRIPTIONS.campaign_manage,
+        auth: "write",
+        annotations: {
+            title: "Manage Sitecore Orchestrate campaigns, deliverables, and tasks",
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            resource: zod_1.z
+                .enum(["campaign", "deliverable", "task"])
+                .describe("Which Orchestrate resource the verb targets."),
+            verb: zod_1.z
+                .enum(["create", "update", "delete"])
+                .describe("Mutation verb. create: POST a new resource. update: PUT-replace (task only — full-replacement, no PATCH). delete: DELETE the resource (UNVERIFIED Orchestrate endpoint — irreversible)."),
+            campaignId: zod_1.z
+                .string()
+                .uuid()
+                .optional()
+                .describe("Campaign UUID. Required for deliverable/task writes, and for verb='delete' on resource='campaign'."),
+            deliverableId: zod_1.z
+                .string()
+                .uuid()
+                .optional()
+                .describe("Deliverable UUID. Required for task writes, and for verb='delete' on resource='deliverable'."),
+            taskId: zod_1.z
+                .string()
+                .uuid()
+                .optional()
+                .describe("Task UUID. Required for verb='update' and verb='delete' on resource='task'."),
+            name: zod_1.z.string().optional().describe("Resource name. Required for verb='create'."),
+            description: zod_1.z.string().optional().describe("Description (campaign, or task — HTML)."),
+            startDate: zod_1.z.string().optional().describe("Start date, ISO-8601 (campaign)."),
+            dueDate: zod_1.z.string().optional().describe("Due date, ISO-8601."),
+            status: zod_1.z.string().optional().describe("Status enum, e.g. NOT_STARTED."),
+            brandkitId: zod_1.z.string().optional().describe("Associated brand kit UUID (campaign)."),
+            funnelStage: zod_1.z.string().optional().describe("Funnel stage, e.g. TOP (deliverable)."),
+            funnelTactics: zod_1.z.array(zod_1.z.string()).optional().describe("Funnel tactics (deliverable)."),
+            priority: zod_1.z.string().optional().describe("Task priority (task update)."),
+            assignee: zod_1.z.string().optional().describe("Assignee — an Auth0 subject (task update)."),
+            ...common_1.allowWriteShape,
+            ...common_1.whatIfShape,
+        },
+        handler: async (input, context) => {
+            const taskOpts = baseTaskOptions(context.configPath, context.envName);
+            const whatIf = input.whatIf;
+            const requireName = () => {
+                if (!input.name) {
+                    throw (0, errors_1.createScaiError)("verb='create' requires `name`.", "INPUT_INVALID");
+                }
+                return input.name;
+            };
+            if (input.resource === "campaign") {
+                if (input.verb === "update") {
+                    throw (0, errors_1.createScaiError)("resource='campaign' supports verb='create' and verb='delete'.", "INPUT_INVALID");
+                }
+                if (input.verb === "delete") {
+                    if (!input.campaignId) {
+                        throw (0, errors_1.createScaiError)("campaign delete requires `campaignId`.", "INPUT_INVALID");
+                    }
+                    const result = await (0, tasks_1.runCampaignDelete)({
+                        ...taskOpts,
+                        whatIf,
+                        campaignId: input.campaignId,
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: result.deleted
+                                    ? `Deleted campaign ${input.campaignId}.`
+                                    : `Plan: delete campaign ${input.campaignId}.`,
+                            },
+                        ],
+                        structuredContent: { resource: input.resource, verb: input.verb, result },
+                    };
+                }
+                const result = await (0, tasks_1.runCampaignCreate)({
+                    ...taskOpts,
+                    whatIf,
+                    input: {
+                        name: requireName(),
+                        description: input.description,
+                        start_date: input.startDate,
+                        due_date: input.dueDate,
+                        status: input.status,
+                        brandkit_id: input.brandkitId,
+                    },
+                });
+                return {
+                    content: [{ type: "text", text: `${whatIf ? "Plan: create" : "Created"} campaign.` }],
+                    structuredContent: { resource: input.resource, verb: input.verb, result },
+                };
+            }
+            if (input.resource === "deliverable") {
+                if (input.verb === "update") {
+                    throw (0, errors_1.createScaiError)("resource='deliverable' supports verb='create' and verb='delete'.", "INPUT_INVALID");
+                }
+                if (!input.campaignId) {
+                    throw (0, errors_1.createScaiError)("deliverable writes require `campaignId`.", "INPUT_INVALID");
+                }
+                if (input.verb === "delete") {
+                    if (!input.deliverableId) {
+                        throw (0, errors_1.createScaiError)("deliverable delete requires `deliverableId`.", "INPUT_INVALID");
+                    }
+                    const result = await (0, tasks_1.runDeliverableDelete)({
+                        ...taskOpts,
+                        whatIf,
+                        campaignId: input.campaignId,
+                        deliverableId: input.deliverableId,
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: result.deleted
+                                    ? `Deleted deliverable ${input.deliverableId}.`
+                                    : `Plan: delete deliverable ${input.deliverableId}.`,
+                            },
+                        ],
+                        structuredContent: { resource: input.resource, verb: input.verb, result },
+                    };
+                }
+                const result = await (0, tasks_1.runDeliverableCreate)({
+                    ...taskOpts,
+                    whatIf,
+                    campaignId: input.campaignId,
+                    input: {
+                        name: requireName(),
+                        due_date: input.dueDate,
+                        status: input.status,
+                        funnel_stage: input.funnelStage,
+                        funnel_tactics: input.funnelTactics,
+                    },
+                });
+                return {
+                    content: [{ type: "text", text: `${whatIf ? "Plan: create" : "Created"} deliverable.` }],
+                    structuredContent: { resource: input.resource, verb: input.verb, result },
+                };
+            }
+            // resource === "task"
+            if (!input.campaignId || !input.deliverableId) {
+                throw (0, errors_1.createScaiError)("task writes require `campaignId` and `deliverableId`.", "INPUT_INVALID");
+            }
+            if (input.verb === "create") {
+                const result = await (0, tasks_1.runTaskCreate)({
+                    ...taskOpts,
+                    whatIf,
+                    campaignId: input.campaignId,
+                    deliverableId: input.deliverableId,
+                    input: { name: requireName(), due_date: input.dueDate, status: input.status },
+                });
+                return {
+                    content: [{ type: "text", text: `${whatIf ? "Plan: create" : "Created"} task.` }],
+                    structuredContent: { resource: input.resource, verb: input.verb, result },
+                };
+            }
+            if (input.verb === "delete") {
+                if (!input.taskId) {
+                    throw (0, errors_1.createScaiError)("task delete requires `taskId`.", "INPUT_INVALID");
+                }
+                const result = await (0, tasks_1.runTaskDelete)({
+                    ...taskOpts,
+                    whatIf,
+                    campaignId: input.campaignId,
+                    deliverableId: input.deliverableId,
+                    taskId: input.taskId,
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: result.deleted
+                                ? `Deleted task ${input.taskId}.`
+                                : `Plan: delete task ${input.taskId}.`,
+                        },
+                    ],
+                    structuredContent: { resource: input.resource, verb: input.verb, result },
+                };
+            }
+            // verb === "update"
+            if (!input.taskId) {
+                throw (0, errors_1.createScaiError)("task update requires `taskId`.", "INPUT_INVALID");
+            }
+            const result = await (0, tasks_1.runTaskUpdate)({
+                ...taskOpts,
+                whatIf,
+                campaignId: input.campaignId,
+                deliverableId: input.deliverableId,
+                taskId: input.taskId,
+                input: {
+                    name: requireName(),
+                    due_date: input.dueDate,
+                    status: input.status,
+                    priority: input.priority,
+                    description: input.description,
+                    assignee: input.assignee,
+                },
+            });
+            return {
+                content: [{ type: "text", text: `${whatIf ? "Plan: update" : "Updated"} task.` }],
+                structuredContent: { resource: input.resource, verb: input.verb, result },
+            };
+        },
+    });
+};
+exports.registerCampaignTools = registerCampaignTools;

package/dist/mcp/tools/cleanup.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Cleanup domain — preview + execute.
+ *
+ * Two tools cover the destructive hygiene surface:
+ *
+ *   - `cleanup_preview` (read) — runs any cleanup verb with
+ *     `whatIf: true` so the agent can show the user what would change
+ *     before asking for write authorization. No tenant mutations occur.
+ *
+ *   - `cleanup_execute` (write) — single destructive entry point,
+ *     discriminated on `verb`. Honors the per-call `allowWrite` gate
+ *     enforced at dispatch, the `whatIf` plan-only flag, and per-verb
+ *     blast-radius caps (`max*` options forwarded to the underlying
+ *     library). Every verb returns a per-action list so the caller can
+ *     inspect what actually applied.
+ *
+ * Verbs map 1:1 with the `scai hygiene cleanup` CLI verbs whose library task
+ * honors `--what-if`. The interactive-keep mode for `duplicates` stays
+ * CLI-only because it requires per-group keystroke selection.
+ */
+import type { McpRegistry } from "../registry";
+export declare const registerCleanupTools: (registry: McpRegistry) => void;