@sitecoreai-labs/sitecoreai-cli 0.0.4 → 0.1.0

package/dist/brand/tasks/review.js

@@ -0,0 +1,310 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBrandReview = exports.computeExitCode = exports.resolveReviewInputs = exports.parseSectionSelectors = exports.detectInputFormat = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const package_json_1 = __importDefault(require("../../../package.json"));
+const cli_tasks_1 = require("../../shared/cli-tasks");
+const generate_1 = require("../review/generate");
+const credential_1 = require("../credential");
+const outcomes_1 = require("../review/outcomes");
+const format_json_1 = require("../review/format-json");
+const format_sarif_1 = require("../review/format-sarif");
+const format_text_1 = require("../review/format-text");
+const DEFAULT_CONCURRENCY = 4;
+const DEFAULT_LIMIT = 1000;
+const isReviewFormat = (value) => value === "text" || value === "json" || value === "sarif";
+const asThreshold = (raw) => {
+    if (raw === undefined)
+        return undefined;
+    if (!Number.isFinite(raw) || raw < 1 || raw > 5) {
+        throw (0, cli_tasks_1.inputError)(`Invalid --threshold ${raw}.`, "Threshold must be an integer between 1 and 5 inclusive.");
+    }
+    return Math.round(raw);
+};
+const detectInputFormat = (filePath) => {
+    const ext = node_path_1.default.extname(filePath).toLowerCase();
+    if (ext === ".md" || ext === ".markdown" || ext === ".mdx")
+        return "markdown";
+    if (ext === ".json")
+        return "json";
+    return "text";
+};
+exports.detectInputFormat = detectInputFormat;
+/**
+ * Parse CLI `--section-id` values into the Brand Review API's
+ * `Section[]` selector shape.
+ *
+ * Each value is either:
+ *   - `<sectionId>`              → section-level evaluation
+ *   - `<sectionId>:<fieldId>`    → field-level evaluation (multiple
+ *                                  `--section-id <sectionId>:<a>`
+ *                                  occurrences merge into one
+ *                                  `Section` entry)
+ *
+ * Multiple values for the same sectionId accumulate into the
+ * section's `fieldIds[]`. An empty / undefined input list returns
+ * `undefined` (= API evaluates every section).
+ */
+const parseSectionSelectors = (raw) => {
+    if (!raw?.length)
+        return undefined;
+    const bySection = new Map();
+    for (const entry of raw) {
+        const [sectionId, fieldId] = entry.split(":");
+        if (!sectionId) {
+            throw (0, cli_tasks_1.inputError)(`Invalid --section-id value '${entry}'.`, "Use <sectionId> or <sectionId>:<fieldId>. IDs are UUIDs from the Brand Management API.");
+        }
+        if (!bySection.has(sectionId)) {
+            bySection.set(sectionId, new Set());
+        }
+        if (fieldId) {
+            bySection.get(sectionId).add(fieldId);
+        }
+    }
+    return Array.from(bySection.entries()).map(([sectionId, fieldIds]) => ({
+        sectionId,
+        fieldIds: fieldIds.size > 0 ? Array.from(fieldIds) : undefined,
+    }));
+};
+exports.parseSectionSelectors = parseSectionSelectors;
+/**
+ * Resolve positional file paths + glob patterns to a deduplicated,
+ * sorted list of absolute file paths. Resolution rules:
+ *
+ *   - Positional paths must exist; if any are missing the call
+ *     errors with INPUT_INVALID listing the missing entries.
+ *   - Glob patterns expand relative to `cwd`.
+ *   - Duplicates across positional+glob are removed.
+ *   - Directories and non-files are filtered out — Brand Review
+ *     operates on file content, not directory listings.
+ *
+ * Returns the resolved files in input order (positionals first,
+ * then glob hits in their natural order).
+ */
+const resolveReviewInputs = async (positionals, globs, cwd) => {
+    const resolved = [];
+    const seen = new Set();
+    const missing = [];
+    for (const positional of positionals) {
+        const abs = node_path_1.default.resolve(cwd, positional);
+        if (!node_fs_1.default.existsSync(abs)) {
+            missing.push(positional);
+            continue;
+        }
+        const stat = node_fs_1.default.statSync(abs);
+        if (!stat.isFile())
+            continue;
+        if (!seen.has(abs)) {
+            seen.add(abs);
+            resolved.push(abs);
+        }
+    }
+    if (missing.length > 0) {
+        throw (0, cli_tasks_1.inputError)(`Input files not found: ${missing.join(", ")}.`, "Check the paths or use --glob to expand a pattern.");
+    }
+    if (globs.length > 0) {
+        const matched = await (0, fast_glob_1.default)([...globs], {
+            cwd,
+            absolute: true,
+            onlyFiles: true,
+            dot: false,
+        });
+        for (const abs of matched) {
+            if (!seen.has(abs)) {
+                seen.add(abs);
+                resolved.push(abs);
+            }
+        }
+    }
+    return resolved;
+};
+exports.resolveReviewInputs = resolveReviewInputs;
+const buildReviewInput = (filePath, cwd) => {
+    const content = node_fs_1.default.readFileSync(filePath, "utf8");
+    const relative = node_path_1.default.relative(cwd, filePath);
+    return {
+        text: content,
+        label: relative || filePath,
+    };
+};
+/**
+ * Bounded-concurrency fan-out with per-item error capture. Each
+ * worker pulls the next index from a shared counter; failures are
+ * captured into the outcome array instead of aborting peers (unless
+ * `failFast` is set). Order matches input order.
+ *
+ * Not generalized into `mapWithConcurrency` because that helper
+ * fail-fasts — a property we want NOT to have here: a 500 on one
+ * file shouldn't lose results for 99 peers.
+ */
+const fanOutReviews = async (options) => {
+    const { inputs, client, kit, sections, concurrency, failFast, threshold, onProgress } = options;
+    const outcomes = new Array(inputs.length);
+    let nextIndex = 0;
+    let stopped = false;
+    const runOne = async () => {
+        while (!stopped) {
+            const index = nextIndex++;
+            if (index >= inputs.length)
+                return;
+            const input = inputs[index];
+            const label = input.label ?? `input[${index}]`;
+            try {
+                const result = await (0, generate_1.generateBrandReview)({
+                    client,
+                    input,
+                    selector: { brandKitId: kit, sections },
+                });
+                const outcome = { kind: "ok", label, result };
+                outcomes[index] = outcome;
+                onProgress(outcome, index);
+                if (failFast && threshold !== undefined && result.overallScore < threshold) {
+                    stopped = true;
+                    return;
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const outcome = { kind: "error", label, message, cause: error };
+                outcomes[index] = outcome;
+                onProgress(outcome, index);
+                if (failFast) {
+                    stopped = true;
+                    return;
+                }
+            }
+        }
+    };
+    const workerCount = Math.min(Math.max(1, concurrency), inputs.length);
+    await Promise.all(Array.from({ length: workerCount }, () => runOne()));
+    return outcomes.filter((entry) => entry !== undefined);
+};
+/**
+ * Compute the CLI exit code for a batch review run.
+ *
+ *   0  → no API errors and no scores below threshold
+ *   1  → threshold violated by at least one file
+ *   7  → at least one API call failed (`BRAND_API_FAILED`)
+ *
+ * Threshold violations and API errors can co-occur — when both fire,
+ * the threshold violation wins (1) so CI failure modes are
+ * distinguishable from infrastructure failures.
+ */
+const computeExitCode = (outcomes, threshold) => {
+    const summary = (0, outcomes_1.summarizeOutcomes)(outcomes, threshold);
+    if (summary.belowThreshold > 0)
+        return 1;
+    if (summary.errored > 0)
+        return 7;
+    return 0;
+};
+exports.computeExitCode = computeExitCode;
+/**
+ * Run a batch Brand Review.
+ *
+ * The CLI verb is a thin wrapper around this — pass the same options
+ * and inspect the returned `BrandReviewRunResult` to drive exit
+ * codes, stdout writes, or downstream tooling. SDK consumers should
+ * use this directly (exported through `@sitecoreai-labs/sitecoreai-cli/unstable/brand`).
+ */
+const runBrandReview = async (options) => {
+    const logger = (0, cli_tasks_1.toLogger)(options);
+    const configPath = options.config ?? process.cwd();
+    const { orgId, credential } = (0, credential_1.resolveBrandClient)(options);
+    if (!options.kit) {
+        throw (0, cli_tasks_1.inputError)("Brand kit ID is required.", "Pass --kit <id>. List kits with `scai brand kits list` (coming in a follow-up slice).");
+    }
+    const format = isReviewFormat(options.format) ? options.format : "text";
+    const threshold = asThreshold(options.threshold);
+    const concurrency = Math.max(1, options.concurrency ?? DEFAULT_CONCURRENCY);
+    const limit = Math.max(1, options.limit ?? DEFAULT_LIMIT);
+    const cwd = configPath;
+    const filePaths = await (0, exports.resolveReviewInputs)(options.inputs ?? [], options.glob ?? [], cwd);
+    if (filePaths.length === 0) {
+        throw (0, cli_tasks_1.inputError)("No input files matched.", "Provide file paths as positional args or use --glob <pattern>.");
+    }
+    if (filePaths.length > limit && !options.force) {
+        throw (0, cli_tasks_1.inputError)(`Resolved ${filePaths.length} files which exceeds --limit ${limit}.`, "Increase --limit, narrow --glob, or pass --force to override. Each file is a paid API call.");
+    }
+    if (options.whatIf) {
+        logger.info(`--what-if: would review ${filePaths.length} file(s) against kit '${options.kit}'.`);
+        for (const filePath of filePaths) {
+            logger.info(`  ${node_path_1.default.relative(cwd, filePath)}`);
+        }
+        return { outcomes: [], exitCode: 0 };
+    }
+    const inputs = filePaths.map((p) => buildReviewInput(p, cwd));
+    const client = { orgId, credential };
+    const sections = (0, exports.parseSectionSelectors)(options.sectionId);
+    // Text format streams as files complete. JSON / SARIF buffer (order
+    // matters for those payloads and the formats aggregate per-file
+    // sections, so streaming would be a wire-format leak).
+    const onProgress = format === "text"
+        ? (outcome) => {
+            logger.info((0, format_text_1.formatTextRow)(outcome, threshold));
+        }
+        : () => {
+            // No-op — buffered output formats render at end.
+        };
+    const outcomes = await fanOutReviews({
+        inputs,
+        client,
+        kit: options.kit,
+        sections,
+        concurrency,
+        failFast: Boolean(options.failFast),
+        threshold,
+        onProgress,
+    });
+    const exitCode = (0, exports.computeExitCode)(outcomes, threshold);
+    const result = { outcomes, exitCode };
+    if (format === "text") {
+        const summary = (0, outcomes_1.summarizeOutcomes)(outcomes, threshold);
+        const summaryLine = (0, format_text_1.formatTextSummary)(summary, threshold);
+        if (options.output) {
+            node_fs_1.default.writeFileSync(options.output, (0, format_text_1.buildTextReport)(outcomes, threshold), "utf8");
+            logger.info(`Wrote text report to ${options.output}.`);
+        }
+        else {
+            logger.info("");
+            logger.info(summaryLine);
+        }
+        result.report = (0, format_text_1.buildTextReport)(outcomes, threshold);
+    }
+    else if (format === "json") {
+        const report = (0, format_json_1.buildJsonReport)(outcomes, threshold);
+        const serialized = JSON.stringify(report, null, 2);
+        if (options.output) {
+            node_fs_1.default.writeFileSync(options.output, serialized, "utf8");
+            logger.info(`Wrote JSON report to ${options.output}.`);
+        }
+        else {
+            // Direct stdout write — logger.info would prepend formatting
+            // that breaks JSON consumers piping to jq.
+            process.stdout.write(serialized + "\n");
+        }
+        result.report = serialized;
+        result.json = report;
+    }
+    else {
+        const driverVersion = package_json_1.default.version ?? "0.0.0";
+        const report = (0, format_sarif_1.buildSarifReport)(outcomes, threshold, driverVersion);
+        const serialized = JSON.stringify(report, null, 2);
+        if (options.output) {
+            node_fs_1.default.writeFileSync(options.output, serialized, "utf8");
+            logger.info(`Wrote SARIF report to ${options.output}.`);
+        }
+        else {
+            process.stdout.write(serialized + "\n");
+        }
+        result.report = serialized;
+        result.sarif = report;
+    }
+    return result;
+};
+exports.runBrandReview = runBrandReview;

package/dist/brief/api/brief-types.d.ts

@@ -0,0 +1,64 @@
+import type { BriefField, BriefType, LocalizedString, PagedResult } from "./schema";
+import type { BriefApiClientOptions } from "./types";
+/**
+ * BriefType resource — catalogue of available brief schemas/templates.
+ *
+ * Endpoint surface (verified against the Agents env on 2026-05-15 by
+ * `scripts/_smoke-brief-types-write.ts`):
+ *
+ *   GET    /api/brief/v1/brief-types         — list (paged)
+ *   GET    /api/brief/v1/brief-types/{id}    — read one
+ *   POST   /api/brief/v1/brief-types         — create (201, returns body)
+ *   PUT    /api/brief/v1/brief-types/{id}    — update (204, full-replacement)
+ *   DELETE /api/brief/v1/brief-types/{id}    — delete (204)
+ *
+ * Item-level OPTIONS reports `Allow: DELETE, GET, PUT` — no PATCH, so
+ * `updateBriefType` performs a full-replacement PUT. Callers wanting
+ * field-level merging must read first, mutate, then write.
+ *
+ * Field definitions on a BriefType carry `aiEditable` and `aiIntent`
+ * hints — agents working a brief should respect both.
+ */
+/** List all brief types. */
+export declare const listBriefTypes: (options: BriefApiClientOptions) => Promise<PagedResult<BriefType>>;
+/** Read a single brief type by id. */
+export declare const getBriefType: (options: BriefApiClientOptions, briefTypeId: string) => Promise<BriefType>;
+/**
+ * Input for `createBriefType`.
+ *
+ * `name` must match `^[A-Za-z][A-Za-z0-9_]*$` — the API rejects names
+ * starting with non-letters or containing punctuation other than `_`.
+ * `label` and `description` are required by the server; the rest are
+ * server-defaulted but accepted on input.
+ */
+export type CreateBriefTypeInput = {
+    name: string;
+    label: LocalizedString;
+    description: string;
+    icon: string;
+    iconColor: string;
+    fields: BriefField[];
+};
+/**
+ * Validate an untyped value against the `CreateBriefTypeInput` contract.
+ *
+ * Mirrors the Brief API's own input rules so a malformed payload fails
+ * fast with a clear message instead of a raw server 400. Throws a
+ * `ScaiError` (`INPUT_INVALID`); returns the narrowed input on success.
+ * `createBriefType` / `updateBriefType` call this themselves, so direct
+ * SDK consumers are guarded without invoking it explicitly.
+ */
+export declare const assertCreateBriefTypeInput: (value: unknown) => CreateBriefTypeInput;
+/** Create a brief type. Returns the persisted record (201). */
+export declare const createBriefType: (options: BriefApiClientOptions, input: CreateBriefTypeInput) => Promise<BriefType>;
+/**
+ * Full-replacement update of a brief type (PUT — 204 No Content).
+ *
+ * `id` in the path is authoritative; any `id` field on the body is
+ * ignored by the server. To preserve fields the caller didn't intend
+ * to change, fetch with `getBriefType` first, then write the merged
+ * result.
+ */
+export declare const updateBriefType: (options: BriefApiClientOptions, briefTypeId: string, input: CreateBriefTypeInput) => Promise<void>;
+/** Delete a brief type. Returns void (204 No Content). */
+export declare const deleteBriefType: (options: BriefApiClientOptions, briefTypeId: string) => Promise<void>;

package/dist/brief/api/brief-types.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteBriefType = exports.updateBriefType = exports.createBriefType = exports.assertCreateBriefTypeInput = exports.getBriefType = exports.listBriefTypes = void 0;
+const errors_1 = require("../../shared/errors");
+const request_1 = require("./request");
+/**
+ * BriefType resource — catalogue of available brief schemas/templates.
+ *
+ * Endpoint surface (verified against the Agents env on 2026-05-15 by
+ * `scripts/_smoke-brief-types-write.ts`):
+ *
+ *   GET    /api/brief/v1/brief-types         — list (paged)
+ *   GET    /api/brief/v1/brief-types/{id}    — read one
+ *   POST   /api/brief/v1/brief-types         — create (201, returns body)
+ *   PUT    /api/brief/v1/brief-types/{id}    — update (204, full-replacement)
+ *   DELETE /api/brief/v1/brief-types/{id}    — delete (204)
+ *
+ * Item-level OPTIONS reports `Allow: DELETE, GET, PUT` — no PATCH, so
+ * `updateBriefType` performs a full-replacement PUT. Callers wanting
+ * field-level merging must read first, mutate, then write.
+ *
+ * Field definitions on a BriefType carry `aiEditable` and `aiIntent`
+ * hints — agents working a brief should respect both.
+ */
+/** List all brief types. */
+const listBriefTypes = (options) => (0, request_1.briefRequest)(options, "/api/brief/v1/brief-types");
+exports.listBriefTypes = listBriefTypes;
+/** Read a single brief type by id. */
+const getBriefType = (options, briefTypeId) => (0, request_1.briefRequest)(options, `/api/brief/v1/brief-types/${encodeURIComponent(briefTypeId)}`);
+exports.getBriefType = getBriefType;
+/**
+ * The Brief API requires `name` to match this pattern — a letter first,
+ * then letters / digits / underscore. Names starting with a non-letter
+ * or carrying other punctuation are rejected server-side.
+ */
+const BRIEF_TYPE_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_]*$/;
+const BRIEF_TYPE_REQUIRED_KEYS = [
+    "name",
+    "label",
+    "description",
+    "icon",
+    "iconColor",
+    "fields",
+];
+/**
+ * Validate an untyped value against the `CreateBriefTypeInput` contract.
+ *
+ * Mirrors the Brief API's own input rules so a malformed payload fails
+ * fast with a clear message instead of a raw server 400. Throws a
+ * `ScaiError` (`INPUT_INVALID`); returns the narrowed input on success.
+ * `createBriefType` / `updateBriefType` call this themselves, so direct
+ * SDK consumers are guarded without invoking it explicitly.
+ */
+const assertCreateBriefTypeInput = (value) => {
+    if (!value || typeof value !== "object") {
+        throw (0, errors_1.createScaiError)("Brief type body must be a JSON object.", "INPUT_INVALID");
+    }
+    const obj = value;
+    const missing = BRIEF_TYPE_REQUIRED_KEYS.filter((key) => obj[key] === undefined);
+    if (missing.length > 0) {
+        throw (0, errors_1.createScaiError)(`Brief type body is missing required fields: ${missing.join(", ")}.`, "INPUT_INVALID", { hint: "Required: name, label, description, icon, iconColor, fields." });
+    }
+    if (typeof obj.name !== "string" || !BRIEF_TYPE_NAME_PATTERN.test(obj.name)) {
+        throw (0, errors_1.createScaiError)(`Invalid 'name': ${JSON.stringify(obj.name)}.`, "INPUT_INVALID", {
+            hint: "Server requires name to match /^[A-Za-z][A-Za-z0-9_]*$/.",
+        });
+    }
+    if (!Array.isArray(obj.fields)) {
+        throw (0, errors_1.createScaiError)("'fields' must be an array (use [] for none).", "INPUT_INVALID");
+    }
+    return obj;
+};
+exports.assertCreateBriefTypeInput = assertCreateBriefTypeInput;
+/** Create a brief type. Returns the persisted record (201). */
+const createBriefType = (options, input) => {
+    (0, exports.assertCreateBriefTypeInput)(input);
+    return (0, request_1.briefRequest)(options, "/api/brief/v1/brief-types", {
+        method: "POST",
+        body: input,
+    });
+};
+exports.createBriefType = createBriefType;
+/**
+ * Full-replacement update of a brief type (PUT — 204 No Content).
+ *
+ * `id` in the path is authoritative; any `id` field on the body is
+ * ignored by the server. To preserve fields the caller didn't intend
+ * to change, fetch with `getBriefType` first, then write the merged
+ * result.
+ */
+const updateBriefType = (options, briefTypeId, input) => {
+    (0, exports.assertCreateBriefTypeInput)(input);
+    return (0, request_1.briefRequest)(options, `/api/brief/v1/brief-types/${encodeURIComponent(briefTypeId)}`, {
+        method: "PUT",
+        body: input,
+    });
+};
+exports.updateBriefType = updateBriefType;
+/** Delete a brief type. Returns void (204 No Content). */
+const deleteBriefType = (options, briefTypeId) => (0, request_1.briefRequest)(options, `/api/brief/v1/brief-types/${encodeURIComponent(briefTypeId)}`, {
+    method: "DELETE",
+});
+exports.deleteBriefType = deleteBriefType;

