@sitecoreai-labs/sitecoreai-cli 0.0.4 → 0.1.1

package/dist/hygiene/tasks/audit/all.js

@@ -0,0 +1,274 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAuditAll = exports.auditNames = void 0;
+const baseline_1 = require("../../baseline");
+const output_adapters_1 = require("../../output-adapters");
+const shared_1 = require("../shared");
+const alt_text_missing_1 = require("./alt-text-missing");
+const broken_images_1 = require("./broken-images");
+const broken_links_1 = require("./broken-links");
+const empty_roles_1 = require("./empty-roles");
+const fallback_drift_1 = require("./fallback-drift");
+const role_bloat_1 = require("./role-bloat");
+const slug_conflicts_1 = require("./slug-conflicts");
+const stale_users_1 = require("./stale-users");
+const translation_coverage_1 = require("./translation-coverage");
+const datasource_missing_1 = require("./datasource-missing");
+const dead_templates_1 = require("./dead-templates");
+const duplicates_1 = require("./duplicates");
+const empty_items_1 = require("./empty-items");
+const empty_links_1 = require("./empty-links");
+const find_replace_1 = require("./find-replace");
+const heavy_templates_1 = require("./heavy-templates");
+const language_data_1 = require("./language-data");
+const large_fields_1 = require("./large-fields");
+const missing_meta_1 = require("./missing-meta");
+const orphans_1 = require("./orphans");
+const page_design_orphans_1 = require("./page-design-orphans");
+const personalization_broken_1 = require("./personalization-broken");
+const references_1 = require("./references");
+const site_residue_1 = require("./site-residue");
+const stale_content_1 = require("./stale-content");
+const stale_workflow_1 = require("./stale-workflow");
+const template_dependencies_1 = require("./template-dependencies");
+const unused_media_1 = require("./unused-media");
+/**
+ * Convert a typed audit runner into the loose-typed registry shape.
+ * Mirrors `loosen<O>` in `src/mcp/tools/audit.ts` — same rationale:
+ * the runtime still hands every audit a `Record<string, unknown>`
+ * option bag (because the registry-driven dispatch path doesn't know
+ * the audit-specific option type at compile time), but the call to
+ * `loosen` requires its argument to return `Promise<X[]>`, so a
+ * runner regression (e.g. returning a non-array) fails type-check
+ * here instead of leaking into the dispatch path.
+ */
+const loosen = (fn) => fn;
+const AUDIT_REGISTRY = [
+    { name: "alt-text-missing", run: loosen(alt_text_missing_1.runAuditAltTextMissing) },
+    // broken-images makes external HTTP requests; off by default in `audit all`.
+    { name: "broken-images", run: loosen(broken_images_1.runAuditBrokenImages), requiresExtraConfig: true },
+    { name: "broken-links", run: loosen(broken_links_1.runAuditBrokenLinks) },
+    { name: "empty-roles", run: loosen(empty_roles_1.runAuditEmptyRoles) },
+    // fallback-drift + translation-coverage need explicit --target-languages.
+    { name: "fallback-drift", run: loosen(fallback_drift_1.runAuditFallbackDrift), requiresExtraConfig: true },
+    { name: "role-bloat", run: loosen(role_bloat_1.runAuditRoleBloat) },
+    { name: "slug-conflicts", run: loosen(slug_conflicts_1.runAuditSlugConflicts) },
+    { name: "stale-users", run: loosen(stale_users_1.runAuditStaleUsers) },
+    {
+        name: "translation-coverage",
+        run: loosen(translation_coverage_1.runAuditTranslationCoverage),
+        requiresExtraConfig: true,
+    },
+    { name: "datasource-missing", run: loosen(datasource_missing_1.runAuditDatasourceMissing) },
+    { name: "dead-templates", run: loosen(dead_templates_1.runAuditDeadTemplates) },
+    { name: "duplicates", run: loosen(duplicates_1.runAuditDuplicates) },
+    { name: "empty-items", run: loosen(empty_items_1.runAuditEmptyItems) },
+    { name: "empty-links", run: loosen(empty_links_1.runAuditEmptyLinks) },
+    // find-replace needs --pattern; only run if explicitly included AND pattern provided.
+    { name: "find-replace", run: loosen(find_replace_1.runAuditFindReplace), requiresExtraConfig: true },
+    { name: "heavy-templates", run: loosen(heavy_templates_1.runAuditHeavyTemplates) },
+    { name: "language-data", run: loosen(language_data_1.runAuditLanguageData) },
+    { name: "large-fields", run: loosen(large_fields_1.runAuditLargeFields) },
+    { name: "missing-meta", run: loosen(missing_meta_1.runAuditMissingMeta) },
+    { name: "orphans", run: loosen(orphans_1.runAuditOrphans) },
+    { name: "page-design-orphans", run: loosen(page_design_orphans_1.runAuditPageDesignOrphans) },
+    { name: "personalization-broken", run: loosen(personalization_broken_1.runAuditPersonalizationBroken) },
+    // references requires --to; off by default in `audit all`.
+    { name: "references", run: loosen(references_1.runAuditReferences), requiresExtraConfig: true },
+    { name: "site-residue", run: loosen(site_residue_1.runAuditSiteResidue) },
+    { name: "stale-content", run: loosen(stale_content_1.runAuditStaleContent) },
+    { name: "stale-workflow", run: loosen(stale_workflow_1.runAuditStaleWorkflow) },
+    // template-dependencies requires --template-id; off by default in `audit all`.
+    {
+        name: "template-dependencies",
+        run: loosen(template_dependencies_1.runAuditTemplateDependencies),
+        requiresExtraConfig: true,
+    },
+    { name: "unused-media", run: loosen(unused_media_1.runAuditUnusedMedia) },
+];
+const auditNames = () => AUDIT_REGISTRY.map((a) => a.name);
+exports.auditNames = auditNames;
+const runAuditAll = async (options) => {
+    const logger = (0, shared_1.toLogger)(options);
+    const want = pickAuditsToRun(options);
+    const { envName, configDir } = await resolveEnvForBaseline(options);
+    const baseline = options.baseline || options.updateBaseline
+        ? (0, baseline_1.openBaseline)({ envName, configDir, logger })
+        : null;
+    const subOptions = {
+        ...options,
+        // Each sub-audit prints its own report. Suppress that by forcing
+        // --json + --quiet — we emit the consolidated report ourselves.
+        json: true,
+        quiet: true,
+        // CRITICAL: strip the file-output flags. Without this, every
+        // sub-audit calls `writeAuditOutput` against the same path and
+        // overwrites the consolidated envelope mid-run; only the last
+        // audit's findings would survive, and any earlier ones would be
+        // visible only via the in-memory `results` array we keep here.
+        output: undefined,
+        format: undefined,
+    };
+    const results = [];
+    for (const audit of want) {
+        const start = Date.now();
+        try {
+            logger.verbose(`Running audit ${audit.name}…`);
+            const raw = (await audit.run(subOptions));
+            const findings = Array.isArray(raw) ? raw : [];
+            let kept = findings;
+            let ignored = [];
+            if (baseline && options.baseline) {
+                const split = (0, baseline_1.splitByBaseline)(audit.name, findings, baseline);
+                kept = split.kept;
+                ignored = split.ignored;
+            }
+            if (baseline && options.updateBaseline) {
+                for (const finding of findings)
+                    baseline.add(audit.name, finding, undefined);
+            }
+            results.push({
+                name: audit.name,
+                findings: kept,
+                ignored,
+                ignoredCount: ignored.length,
+                durationMs: Date.now() - start,
+            });
+        }
+        catch (error) {
+            results.push({
+                name: audit.name,
+                findings: [],
+                ignored: [],
+                ignoredCount: 0,
+                durationMs: Date.now() - start,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    if (baseline && options.updateBaseline) {
+        await baseline.flush();
+        logger.info(`Baseline updated: ${baseline.filePath}`, "green");
+    }
+    const envelope = {
+        command: "audit.all",
+        environment: envName,
+        baseline: baseline?.filePath ?? null,
+        summary: buildAllSummary(results),
+        counts: {
+            auditsRun: results.length,
+            auditsFailed: results.filter((r) => r.error).length,
+            totalFindings: results.reduce((n, r) => n + r.findings.length, 0),
+            totalIgnored: results.reduce((n, r) => n + r.ignoredCount, 0),
+        },
+        audits: Object.fromEntries(results.map((r) => [
+            r.name,
+            {
+                findings: r.findings,
+                ignoredCount: r.ignoredCount,
+                durationMs: r.durationMs,
+                ...(r.error && { error: r.error }),
+            },
+        ])),
+        // `data` is the canonical envelope key (renamed from `results` on
+        // 2026-05-14 to unify CLI output across deploy/hygiene surfaces).
+        // It mirrors the per-audit findings list for adapters that walk
+        // a flat array (CSV, Markdown table); the structured per-audit
+        // view stays under `audits`.
+        data: results.flatMap((r) => r.findings.map((f) => ({ audit: r.name, ...f }))),
+        count: results.reduce((n, r) => n + r.findings.length, 0),
+    };
+    const format = options.format ?? inferFormatOrDefault(options.output);
+    const body = (0, output_adapters_1.writeAuditOutput)(envelope, { format, output: options.output });
+    if (!options.output && !options.quiet) {
+        // Echo to stdout when no file output requested.
+        logger.json(envelope);
+    }
+    else if (options.output && !options.quiet) {
+        logger.info(`Wrote ${options.output} (${envelope.count} findings).`, "green");
+    }
+    else if (!options.output) {
+        // Quiet mode and no output file — still return; caller may read
+        // the envelope via stdout if json mode.
+        process.stdout.write(body);
+    }
+};
+exports.runAuditAll = runAuditAll;
+const pickAuditsToRun = (options) => {
+    const include = options.include?.length
+        ? new Set(options.include.map((s) => s.toLowerCase()))
+        : null;
+    const excludeAudit = new Set((options.excludeAudit ?? []).map((s) => s.toLowerCase()));
+    return AUDIT_REGISTRY.filter((a) => {
+        if (include) {
+            // Explicit include list — only run what's listed.
+            return include.has(a.name);
+        }
+        // Default: run everything except find-replace (needs --pattern).
+        if (a.requiresExtraConfig)
+            return false;
+        if (excludeAudit.has(a.name))
+            return false;
+        return true;
+    });
+};
+const resolveEnvForBaseline = async (options) => {
+    const { resolveEnvironment } = await Promise.resolve().then(() => __importStar(require("../../../policy/environment")));
+    const { envName } = resolveEnvironment(options);
+    const path = await Promise.resolve().then(() => __importStar(require("node:path")));
+    const configDir = path.dirname(options.config?.endsWith(".json") ? options.config : (options.config ?? process.cwd()));
+    return { envName, configDir: options.config ? configDir : process.cwd() };
+};
+const buildAllSummary = (results) => {
+    const totalFindings = results.reduce((n, r) => n + r.findings.length, 0);
+    const failed = results.filter((r) => r.error).length;
+    const parts = [];
+    parts.push(`${results.length} audit${results.length === 1 ? "" : "s"} run`);
+    parts.push(`${totalFindings} finding${totalFindings === 1 ? "" : "s"}`);
+    if (failed > 0)
+        parts.push(`${failed} audit${failed === 1 ? "" : "s"} failed`);
+    return parts.join(", ") + ".";
+};
+const inferFormatOrDefault = (output) => {
+    if (!output)
+        return "json";
+    const ext = output.toLowerCase().split(".").pop();
+    if (ext === "csv")
+        return "csv";
+    if (ext === "md" || ext === "markdown")
+        return "markdown";
+    return "json";
+};

package/dist/hygiene/tasks/audit/alt-text-missing.d.ts

@@ -0,0 +1,27 @@
+import { type HygieneCommonOptions } from "../shared";
+export interface AuditAltTextMissingOptions extends HygieneCommonOptions {
+    root?: string;
+    index?: string;
+    limit?: number;
+    includeSystem?: boolean;
+    language?: string;
+    batchSize?: number;
+    concurrency?: number;
+    pageParallelism?: number;
+    cache?: boolean;
+    exclude?: string[];
+    since?: string;
+    owner?: string;
+    baseline?: boolean;
+    output?: string;
+    format?: "json" | "csv" | "markdown";
+}
+export interface AltTextMissingReport {
+    itemId: string;
+    path: string;
+    templateName: string | null;
+    language: string | null;
+    fieldName: string;
+    mediaId: string | null;
+}
+export declare const runAuditAltTextMissing: (options: AuditAltTextMissingOptions) => Promise<AltTextMissingReport[]>;

package/dist/hygiene/tasks/audit/alt-text-missing.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAuditAltTextMissing = void 0;
+const shared_1 = require("../shared");
+/**
+ * Audit content for Image-field values that have no alt text.
+ *
+ * Sitecore Image fields store XML like:
+ *
+ *   <image mediaid="{...}" alt="" width="..." height="..."/>
+ *
+ * Accessibility audits care about `alt=""` (empty) on real images.
+ * The pattern matches the field value to detect Image-field XML
+ * with an empty `alt` attribute, OR with the attribute absent
+ * entirely.
+ *
+ * Notes:
+ *   - This is a per-field check; an item may have multiple Image
+ *     fields, each contributing to the report.
+ *   - Decorative images intentionally use `alt=""` for screen-reader
+ *     skipping. We can't distinguish those automatically — operators
+ *     who use that pattern should baseline the affected items.
+ */
+const IMAGE_FIELD_PATTERN = /<image\b[^>]*\/>/gi;
+const ALT_ATTR_PATTERN = /\balt=["']([^"']*)["']/i;
+const MEDIA_ID_PATTERN = /\bmediaid=["']([^"']*)["']/i;
+const runAuditAltTextMissing = async (options) => {
+    const logger = (0, shared_1.toLogger)(options);
+    const { envName, client } = (0, shared_1.resolveTenant)(options);
+    const root = options.root ?? "/sitecore/content";
+    const { scanned, fieldsByItemId, cache } = await (0, shared_1.scanItemsAndFields)({
+        client,
+        envName,
+        root,
+        logger,
+        options,
+    });
+    const reports = [];
+    for (const item of scanned) {
+        const fields = fieldsByItemId.get(item.itemId);
+        if (!fields || !Array.isArray(fields))
+            continue;
+        for (const field of fields) {
+            if (!field.value)
+                continue;
+            if (field.name.startsWith("__"))
+                continue;
+            // Each <image> XML in this field — Image fields hold one; RichText
+            // can hold many embedded as <img> (different tag we don't check
+            // here; that's a separate concern).
+            const matches = field.value.match(IMAGE_FIELD_PATTERN);
+            if (!matches)
+                continue;
+            for (const tag of matches) {
+                const altMatch = ALT_ATTR_PATTERN.exec(tag);
+                const alt = altMatch ? altMatch[1].trim() : "";
+                if (alt.length > 0)
+                    continue;
+                const mediaMatch = MEDIA_ID_PATTERN.exec(tag);
+                const mediaId = mediaMatch ? mediaMatch[1].replace(/[{}-]/g, "").toLowerCase() : null;
+                reports.push({
+                    itemId: item.itemId,
+                    path: item.path,
+                    templateName: item.templateName,
+                    language: item.language,
+                    fieldName: field.name,
+                    mediaId,
+                });
+            }
+        }
+    }
+    // Sort by path, then field name, so multi-field items group naturally.
+    reports.sort((a, b) => a.path.localeCompare(b.path) || a.fieldName.localeCompare(b.fieldName));
+    await cache?.flush();
+    (0, shared_1.printReport)({
+        logger,
+        command: "audit.alt-text-missing.list",
+        envName,
+        results: reports,
+        summary: `Scanned ${scanned.length} items; ${reports.length} Image field${reports.length === 1 ? " has" : "s have"} empty alt text.`,
+        formatLine: (r) => `${r.path} — ${r.fieldName}${r.mediaId ? ` (${r.mediaId.slice(0, 8)})` : ""}`,
+        extra: { root, scannedCount: scanned.length },
+        options,
+    });
+    return reports;
+};
+exports.runAuditAltTextMissing = runAuditAltTextMissing;

package/dist/hygiene/tasks/audit/baseline.d.ts

@@ -0,0 +1,66 @@
+import { type HygieneCommonOptions } from "../shared";
+/**
+ * `scai hygiene audit baseline <show|create|remove|reset>` task runners.
+ *
+ * Baseline files live at `.scai/audit-baseline-<envName>.json` and
+ * record the set of audit findings that should be ignored by future
+ * runs that pass `--baseline`. See `src/hygiene/baseline.ts` for the
+ * file shape and fingerprinting rules.
+ */
+export type BaselineShowOptions = HygieneCommonOptions;
+export interface BaselineCreateOptions extends HygieneCommonOptions {
+    /** Comma-separated audit names. Default: all. */
+    audits?: string[];
+    /** Replace existing entries instead of merging. Default false (merge). */
+    reset?: boolean;
+    root?: string;
+    limit?: number;
+    includeSystem?: boolean;
+}
+export interface BaselineRemoveOptions extends HygieneCommonOptions {
+    /** Audit name. */
+    audit: string;
+    /** Fingerprint to remove (from `baseline show`). */
+    fingerprint: string;
+}
+export interface BaselineResetOptions extends HygieneCommonOptions {
+    /** Audit name to reset. Default: all audits. */
+    audit?: string;
+}
+export interface BaselineAcceptOptions extends HygieneCommonOptions {
+    /** Audit name the findings belong to (must match the audit that produced the envelope). */
+    audit?: string;
+    /** Optional note recorded with every accepted entry. */
+    note?: string;
+    /**
+     * Read a `ScaiEnvelope` from stdin and add every finding in
+     * `envelope.data` to the baseline. The only ingestion mode in v1 —
+     * future shapes (e.g. `--all-current` to run the audit live and
+     * accept everything) can layer on top of the same library
+     * function.
+     */
+    fromStdin?: boolean;
+}
+export declare const runBaselineShow: (options: BaselineShowOptions) => Promise<void>;
+export declare const runBaselineCreate: (options: BaselineCreateOptions) => Promise<void>;
+export declare const runBaselineRemove: (options: BaselineRemoveOptions) => Promise<void>;
+export declare const runBaselineReset: (options: BaselineResetOptions) => Promise<void>;
+/**
+ * `scai hygiene audit baseline accept --audit <name> --from-stdin` — read a
+ * `ScaiEnvelope` from stdin (typically the output of an audit's
+ * `--json` mode) and mark every finding in `envelope.data` as
+ * accepted in the per-env baseline.
+ *
+ * Closes the agent-friendly loop the feedback agent called out:
+ * baseline was underused because there was no fast way to say "yes,
+ * everything I just saw is intentional." Pair with the canonical
+ * envelope (every audit emits one) and you get a one-pipeline
+ * answer:
+ *
+ *   $ scai hygiene audit broken-links list --json \
+ *     | scai hygiene audit baseline accept --audit broken-links --note "known debt"
+ *
+ * Skips fingerprints that are already in the baseline so the
+ * pipeline is idempotent.
+ */
+export declare const runBaselineAccept: (options: BaselineAcceptOptions) => Promise<void>;

package/dist/hygiene/tasks/audit/baseline.js

@@ -0,0 +1,185 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBaselineAccept = exports.runBaselineReset = exports.runBaselineRemove = exports.runBaselineCreate = exports.runBaselineShow = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const environment_1 = require("../../../policy/environment");
+const errors_1 = require("../../../shared/errors");
+const envelope_1 = require("../../../shared/envelope");
+const baseline_1 = require("../../baseline");
+const shared_1 = require("../shared");
+const all_1 = require("./all");
+const all_2 = require("./all");
+const resolveConfigDir = (options) => {
+    if (!options.config)
+        return process.cwd();
+    if (options.config.endsWith(".json"))
+        return node_path_1.default.dirname(options.config);
+    return options.config;
+};
+const runBaselineShow = async (options) => {
+    const logger = (0, shared_1.toLogger)(options);
+    const { envName } = (0, environment_1.resolveEnvironment)(options);
+    const baseline = (0, baseline_1.openBaseline)({
+        envName,
+        configDir: resolveConfigDir(options),
+        logger,
+    });
+    const snapshot = baseline.snapshot();
+    const totalEntries = Object.values(snapshot.ignored).reduce((n, list) => n + list.length, 0);
+    if (logger.isJson()) {
+        logger.json({
+            command: "audit.baseline.show",
+            environment: envName,
+            filePath: baseline.filePath,
+            totalEntries,
+            ignored: snapshot.ignored,
+        });
+        return;
+    }
+    logger.info(`Baseline: ${baseline.filePath}`);
+    logger.info(`${totalEntries} entr${totalEntries === 1 ? "y" : "ies"} ignored.`);
+    for (const [audit, list] of Object.entries(snapshot.ignored)) {
+        if (!list.length)
+            continue;
+        logger.info(`  ${audit}: ${list.length}`);
+        for (const e of list.slice(0, 5)) {
+            logger.info(`    ${e.fingerprint}${e.note ? ` — ${e.note}` : ""}`);
+        }
+        if (list.length > 5)
+            logger.info(`    … +${list.length - 5} more`);
+    }
+};
+exports.runBaselineShow = runBaselineShow;
+const runBaselineCreate = async (options) => {
+    const logger = (0, shared_1.toLogger)(options);
+    const { envName } = (0, environment_1.resolveEnvironment)(options);
+    const configDir = resolveConfigDir(options);
+    const baseline = (0, baseline_1.openBaseline)({ envName, configDir, logger });
+    if (options.reset) {
+        // Wipe existing audit entries we're about to refresh.
+        const snap = baseline.snapshot();
+        const target = options.audits?.length ? options.audits : (0, all_1.auditNames)();
+        for (const a of target) {
+            for (const e of snap.ignored[a] ?? [])
+                baseline.remove(a, e.fingerprint);
+        }
+    }
+    // Run the chosen audits and add every finding to the baseline.
+    await (0, all_2.runAuditAll)({
+        ...options,
+        include: options.audits,
+        updateBaseline: true,
+        json: true,
+        quiet: true,
+    });
+    logger.info(`Baseline ${options.reset ? "reset" : "updated"} at ${baseline.filePath}`, "green");
+};
+exports.runBaselineCreate = runBaselineCreate;
+const runBaselineRemove = async (options) => {
+    const logger = (0, shared_1.toLogger)(options);
+    if (!options.audit || !options.fingerprint) {
+        throw (0, errors_1.createScaiError)("Both --audit and --fingerprint are required.", "INPUT_INVALID");
+    }
+    const { envName } = (0, environment_1.resolveEnvironment)(options);
+    const baseline = (0, baseline_1.openBaseline)({
+        envName,
+        configDir: resolveConfigDir(options),
+        logger,
+    });
+    baseline.remove(options.audit, options.fingerprint);
+    await baseline.flush();
+    logger.info(`Removed ${options.audit}/${options.fingerprint} from baseline ${baseline.filePath}`, "green");
+};
+exports.runBaselineRemove = runBaselineRemove;
+const runBaselineReset = async (options) => {
+    const logger = (0, shared_1.toLogger)(options);
+    const { envName } = (0, environment_1.resolveEnvironment)(options);
+    const baseline = (0, baseline_1.openBaseline)({
+        envName,
+        configDir: resolveConfigDir(options),
+        logger,
+    });
+    const snap = baseline.snapshot();
+    const target = options.audit ? [options.audit] : Object.keys(snap.ignored);
+    let removed = 0;
+    for (const a of target) {
+        for (const e of snap.ignored[a] ?? []) {
+            baseline.remove(a, e.fingerprint);
+            removed += 1;
+        }
+    }
+    await baseline.flush();
+    logger.info(`Removed ${removed} entr${removed === 1 ? "y" : "ies"} from ${baseline.filePath}`, "green");
+};
+exports.runBaselineReset = runBaselineReset;
+/**
+ * `scai hygiene audit baseline accept --audit <name> --from-stdin` — read a
+ * `ScaiEnvelope` from stdin (typically the output of an audit's
+ * `--json` mode) and mark every finding in `envelope.data` as
+ * accepted in the per-env baseline.
+ *
+ * Closes the agent-friendly loop the feedback agent called out:
+ * baseline was underused because there was no fast way to say "yes,
+ * everything I just saw is intentional." Pair with the canonical
+ * envelope (every audit emits one) and you get a one-pipeline
+ * answer:
+ *
+ *   $ scai hygiene audit broken-links list --json \
+ *     | scai hygiene audit baseline accept --audit broken-links --note "known debt"
+ *
+ * Skips fingerprints that are already in the baseline so the
+ * pipeline is idempotent.
+ */
+const runBaselineAccept = async (options) => {
+    const logger = (0, shared_1.toLogger)(options);
+    if (!options.audit) {
+        throw (0, errors_1.createScaiError)("audit baseline accept requires --audit <name>.", "INPUT_INVALID");
+    }
+    if (!options.fromStdin) {
+        throw (0, errors_1.createScaiError)("audit baseline accept requires --from-stdin (pipe an audit --json envelope).", "INPUT_INVALID", {
+            hint: "Run e.g. `scai hygiene audit broken-links list --json | scai hygiene audit baseline accept --audit broken-links`.",
+        });
+    }
+    const envelope = await (0, envelope_1.readScaiEnvelopeFromStdin)();
+    if (!Array.isArray(envelope.data)) {
+        throw (0, errors_1.createScaiError)(`audit baseline accept: stdin envelope.data is not an array (got ${typeof envelope.data}).`, "INPUT_INVALID");
+    }
+    const { envName } = (0, environment_1.resolveEnvironment)(options);
+    const baseline = (0, baseline_1.openBaseline)({
+        envName,
+        configDir: resolveConfigDir(options),
+        logger,
+    });
+    let added = 0;
+    let alreadyPresent = 0;
+    for (const finding of envelope.data) {
+        if (baseline.isIgnored(options.audit, finding)) {
+            alreadyPresent += 1;
+            continue;
+        }
+        baseline.add(options.audit, finding, options.note);
+        added += 1;
+    }
+    await baseline.flush();
+    const summary = `Accepted ${added} new finding${added === 1 ? "" : "s"} into baseline ${baseline.filePath}${alreadyPresent > 0 ? ` (${alreadyPresent} already present, skipped)` : ""}.`;
+    if (logger.isJson()) {
+        logger.json((0, envelope_1.buildScaiEnvelope)({
+            command: "audit.baseline.accept",
+            environment: envName,
+            data: {
+                audit: options.audit,
+                added,
+                alreadyPresent,
+                filePath: baseline.filePath,
+                sourceCommand: envelope.command,
+            },
+            extra: { summary },
+        }));
+        return;
+    }
+    logger.info(summary, added > 0 ? "green" : "gray");
+};
+exports.runBaselineAccept = runBaselineAccept;

package/dist/hygiene/tasks/audit/broken-images.d.ts

@@ -0,0 +1,41 @@
+import { type HygieneCommonOptions } from "../shared";
+export interface AuditBrokenImagesOptions extends HygieneCommonOptions {
+    /** Content root. Default `/sitecore/content`. */
+    root?: string;
+    index?: string;
+    limit?: number;
+    includeSystem?: boolean;
+    language?: string;
+    batchSize?: number;
+    concurrency?: number;
+    pageParallelism?: number;
+    cache?: boolean;
+    exclude?: string[];
+    since?: string;
+    owner?: string;
+    baseline?: boolean;
+    output?: string;
+    format?: "json" | "csv" | "markdown";
+    /** HTTP timeout in ms for each HEAD request. Default 5000. */
+    requestTimeoutMs?: number;
+    /** Max number of unique URLs probed. Default 500. */
+    urlLimit?: number;
+    /**
+     * Domains to exclude from probing. Repeatable. Sitecore media
+     * library URLs (typically same-origin) are always probed; this is
+     * for skipping external image hosts you can't reach.
+     */
+    excludeDomains?: string[];
+}
+export interface BrokenImageReport {
+    itemId: string;
+    path: string;
+    templateName: string | null;
+    language: string | null;
+    brokenImages: Array<{
+        fieldName: string;
+        url: string;
+        status: number | "timeout" | "network-error";
+    }>;
+}
+export declare const runAuditBrokenImages: (options: AuditBrokenImagesOptions) => Promise<BrokenImageReport[]>;