@sitecoreai-labs/sitecoreai-cli 0.0.4 → 0.1.0

package/dist/mcp/tools/agents.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAgentsTools = void 0;
+/**
+ * Agentic Studio domain — read + run tools over the Agentic Studio BFF.
+ *
+ * Two tools, workflow-shaped:
+ *   - `agents_inspect` (read) discriminates on `verb` — list agents,
+ *     skills, the tool catalog, widgets, schemas, or registered custom
+ *     MCP servers, or report session status.
+ *   - `agents_run` (write) runs an agent by slug and returns its output.
+ *
+ * Creating/updating agents, skills, widgets, and MCPs is declarative —
+ * the recipe kinds + `scai sync`, not an MCP tool.
+ */
+const zod_1 = require("zod");
+const session_1 = require("../../agents/session");
+const request_1 = require("../../agents/api/request");
+const agents_1 = require("../../agents/api/agents");
+const skills_1 = require("../../agents/api/skills");
+const tools_1 = require("../../agents/api/tools");
+const widgets_1 = require("../../agents/api/widgets");
+const schemas_1 = require("../../agents/api/schemas");
+const custom_mcps_1 = require("../../agents/api/custom-mcps");
+const runs_1 = require("../../agents/api/runs");
+const descriptions_1 = require("../descriptions");
+const common_1 = require("../schemas/common");
+const registerAgentsTools = (registry) => {
+    registry.registerTool({
+        name: "agents_inspect",
+        description: descriptions_1.TOOL_DESCRIPTIONS.agents_inspect,
+        auth: "read",
+        annotations: {
+            title: "Inspect Sitecore Agentic Studio",
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            verb: zod_1.z
+                .enum(["agents", "skills", "tools", "widgets", "schemas", "mcps", "status"])
+                .describe("Read operation: agents | skills | tools (catalog) | widgets | schemas | mcps (custom MCP servers) | status (session validity)."),
+        },
+        handler: async (input, context) => {
+            const session = await (0, session_1.acquireAgentsSession)(context.envName);
+            switch (input.verb) {
+                case "agents": {
+                    const result = await (0, agents_1.listAgents)(session);
+                    return {
+                        content: [{ type: "text", text: `${result.length} agent(s).` }],
+                        structuredContent: { verb: input.verb, result },
+                    };
+                }
+                case "skills": {
+                    const result = await (0, skills_1.listSkills)(session);
+                    return {
+                        content: [{ type: "text", text: `${result.length} skill(s).` }],
+                        structuredContent: { verb: input.verb, result },
+                    };
+                }
+                case "tools": {
+                    const result = await (0, tools_1.listTools)(session);
+                    return {
+                        content: [{ type: "text", text: `${result.length} tool(s) in the catalog.` }],
+                        structuredContent: { verb: input.verb, result },
+                    };
+                }
+                case "widgets": {
+                    const result = await (0, widgets_1.listWidgets)(session);
+                    return {
+                        content: [{ type: "text", text: `${result.length} widget(s).` }],
+                        structuredContent: { verb: input.verb, result },
+                    };
+                }
+                case "schemas": {
+                    const result = await (0, schemas_1.listSchemas)(session);
+                    return {
+                        content: [{ type: "text", text: `${result.length} schema(s).` }],
+                        structuredContent: { verb: input.verb, result },
+                    };
+                }
+                case "mcps": {
+                    const result = await (0, custom_mcps_1.listCustomMcps)(session);
+                    return {
+                        content: [{ type: "text", text: `${result.length} custom MCP(s).` }],
+                        structuredContent: { verb: input.verb, result },
+                    };
+                }
+                case "status": {
+                    const refresh = await (0, request_1.agentsRequest)(session, "/api/token-refresh");
+                    const valid = refresh?.success !== false;
+                    return {
+                        content: [
+                            { type: "text", text: `Agentic Studio session is ${valid ? "valid" : "invalid"}.` },
+                        ],
+                        structuredContent: {
+                            verb: input.verb,
+                            result: { endpoint: session.baseUrl, valid, expiresAt: refresh?.expiresAt },
+                        },
+                    };
+                }
+            }
+        },
+    });
+    registry.registerTool({
+        name: "agents_run",
+        description: descriptions_1.TOOL_DESCRIPTIONS.agents_run,
+        auth: "write",
+        annotations: {
+            title: "Run a Sitecore Agentic Studio agent",
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            agentSlug: zod_1.z
+                .string()
+                .describe("Slug of the agent to run (see agents_inspect verb='agents')."),
+            message: zod_1.z.string().describe("The user message / prompt to send to the agent."),
+            ...common_1.allowWriteShape,
+        },
+        handler: async (input, context) => {
+            const session = await (0, session_1.acquireAgentsSession)(context.envName);
+            const { spaceId, events } = await (0, runs_1.runAgent)(session, {
+                agentSlug: input.agentSlug,
+                message: input.message,
+            });
+            let output = "";
+            const eventCounts = {};
+            for await (const event of events) {
+                eventCounts[event.type] = (eventCounts[event.type] ?? 0) + 1;
+                if (event.type === "text-delta" && typeof event.delta === "string") {
+                    output += event.delta;
+                }
+                else if (event.type === "data-artifactDelta") {
+                    const data = event.data;
+                    if (typeof data?.content === "string")
+                        output += data.content;
+                }
+            }
+            return {
+                content: [{ type: "text", text: output || `Run completed (space ${spaceId}).` }],
+                structuredContent: { spaceId, output, eventCounts },
+            };
+        },
+    });
+};
+exports.registerAgentsTools = registerAgentsTools;

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