package/dist/brief/api/briefs.d.ts

@@ -0,0 +1,66 @@
+import type { Brief, BriefStatus, PagedResult } from "./schema";
+import type { BriefApiClientOptions } from "./types";
+/**
+ * Brief resource — CRUD on brief instances.
+ *
+ * Endpoint surface (reverse-engineered):
+ *   GET    /api/brief/v1/briefs            — list (paged)
+ *   GET    /api/brief/v1/briefs/{id}       — read one
+ *   POST   /api/brief/v1/briefs            — create  (verified 2026-05-15)
+ *   PUT    /api/brief/v1/briefs/{id}       — update  (untested)
+ *   DELETE /api/brief/v1/briefs/{id}       — delete  (verified 2026-05-15)
+ *
+ * `createBrief` + `deleteBrief` are verified against the Agents
+ * tenant. `updateBrief` is wired the same way the Sites surface wires
+ * its writes but has not been smoke-tested end-to-end.
+ */
+export type ListBriefsQuery = {
+    /** Page size. */
+    limit?: number;
+    /** Cursor from the previous response's `next` field. */
+    next?: string;
+    /** Optional locale filter — e.g. `en-us`. */
+    locale?: string;
+};
+/** List all briefs in the tenant (paged). */
+export declare const listBriefs: (options: BriefApiClientOptions, query?: ListBriefsQuery) => Promise<PagedResult<Brief>>;
+/** Read a single brief by id. 404 surfaces as `BRIEF_API_FAILED` with `"Brief not found"`. */
+export declare const getBrief: (options: BriefApiClientOptions, briefId: string) => Promise<Brief>;
+/**
+ * Input for `createBrief`.
+ *
+ * Verified against the Agents tenant 2026-05-15: the POST body takes a
+ * flat `briefTypeId` (NOT a nested `briefType: { id }` — that 400s with
+ * `BriefTypeId: Brief type is required`). `name` + `briefTypeId` are
+ * required; `locale`, `fields`, `isTemplate` are optional. `fields`
+ * accepts the same per-field `{ type, value }` shape the read endpoint
+ * returns, where RichText `value` is a ProseMirror doc node.
+ */
+export type CreateBriefInput = {
+    name: string;
+    briefTypeId: string;
+    locale?: string;
+    fields?: Record<string, unknown>;
+    isTemplate?: boolean;
+};
+/** Create a brief. Returns the persisted record (201). */
+export declare const createBrief: (options: BriefApiClientOptions, input: CreateBriefInput) => Promise<Brief>;
+/**
+ * Partial update of a brief (`PUT /api/brief/v1/briefs/{id}` — 204 No
+ * Content). A status-only body is accepted; other partial fields are
+ * wired but only the `status` path is verified (2026-05-15).
+ */
+export declare const updateBrief: (options: BriefApiClientOptions, briefId: string, patch: Partial<CreateBriefInput> & {
+    status?: BriefStatus;
+}) => Promise<void>;
+/**
+ * Move a brief to a new workflow status.
+ *
+ * Verified 2026-05-15 against the Agents tenant: a plain `{ status }`
+ * PUT transitions the brief directly (e.g. `Draft → Approved`), 204 on
+ * success. Briefs must be out of `Draft` before they can be linked to
+ * a campaign.
+ */
+export declare const setBriefStatus: (options: BriefApiClientOptions, briefId: string, status: BriefStatus) => Promise<void>;
+/** Delete a brief. Returns void (204). Verified against the Agents tenant 2026-05-15. */
+export declare const deleteBrief: (options: BriefApiClientOptions, briefId: string) => Promise<void>;

