@sitecoreai-labs/sitecoreai-cli 0.0.4 → 0.1.0

package/dist/hygiene/cache.js

@@ -0,0 +1,179 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAuditCacheEnabled = exports.wrapFieldsBatchWithCache = exports.createFieldCache = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * Cross-audit field cache.
+ *
+ * Many hygiene audits make the same shape of read: search-paginate
+ * → fetch fields per item via `getItemFieldsBatch`. Running multiple
+ * audits back-to-back (e.g. `broken-links` then `unused-media` then
+ * `duplicates`) re-fetches the same field bundles, each round trip
+ * costing ~150-300ms.
+ *
+ * This cache stores per-item field bundles keyed by `(envName, itemId,
+ * updatedDate)`. The updatedDate from the search index serves as a
+ * cheap freshness check — if the cached entry's updatedDate matches
+ * the search result's updatedDate, we can skip the field fetch and
+ * use the cached bundle.
+ *
+ * **When is it correct to use?** Reads are diagnostic-shaped: if the
+ * cache returns slightly-stale data, the worst case is a false-positive
+ * audit flag (the operator goes to look at an item that was already
+ * fixed). No mutations consult the cache. The `updatedDate` invariant
+ * also means changes show up within one search-index refresh window
+ * (typically seconds-to-minutes on XM Cloud).
+ *
+ * **Storage.** JSON file at `~/.sitecoreai/audit-cache/<envName>.json`.
+ * Per-env files mean cross-tenant isolation; one corrupt file doesn't
+ * sink all caches. LRU-capped at 50_000 entries to keep file size
+ * bounded (typical entry is ~500 bytes, capping at ~25MB per env).
+ */
+const DEFAULT_MAX_ENTRIES = 50000;
+const CACHE_DIR = node_path_1.default.join(node_os_1.default.homedir(), ".sitecoreai", "audit-cache");
+const CACHE_VERSION = 1;
+const resolveCacheFile = (envName, baseDir) => node_path_1.default.join(baseDir, `${envName.replace(/[^A-Za-z0-9._-]/g, "_")}.json`);
+const loadCache = (filePath, envName, logger) => {
+    if (!node_fs_1.default.existsSync(filePath)) {
+        return { version: CACHE_VERSION, envName, entries: {} };
+    }
+    try {
+        const raw = node_fs_1.default.readFileSync(filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed.version !== CACHE_VERSION || parsed.envName !== envName) {
+            // Wrong-version or wrong-env file → start fresh, don't blow up.
+            return { version: CACHE_VERSION, envName, entries: {} };
+        }
+        return parsed;
+    }
+    catch (error) {
+        logger?.warn(`Audit cache for env ${envName} is unreadable; starting fresh. (${error instanceof Error ? error.message : String(error)})`);
+        return { version: CACHE_VERSION, envName, entries: {} };
+    }
+};
+const saveCache = (filePath, file, logger) => {
+    try {
+        node_fs_1.default.mkdirSync(node_path_1.default.dirname(filePath), { recursive: true });
+        node_fs_1.default.writeFileSync(filePath, JSON.stringify(file), "utf8");
+    }
+    catch (error) {
+        logger?.warn(`Failed to persist audit cache to ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+const createFieldCache = (options) => {
+    const baseDir = options.cacheDir ?? CACHE_DIR;
+    const filePath = resolveCacheFile(options.envName, baseDir);
+    const maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
+    const file = loadCache(filePath, options.envName, options.logger);
+    let hits = 0;
+    let misses = 0;
+    let dirty = false;
+    const evictLruIfNeeded = () => {
+        const keys = Object.keys(file.entries);
+        if (keys.length <= maxEntries)
+            return;
+        const sorted = keys
+            .map((k) => ({ k, t: file.entries[k].lastAccessed }))
+            .sort((a, b) => a.t - b.t);
+        const dropCount = keys.length - maxEntries;
+        for (let i = 0; i < dropCount; i += 1) {
+            delete file.entries[sorted[i].k];
+        }
+    };
+    return {
+        get(itemId, updatedDate) {
+            if (!updatedDate) {
+                misses += 1;
+                return null;
+            }
+            const entry = file.entries[itemId];
+            if (!entry) {
+                misses += 1;
+                return null;
+            }
+            if (entry.updatedDate !== updatedDate) {
+                // Stale — drop it; next set() will repopulate.
+                delete file.entries[itemId];
+                dirty = true;
+                misses += 1;
+                return null;
+            }
+            entry.lastAccessed = Date.now();
+            dirty = true;
+            hits += 1;
+            return entry.fields;
+        },
+        set(itemId, updatedDate, fields) {
+            if (!updatedDate)
+                return;
+            file.entries[itemId] = {
+                updatedDate,
+                fields,
+                lastAccessed: Date.now(),
+            };
+            dirty = true;
+            evictLruIfNeeded();
+        },
+        async flush() {
+            if (!dirty)
+                return;
+            saveCache(filePath, file, options.logger);
+            dirty = false;
+        },
+        stats() {
+            return {
+                hits,
+                misses,
+                size: Object.keys(file.entries).length,
+            };
+        },
+    };
+};
+exports.createFieldCache = createFieldCache;
+/**
+ * Wrap `getItemFieldsBatch` with a field-cache layer. The returned
+ * function consults the cache first per item, then defers to the
+ * underlying batch for any cache misses, and finally writes the
+ * fresh results back into the cache.
+ *
+ * `searchResults` is required so the wrapper knows each item's
+ * `updatedDate` — that's the cache freshness key. Callers pass the
+ * search results from the same enumeration pass.
+ */
+const wrapFieldsBatchWithCache = (underlying, cache, updatedDateByItemId) => {
+    return async (itemIds) => {
+        const result = new Map();
+        const misses = [];
+        for (const id of itemIds) {
+            const updated = updatedDateByItemId.get(id);
+            const cached = cache.get(id, updated);
+            if (cached) {
+                result.set(id, cached);
+            }
+            else {
+                misses.push(id);
+            }
+        }
+        if (misses.length > 0) {
+            const fresh = await underlying(misses);
+            for (const [id, fields] of fresh) {
+                result.set(id, fields);
+                if (fields) {
+                    cache.set(id, updatedDateByItemId.get(id), fields);
+                }
+            }
+        }
+        return result;
+    };
+};
+exports.wrapFieldsBatchWithCache = wrapFieldsBatchWithCache;
+const isAuditCacheEnabled = () => {
+    const v = (process.env.SITECOREAI_AUDIT_CACHE ?? "").toLowerCase().trim();
+    return v === "1" || v === "true" || v === "yes" || v === "on";
+};
+exports.isAuditCacheEnabled = isAuditCacheEnabled;

package/dist/hygiene/history.d.ts

@@ -0,0 +1,70 @@
+import { Logger } from "../shared/logger";
+export interface HistorySnapshot {
+    version: number;
+    envName: string;
+    capturedAt: string;
+    /** Map of audit-name → list of findings (fingerprints + a sample). */
+    audits: Record<string, Array<{
+        fingerprint: string;
+        sample?: Record<string, unknown>;
+    }>>;
+}
+export interface SnapshotEntry {
+    filePath: string;
+    capturedAt: string;
+}
+export interface CaptureAuditAllEnvelope {
+    audits?: Record<string, {
+        findings?: unknown[];
+        ignoredCount?: number;
+        durationMs?: number;
+        error?: string;
+    }>;
+}
+/**
+ * Take an `audit all` envelope and persist it as a history snapshot.
+ * Returns the full path to the snapshot file.
+ */
+export declare const captureHistory: (params: {
+    envName: string;
+    configDir: string;
+    envelope: CaptureAuditAllEnvelope;
+    logger?: Logger;
+    now?: Date;
+}) => string;
+/** List history snapshots for an env, newest first. */
+export declare const listHistory: (params: {
+    envName: string;
+    configDir: string;
+}) => SnapshotEntry[];
+export declare const loadSnapshot: (filePath: string) => HistorySnapshot;
+export interface DiffSummary {
+    fromCapturedAt: string;
+    toCapturedAt: string;
+    perAudit: Record<string, {
+        total: {
+            from: number;
+            to: number;
+            delta: number;
+        };
+        added: Array<{
+            fingerprint: string;
+            sample?: Record<string, unknown>;
+        }>;
+        removed: Array<{
+            fingerprint: string;
+            sample?: Record<string, unknown>;
+        }>;
+    }>;
+    totals: {
+        added: number;
+        removed: number;
+        net: number;
+    };
+}
+/**
+ * Compute a delta between two snapshots: items added (present in
+ * `to` but not `from`) and removed (vice versa), grouped by audit.
+ * Identity is by fingerprint, same as baselines.
+ */
+export declare const diffSnapshots: (from: HistorySnapshot, to: HistorySnapshot) => DiffSummary;

package/dist/hygiene/history.js

@@ -0,0 +1,148 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffSnapshots = exports.loadSnapshot = exports.listHistory = exports.captureHistory = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("../shared/errors");
+const baseline_1 = require("./baseline");
+/**
+ * Audit history — snapshots of `audit all` results over time, used
+ * for trend tracking ("did broken-links count go up this week?").
+ *
+ * Distinct from baselines (an ignore-list of accepted findings).
+ * History is a journal — every snapshot is preserved, and the diff
+ * command computes per-audit deltas between two snapshots.
+ *
+ * Storage: `.scai/audit-history/<envName>-<datetime>.json` containing
+ * the full audit-all envelope. One file per capture.
+ */
+const HISTORY_VERSION = 1;
+const resolveHistoryDir = (envName, configDir) => {
+    const safeName = envName.replace(/[^A-Za-z0-9._-]/g, "_");
+    return node_path_1.default.join(configDir, ".scai", "audit-history", safeName);
+};
+const formatTimestamp = (date) => {
+    const pad = (n) => n.toString().padStart(2, "0");
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}T${pad(date.getHours())}-${pad(date.getMinutes())}-${pad(date.getSeconds())}`;
+};
+/**
+ * Take an `audit all` envelope and persist it as a history snapshot.
+ * Returns the full path to the snapshot file.
+ */
+const captureHistory = (params) => {
+    const now = params.now ?? new Date();
+    const dir = resolveHistoryDir(params.envName, params.configDir);
+    node_fs_1.default.mkdirSync(dir, { recursive: true });
+    const file = node_path_1.default.join(dir, `${formatTimestamp(now)}.json`);
+    const snapshot = {
+        version: HISTORY_VERSION,
+        envName: params.envName,
+        capturedAt: now.toISOString(),
+        audits: {},
+    };
+    for (const [auditName, info] of Object.entries(params.envelope.audits ?? {})) {
+        const findings = info.findings ?? [];
+        snapshot.audits[auditName] = findings.map((f) => ({
+            fingerprint: (0, baseline_1.fingerprintFinding)(auditName, f),
+            sample: extractSampleFields(f),
+        }));
+    }
+    node_fs_1.default.writeFileSync(file, JSON.stringify(snapshot, null, 2), "utf8");
+    params.logger?.verbose(`Captured snapshot: ${file}`);
+    return file;
+};
+exports.captureHistory = captureHistory;
+/**
+ * Pull a small sample of identifying fields (path, itemId, etc.) for
+ * the snapshot so `audit-history diff` can show human-readable rows
+ * without storing the full finding payload.
+ */
+const extractSampleFields = (finding) => {
+    if (!finding || typeof finding !== "object")
+        return undefined;
+    const f = finding;
+    const sample = {};
+    for (const key of ["path", "itemId", "name", "user", "contentHash", "templateId", "archivalId"]) {
+        if (f[key] !== undefined)
+            sample[key] = f[key];
+    }
+    return Object.keys(sample).length > 0 ? sample : undefined;
+};
+/** List history snapshots for an env, newest first. */
+const listHistory = (params) => {
+    const dir = resolveHistoryDir(params.envName, params.configDir);
+    if (!node_fs_1.default.existsSync(dir))
+        return [];
+    return node_fs_1.default
+        .readdirSync(dir)
+        .filter((f) => f.endsWith(".json"))
+        .map((f) => {
+        const full = node_path_1.default.join(dir, f);
+        const stat = node_fs_1.default.statSync(full);
+        return { filePath: full, capturedAt: stat.mtime.toISOString() };
+    })
+        .sort((a, b) => b.capturedAt.localeCompare(a.capturedAt));
+};
+exports.listHistory = listHistory;
+const loadSnapshot = (filePath) => {
+    if (!node_fs_1.default.existsSync(filePath)) {
+        throw (0, errors_1.createScaiError)(`Snapshot not found: ${filePath}`, "CONFIG_NOT_FOUND");
+    }
+    try {
+        const raw = node_fs_1.default.readFileSync(filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed.version !== HISTORY_VERSION) {
+            throw (0, errors_1.createScaiError)(`Snapshot version mismatch: ${parsed.version} vs expected ${HISTORY_VERSION} (${filePath})`, "CONFIG_INVALID");
+        }
+        return parsed;
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            "code" in error &&
+            error.code === "CONFIG_INVALID") {
+            throw error;
+        }
+        throw (0, errors_1.createScaiError)(`Failed to read snapshot: ${error instanceof Error ? error.message : String(error)}`, "CONFIG_INVALID");
+    }
+};
+exports.loadSnapshot = loadSnapshot;
+/**
+ * Compute a delta between two snapshots: items added (present in
+ * `to` but not `from`) and removed (vice versa), grouped by audit.
+ * Identity is by fingerprint, same as baselines.
+ */
+const diffSnapshots = (from, to) => {
+    const auditNames = new Set([...Object.keys(from.audits), ...Object.keys(to.audits)]);
+    const perAudit = {};
+    let totalAdded = 0;
+    let totalRemoved = 0;
+    for (const name of auditNames) {
+        const fromFindings = from.audits[name] ?? [];
+        const toFindings = to.audits[name] ?? [];
+        const fromFps = new Set(fromFindings.map((f) => f.fingerprint));
+        const toFps = new Set(toFindings.map((f) => f.fingerprint));
+        const added = toFindings.filter((f) => !fromFps.has(f.fingerprint));
+        const removed = fromFindings.filter((f) => !toFps.has(f.fingerprint));
+        perAudit[name] = {
+            total: {
+                from: fromFindings.length,
+                to: toFindings.length,
+                delta: toFindings.length - fromFindings.length,
+            },
+            added,
+            removed,
+        };
+        totalAdded += added.length;
+        totalRemoved += removed.length;
+    }
+    return {
+        fromCapturedAt: from.capturedAt,
+        toCapturedAt: to.capturedAt,
+        perAudit,
+        totals: { added: totalAdded, removed: totalRemoved, net: totalAdded - totalRemoved },
+    };
+};
+exports.diffSnapshots = diffSnapshots;

package/dist/hygiene/index.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Public entry for `@sitecoreai-labs/sitecoreai-cli/hygiene`.
+ *
+ * Hygiene = the audit + cleanup surface (`scai hygiene audit *`, `scai hygiene cleanup *`).
+ * Replaces the dotnet `Sitecore.DevEx dbcleanup` family with a typed,
+ * agent-friendly equivalent. See [[scai-content-hygiene-area]] for the
+ * design decisions.
+ *
+ * Three layers exposed here:
+ *
+ *   1. **API client** — `createHygieneApiClient` + the search/item/role/
+ *      user typed surface it wraps. Build your own task runner on top
+ *      of this if the bundled runners don't fit.
+ *   2. **Task runners** — the same runners the CLI commands call. One
+ *      per audit/cleanup, plus the suite/baseline/history wrappers.
+ *   3. **Output + baseline helpers** — JSON/CSV/Markdown formatting,
+ *      baseline diffing, history snapshots, field-cache.
+ */
+export { createHygieneApiClient, type HygieneApiClient, type HygieneClientOptions, type ItemWorkflowState, type ArchiveVersionInput, type ArchivedItem, type ChildSummary, type DeleteItemInput, type DeleteItemVersionInput, type ItemField, type ItemTemplateSummary, type ItemVersion, type RoleSummary, type SearchCriterion, type SearchCriteriaType, type SearchOperator, type SearchPage, type SearchPaging, type SearchQuery, type SearchResultItem, type SearchStatement, type UserDetail, type UserSummary, MEDIA_LIBRARY_ROOT, DEFAULT_MASTER_INDEX, } from "./api/client";
+export { runHygieneAuthoringGraphQL, type AuthoringRequestOptions as HygieneAuthoringRequestOptions, } from "./api/graphql";
+export { formatAuditOutput, writeAuditOutput, inferFormatFromExtension, type AuditEnvelope, type OutputFormat, } from "./output-adapters";
+export { fingerprintFinding, openBaseline, splitByBaseline, type BaselineEntry, type BaselineFile, type BaselineHandle, type OpenBaselineOptions, } from "./baseline";
+export { captureHistory, listHistory, loadSnapshot, diffSnapshots, type CaptureAuditAllEnvelope, type DiffSummary, type HistorySnapshot, type SnapshotEntry, } from "./history";
+export { loadAuditSuite, expandOutputPath, auditSuiteToRunnerInput, type AuditSuiteEntry, type AuditSuiteFile, } from "./audit-suite";
+export { createFieldCache, wrapFieldsBatchWithCache, isAuditCacheEnabled, type FieldCache, type FieldCacheOptions, } from "./cache";
+export { runAuditBrokenLinks } from "./tasks/audit/broken-links";
+export type { AuditBrokenLinksOptions, BrokenLinkReport } from "./tasks/audit/broken-links";
+export { runAuditUnusedMedia } from "./tasks/audit/unused-media";
+export type { AuditUnusedMediaOptions, UnusedMediaReport } from "./tasks/audit/unused-media";
+export { runAuditOrphans } from "./tasks/audit/orphans";
+export type { AuditOrphansOptions, OrphanReport } from "./tasks/audit/orphans";
+export { runAuditStaleWorkflow } from "./tasks/audit/stale-workflow";
+export type { AuditStaleWorkflowOptions, StaleWorkflowReport } from "./tasks/audit/stale-workflow";
+export { runAuditLanguageData } from "./tasks/audit/language-data";
+export type { AuditLanguageDataOptions, LanguageDataReport } from "./tasks/audit/language-data";
+export { runAuditDeadTemplates } from "./tasks/audit/dead-templates";
+export type { AuditDeadTemplatesOptions, DeadTemplateReport } from "./tasks/audit/dead-templates";
+export { runAuditDatasourceMissing } from "./tasks/audit/datasource-missing";
+export type { AuditDatasourceMissingOptions, DatasourceMissingReport, } from "./tasks/audit/datasource-missing";
+export { runAuditDuplicates } from "./tasks/audit/duplicates";
+export type { AuditDuplicatesOptions, DuplicatesGroup } from "./tasks/audit/duplicates";
+export { runAuditEmptyItems } from "./tasks/audit/empty-items";
+export type { AuditEmptyItemsOptions, EmptyItemReport } from "./tasks/audit/empty-items";
+export { runAuditPageDesignOrphans } from "./tasks/audit/page-design-orphans";
+export type { AuditPageDesignOrphansOptions, PageDesignOrphanReport, } from "./tasks/audit/page-design-orphans";
+export { runAuditPersonalizationBroken } from "./tasks/audit/personalization-broken";
+export type { AuditPersonalizationBrokenOptions, PersonalizationBrokenReport, } from "./tasks/audit/personalization-broken";
+export { runCleanupVersionsPrune } from "./tasks/cleanup/versions-prune";
+export type { CleanupVersionsPruneOptions, VersionPruneAction, } from "./tasks/cleanup/versions-prune";
+export { runCleanupArchivePurge } from "./tasks/cleanup/archive-purge";
+export type { CleanupArchivePurgeOptions, ArchivePurgeAction } from "./tasks/cleanup/archive-purge";
+export { runCleanupDeadTemplates } from "./tasks/cleanup/dead-templates";
+export type { CleanupDeadTemplatesOptions, DeadTemplatePurgeAction, FolderCleanupAction, } from "./tasks/cleanup/dead-templates";
+export { runCleanupDuplicates } from "./tasks/cleanup/duplicates";
+export type { CleanupDuplicatesOptions, DuplicatePurgeAction, DuplicatesKeepRule, } from "./tasks/cleanup/duplicates";
+export { runCleanupSlugConflicts } from "./tasks/cleanup/slug-conflicts";
+export type { CleanupSlugConflictsOptions, SlugConflictPurgeAction, SlugConflictsAction, SlugConflictsKeepRule, } from "./tasks/cleanup/slug-conflicts";
+export { runCleanupVersionsArchive } from "./tasks/cleanup/versions-archive";
+export type { CleanupVersionsArchiveOptions, VersionArchiveAction, } from "./tasks/cleanup/versions-archive";
+export { runAuditFindReplace } from "./tasks/audit/find-replace";
+export type { AuditFindReplaceOptions, FindReplaceMatch } from "./tasks/audit/find-replace";
+export { runAuditStaleContent } from "./tasks/audit/stale-content";
+export type { AuditStaleContentOptions, StaleContentReport } from "./tasks/audit/stale-content";
+export { runCleanupFindReplace } from "./tasks/cleanup/find-replace";
+export type { CleanupFindReplaceOptions, FindReplaceAction } from "./tasks/cleanup/find-replace";
+export { runAuditLargeFields } from "./tasks/audit/large-fields";
+export type { AuditLargeFieldsOptions, LargeFieldReport } from "./tasks/audit/large-fields";
+export { runAuditHeavyTemplates } from "./tasks/audit/heavy-templates";
+export type { AuditHeavyTemplatesOptions, HeavyTemplateReport, } from "./tasks/audit/heavy-templates";
+export { runAuditMissingMeta } from "./tasks/audit/missing-meta";
+export type { AuditMissingMetaOptions, MissingMetaReport } from "./tasks/audit/missing-meta";
+export { runAuditAltTextMissing } from "./tasks/audit/alt-text-missing";
+export type { AuditAltTextMissingOptions, AltTextMissingReport, } from "./tasks/audit/alt-text-missing";
+export { runAuditRoleBloat } from "./tasks/audit/role-bloat";
+export type { AuditRoleBloatOptions, RoleBloatReport } from "./tasks/audit/role-bloat";
+export { runAuditEmptyRoles } from "./tasks/audit/empty-roles";
+export type { AuditEmptyRolesOptions, EmptyRoleReport } from "./tasks/audit/empty-roles";
+export { runAuditStaleUsers } from "./tasks/audit/stale-users";
+export type { AuditStaleUsersOptions, StaleUserReport } from "./tasks/audit/stale-users";
+export { runAuditBrokenImages } from "./tasks/audit/broken-images";
+export type { AuditBrokenImagesOptions, BrokenImageReport } from "./tasks/audit/broken-images";
+export { runAuditSlugConflicts } from "./tasks/audit/slug-conflicts";
+export type { AuditSlugConflictsOptions, SlugConflictGroup } from "./tasks/audit/slug-conflicts";
+export { runAuditTranslationCoverage } from "./tasks/audit/translation-coverage";
+export type { AuditTranslationCoverageOptions, TranslationCoverageReport, } from "./tasks/audit/translation-coverage";
+export { runAuditFallbackDrift } from "./tasks/audit/fallback-drift";
+export type { AuditFallbackDriftOptions, FallbackDriftReport } from "./tasks/audit/fallback-drift";
+export { runAuditEmptyLinks } from "./tasks/audit/empty-links";
+export type { AuditEmptyLinksOptions, EmptyLinkReport } from "./tasks/audit/empty-links";
+export { runCleanupFieldSet } from "./tasks/cleanup/field-set";
+export type { CleanupFieldSetOptions, FieldSetAction, FieldSetMode, } from "./tasks/cleanup/field-set";
+export { runCleanupRename } from "./tasks/cleanup/rename";
+export type { CleanupRenameOptions, RenameAction } from "./tasks/cleanup/rename";
+export { runCleanupLanguageVersionAdd } from "./tasks/cleanup/language-version-add";
+export type { CleanupLanguageVersionAddOptions, LanguageVersionAddAction, } from "./tasks/cleanup/language-version-add";
+export { runAuditSiteResidue } from "./tasks/audit/site-residue";
+export type { AuditSiteResidueOptions, SiteResidueKind, SiteResidueReport, } from "./tasks/audit/site-residue";
+export { runCleanupSiteResidue } from "./tasks/cleanup/site-residue";
+export type { CleanupSiteResidueOptions, SiteResidueCleanupAction, InboundRef, } from "./tasks/cleanup/site-residue";
+export { runCleanupWorkflowAdvance } from "./tasks/cleanup/workflow-advance";
+export type { CleanupWorkflowAdvanceOptions, WorkflowAdvanceAction, } from "./tasks/cleanup/workflow-advance";
+export { runCleanupWorkflowApply } from "./tasks/cleanup/workflow-apply";
+export type { CleanupWorkflowApplyOptions, WorkflowApplyAction, WorkflowApplyActionStatus, } from "./tasks/cleanup/workflow-apply";
+export { runCleanupEmptyFolders } from "./tasks/cleanup/empty-folders";
+export type { CleanupEmptyFoldersOptions, EmptyFolderAction } from "./tasks/cleanup/empty-folders";
+export { runCleanupRoles } from "./tasks/cleanup/roles";
+export type { CleanupRolesOptions, RoleCleanupAction } from "./tasks/cleanup/roles";
+export { runCleanupUsers } from "./tasks/cleanup/users";
+export type { CleanupUsersOptions, UserCleanupAction } from "./tasks/cleanup/users";
+export { runAuditSuiteRun } from "./tasks/audit/suite-run";
+export type { AuditSuiteRunOptions } from "./tasks/audit/suite-run";
+export { runHistoryCapture, runHistoryList, runHistoryDiff } from "./tasks/audit/history";
+export type { HistoryCaptureOptions, HistoryListOptions, HistoryDiffOptions, } from "./tasks/audit/history";
+export { runAuditAll, auditNames } from "./tasks/audit/all";
+export type { AuditAllOptions } from "./tasks/audit/all";
+export { runBaselineShow, runBaselineCreate, runBaselineRemove, runBaselineReset, runBaselineAccept, } from "./tasks/audit/baseline";
+export type { BaselineShowOptions, BaselineCreateOptions, BaselineRemoveOptions, BaselineResetOptions, BaselineAcceptOptions, } from "./tasks/audit/baseline";
+export type { HygieneCommonOptions } from "./tasks/shared";
+export { runAuditReferences } from "./tasks/audit/references";
+export type { AuditReferencesOptions, ReferenceReport } from "./tasks/audit/references";
+export { runAuditTemplateDependencies } from "./tasks/audit/template-dependencies";
+export type { AuditTemplateDependenciesOptions, TemplateDependencyReport, TemplateReferenceKind, } from "./tasks/audit/template-dependencies";
+export { runCleanupSubtree } from "./tasks/cleanup/subtree";
+export type { CleanupSubtreeOptions, CleanupSubtreeResult, InboundBlocker, OrphanExternalRefsPolicy, SubtreeDeletion, } from "./tasks/cleanup/subtree";
+export { runExplainWhyBlocked } from "./tasks/explain/why-blocked";
+export type { ExplainWhyBlockedOptions, ExplainWhyBlockedReport, BlockerEntry, } from "./tasks/explain/why-blocked";
+export { runExplainOrphanSite } from "./tasks/explain/orphan-site";
+export type { ExplainOrphanSiteOptions, ExplainOrphanSiteReport, OrphanSiteEntry, } from "./tasks/explain/orphan-site";