@@ -0,0 +1,41 @@
+/**
+ * Audit domain — inspect, baseline, suite.
+ *
+ * Three read-side tools cover the full hygiene-reporting surface:
+ *
+ *   - `audit_inspect` — discriminated `{ verb }` entry that lists
+ *     available audits, runs one (or `all`) in-process, captures a
+ *     history snapshot, lists captured snapshots, or diffs two
+ *     snapshots. The single tool replaces five CLI verbs so agents
+ *     don't need to memorize a half-dozen names; the verb discriminator
+ *     keeps each call's inputs scoped.
+ *
+ *   - `audit_baseline` — discriminated `{ verb }` entry for the per-env
+ *     baseline file at `.scai/audit-baseline-<envName>.json`. Show is
+ *     free; `update`, `remove`, and `reset` mutate the local baseline
+ *     file (not the tenant), and are write-gated so the host's
+ *     confirmation UX kicks in before any baseline change.
+ *
+ *   - `audit_suite_run` — load + execute a YAML suite file. Read-side
+ *     by definition (suites themselves can't mutate the tenant), but
+ *     can resolve `baseline=true` if the suite says so.
+ *
+ * Every audit run delegates to the CLI-shared `runAudit*` task; this
+ * MCP layer only forwards routing + the structured-content envelope.
+ */
+import type { McpRegistry } from "../registry";
+/**
+ * Loose-typed runner shape — the dispatch path hands every runner a
+ * `Record<string, unknown>` option bag because the MCP boundary doesn't
+ * know the per-audit option type at compile time.
+ */
+type LoosedRunner = (options: Record<string, unknown>) => Promise<readonly unknown[]>;
+/**
+ * Routing table for `audit_inspect` verb=run. The list mirrors
+ * `AUDIT_REGISTRY` in `src/hygiene/tasks/audit/all.ts` — the
+ * `cli-mcp-parity.test.ts` routing-table test asserts the two stay in
+ * lockstep, so it is exported for that test.
+ */
+export declare const SINGLE_AUDIT_RUNNERS: Record<string, LoosedRunner>;
+export declare const registerAuditTools: (registry: McpRegistry) => void;
+export {};