package/dist/brief/api/briefs.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteBrief = exports.setBriefStatus = exports.updateBrief = exports.createBrief = exports.getBrief = exports.listBriefs = void 0;
+const request_1 = require("./request");
+/** List all briefs in the tenant (paged). */
+const listBriefs = (options, query) => {
+    const params = {};
+    if (query?.limit !== undefined)
+        params.Limit = query.limit;
+    if (query?.next)
+        params.Next = query.next;
+    if (query?.locale)
+        params.Locale = query.locale;
+    return (0, request_1.briefRequest)(options, "/api/brief/v1/briefs", {
+        query: params,
+    });
+};
+exports.listBriefs = listBriefs;
+/** Read a single brief by id. 404 surfaces as `BRIEF_API_FAILED` with `"Brief not found"`. */
+const getBrief = (options, briefId) => (0, request_1.briefRequest)(options, `/api/brief/v1/briefs/${encodeURIComponent(briefId)}`);
+exports.getBrief = getBrief;
+/** Create a brief. Returns the persisted record (201). */
+const createBrief = (options, input) => (0, request_1.briefRequest)(options, "/api/brief/v1/briefs", {
+    method: "POST",
+    body: {
+        name: input.name,
+        briefTypeId: input.briefTypeId,
+        locale: input.locale,
+        fields: input.fields,
+        isTemplate: input.isTemplate,
+    },
+});
+exports.createBrief = createBrief;
+/**
+ * Partial update of a brief (`PUT /api/brief/v1/briefs/{id}` — 204 No
+ * Content). A status-only body is accepted; other partial fields are
+ * wired but only the `status` path is verified (2026-05-15).
+ */
+const updateBrief = (options, briefId, patch) => (0, request_1.briefRequest)(options, `/api/brief/v1/briefs/${encodeURIComponent(briefId)}`, {
+    method: "PUT",
+    body: patch,
+});
+exports.updateBrief = updateBrief;
+/**
+ * Move a brief to a new workflow status.
+ *
+ * Verified 2026-05-15 against the Agents tenant: a plain `{ status }`
+ * PUT transitions the brief directly (e.g. `Draft → Approved`), 204 on
+ * success. Briefs must be out of `Draft` before they can be linked to
+ * a campaign.
+ */
+const setBriefStatus = (options, briefId, status) => (0, exports.updateBrief)(options, briefId, { status });
+exports.setBriefStatus = setBriefStatus;
+/** Delete a brief. Returns void (204). Verified against the Agents tenant 2026-05-15. */
+const deleteBrief = (options, briefId) => (0, request_1.briefRequest)(options, `/api/brief/v1/briefs/${encodeURIComponent(briefId)}`, {
+    method: "DELETE",
+});
+exports.deleteBrief = deleteBrief;

package/dist/brief/api/comments.d.ts

@@ -0,0 +1,43 @@
+import type { BriefComment, PagedResult } from "./schema";
+import type { BriefApiClientOptions } from "./types";
+/**
+ * Comments resource on the Brief API.
+ *
+ * Endpoint surface (reverse-engineered):
+ *   GET  /api/brief/v1/comments              — list (tenant-wide)
+ *   GET  /api/brief/v1/comments?BriefId=...  — list (filtered to one brief)
+ *   POST /api/brief/v1/comments              — create  (UNVERIFIED)
+ *
+ * The comment shape is provisional — the probe tenant had zero
+ * comments. Tighten `BriefComment` in `./schema.ts` after capture.
+ */
+export type ListBriefCommentsQuery = {
+    briefId?: string;
+    limit?: number;
+    next?: string;
+};
+/** List comments (optionally filtered by brief). */
+export declare const listBriefComments: (options: BriefApiClientOptions, query?: ListBriefCommentsQuery) => Promise<PagedResult<BriefComment>>;
+/**
+ * Input for `createBriefComment`.
+ *
+ * **UNVERIFIED** — no comment write was captured during reverse-engineering.
+ * The body below (`{ briefId, text }`) is a best guess. The Brief API's
+ * write scope (`co.briefs:w`) is documented as covering "post comments",
+ * so the endpoint exists — but the exact field names are unconfirmed.
+ * Verify by running `scai ops brief comments add <id> --text "…" --apply`
+ * against a tenant, then tighten this shape.
+ */
+export type CreateBriefCommentInput = {
+    /** Brief the comment is attached to. */
+    briefId: string;
+    /** Comment text. */
+    text: string;
+};
+/**
+ * Post a comment to a brief (`POST /api/brief/v1/comments`).
+ *
+ * **UNVERIFIED** — see `CreateBriefCommentInput`. Returns the persisted
+ * comment on success.
+ */
+export declare const createBriefComment: (options: BriefApiClientOptions, input: CreateBriefCommentInput) => Promise<BriefComment>;

package/dist/brief/api/comments.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBriefComment = exports.listBriefComments = void 0;
+const request_1 = require("./request");
+/** List comments (optionally filtered by brief). */
+const listBriefComments = (options, query) => {
+    const params = {};
+    if (query?.briefId)
+        params.BriefId = query.briefId;
+    if (query?.limit !== undefined)
+        params.Limit = query.limit;
+    if (query?.next)
+        params.Next = query.next;
+    return (0, request_1.briefRequest)(options, "/api/brief/v1/comments", {
+        query: params,
+    });
+};
+exports.listBriefComments = listBriefComments;
+/**
+ * Post a comment to a brief (`POST /api/brief/v1/comments`).
+ *
+ * **UNVERIFIED** — see `CreateBriefCommentInput`. Returns the persisted
+ * comment on success.
+ */
+const createBriefComment = (options, input) => (0, request_1.briefRequest)(options, "/api/brief/v1/comments", {
+    method: "POST",
+    body: { briefId: input.briefId, text: input.text },
+});
+exports.createBriefComment = createBriefComment;