@sitecoreai-labs/sitecoreai-cli 0.0.4 → 0.1.0

package/dist/commands/cleanup/duplicates.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCleanupDuplicatesCommand = void 0;
+const commander_1 = require("commander");
+const duplicates_1 = require("../../hygiene/tasks/cleanup/duplicates");
+const envelope_1 = require("../../shared/envelope");
+const shared_1 = require("../shared");
+const shared_2 = require("./shared");
+const createCleanupDuplicatesCommand = () => {
+    const command = new commander_1.Command("duplicates").description("Delete duplicate-content items, keeping one per group per --keep-rule");
+    const purge = new commander_1.Command("purge").description("Delete duplicates per keep-rule (default: oldest creation date wins)");
+    (0, shared_2.addCleanupBaseOptions)(purge);
+    purge.option("--root <path>", "Content-tree root (default: /sitecore/content)");
+    purge.option("--language <code>", "Restrict to one language (default: include all)");
+    purge.option("--min-group-size <count>", "Only act on groups with at least this many duplicates (default: 2)", (v) => parseInt(v, 10));
+    purge.option("--limit <count>", "Cap on the number of items inspected (default: 5000)", (v) => parseInt(v, 10));
+    purge.option("--index <name>", "Override the search index name");
+    purge.option("--include-system", "Include /sitecore/system items in the scan (off by default)");
+    purge.option("--include-system-fields", "Include __-prefixed system fields when computing the content hash");
+    purge.addOption(new commander_1.Option("--keep-rule <rule>", "Which member of each duplicate group survives")
+        .choices(["oldest", "newest", "shortest-path", "interactive"])
+        .default("oldest"));
+    purge.option("--concurrency <count>", "Delete concurrency (default: 4)", (v) => parseInt(v, 10));
+    purge.option("--batch-size <count>", "Aliased GraphQL batch size for field reads", (v) => parseInt(v, 10));
+    purge.option("--skip-ref-check", "Skip the inbound-reference pre-flight scan (faster on large tenants; refs to deleted dupes will become broken)");
+    purge.option("--from-stdin", "Read an `audit duplicates list` envelope from stdin and use its groups directly, skipping the cleanup's internal audit re-run. Pair with the audit's --json mode.");
+    purge.addHelpText("after", "\nPre-flight: each dupe targeted for deletion is scanned for inbound refs\n" +
+        "via `audit references`; matches are reported as 'blocked' and skipped.\n" +
+        "Pass --skip-ref-check or --force (from cleanup base options) to override;\n" +
+        "run `scai hygiene audit broken-links list` after the purge to triage any dangling refs.\n\n" +
+        "Pipelining: skip the cleanup's internal audit re-run with --from-stdin:\n" +
+        "  $ scai hygiene audit duplicates list --json | scai hygiene cleanup duplicates purge --from-stdin --apply\n" +
+        "Useful when the operator wants to inspect / filter the audit envelope\n" +
+        "before passing it to the cleanup, or when running both in a pipeline\n" +
+        "shouldn't repeat the hash scan.\n");
+    purge.action((0, shared_1.withApplyGate)(async (options) => {
+        if (options.fromStdin) {
+            const envelope = await (0, envelope_1.readScaiEnvelopeFromStdin)();
+            if (!Array.isArray(envelope.data)) {
+                throw new Error(`--from-stdin: envelope.data is not an array (got ${typeof envelope.data}). Expected an audit duplicates list envelope.`);
+            }
+            return (0, duplicates_1.runCleanupDuplicates)({ ...options, preComputedGroups: envelope.data });
+        }
+        return (0, duplicates_1.runCleanupDuplicates)(options);
+    }));
+    command.addCommand(purge);
+    return command;
+};
+exports.createCleanupDuplicatesCommand = createCleanupDuplicatesCommand;

package/dist/commands/cleanup/empty-folders.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const createCleanupEmptyFoldersCommand: () => Command;

package/dist/commands/cleanup/empty-folders.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCleanupEmptyFoldersCommand = void 0;
+const commander_1 = require("commander");
+const empty_folders_1 = require("../../hygiene/tasks/cleanup/empty-folders");
+const shared_1 = require("../shared");
+const shared_2 = require("./shared");
+const createCleanupEmptyFoldersCommand = () => {
+    const command = new commander_1.Command("empty-folders").description("Delete folder-like items with no children, recursively bottom-up");
+    const purge = new commander_1.Command("purge").description("Walk --root depth-first and delete every item whose subtree is empty");
+    (0, shared_2.addCleanupBaseOptions)(purge);
+    purge.requiredOption("--root <path>", "Content root to clean up under");
+    purge.option("--max-deletions <count>", "Cap on total deletions per run (default 500)", (v) => parseInt(v, 10));
+    purge.action((0, shared_1.withApplyGate)(empty_folders_1.runCleanupEmptyFolders));
+    command.addCommand(purge);
+    return command;
+};
+exports.createCleanupEmptyFoldersCommand = createCleanupEmptyFoldersCommand;

package/dist/commands/cleanup/field-set.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const createCleanupFieldSetCommand: () => Command;

package/dist/commands/cleanup/field-set.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCleanupFieldSetCommand = void 0;
+const commander_1 = require("commander");
+const field_set_1 = require("../../hygiene/tasks/cleanup/field-set");
+const shared_1 = require("../shared");
+const shared_2 = require("./shared");
+const createCleanupFieldSetCommand = () => {
+    const command = new commander_1.Command("field-set").description("Bulk-edit one field across a content scope — replace, add (multilist), remove (multilist), clear");
+    const apply = new commander_1.Command("apply").description("Write a value to the named --field across matching items");
+    (0, shared_2.addCleanupBaseOptions)(apply);
+    apply.requiredOption("--field <name>", "Single field name to write (case-insensitive; resolved against the item's template)");
+    apply.option("--mode <mode>", "How to combine --value with the existing field state. replace (default) | add | remove | clear", "replace");
+    apply.option("--value <text>", "Value to write. For mode=replace: written verbatim. For mode=add/remove: comma- or pipe-separated GUID list. Ignored for mode=clear.");
+    apply.option("--template-pattern <regex>", "Restrict to items whose templateName matches (strongly recommended — without this the verb operates on every item in --root)");
+    apply.option("--where-current-matches <regex>", "Only update items whose current value of --field matches this regex (e.g. '^$' for empty-only)");
+    apply.option("--root <path>", "Content-tree root (default: /sitecore/content)");
+    apply.option("--language <code>", "Restrict to one language");
+    apply.option("--limit <count>", "Cap on items inspected (default: 5000)", (v) => parseInt(v, 10));
+    apply.option("--max-mutations <count>", "Maximum number of items to mutate per run (default: 100)", (v) => parseInt(v, 10));
+    apply.option("--index <name>", "Override the search index name");
+    apply.option("--include-system", "Include /sitecore/system items in the scan (off by default)");
+    apply.option("--include-system-fields", "Allow writing to __-prefixed system fields (off by default)");
+    apply.option("--cache", "Use the on-disk field cache for the discovery phase");
+    apply.addHelpText("after", "\nModes:\n" +
+        "  replace  Overwrite the field with --value verbatim. Works for any field\n" +
+        "           type — caller owns the wire shape (`{guid}`, pipe-list, ISO date,\n" +
+        "           <link/> XML).\n" +
+        "  add      Union the supplied GUIDs into a pipe-delimited list. Tag-add is\n" +
+        "           this mode on a TreelistEx field. Rejects fields whose existing\n" +
+        "           value is non-empty and not pipe-delimited.\n" +
+        "  remove   Subtract the supplied GUIDs from a pipe-delimited list. Same\n" +
+        "           shape guard as add.\n" +
+        "  clear    Wipe the field (empty string).\n\n" +
+        "Always pair with --template-pattern to scope the run, and start with\n" +
+        "--what-if to preview the plan.\n");
+    apply.action((0, shared_1.withApplyGate)(async (options) => {
+        const mode = options.mode ?? "replace";
+        return (0, field_set_1.runCleanupFieldSet)({ ...options, mode });
+    }));
+    command.addCommand(apply);
+    return command;
+};
+exports.createCleanupFieldSetCommand = createCleanupFieldSetCommand;

package/dist/commands/cleanup/find-replace.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const createCleanupFindReplaceCommand: () => Command;

package/dist/commands/cleanup/find-replace.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCleanupFindReplaceCommand = void 0;
+const commander_1 = require("commander");
+const find_replace_1 = require("../../hygiene/tasks/cleanup/find-replace");
+const shared_1 = require("../shared");
+const shared_2 = require("./shared");
+const createCleanupFindReplaceCommand = () => {
+    const command = new commander_1.Command("find-replace").description("Apply a find-replace operation across content field values");
+    const apply = new commander_1.Command("apply").description("Replace --pattern with --replacement in matching field values");
+    (0, shared_2.addCleanupBaseOptions)(apply);
+    apply.requiredOption("--pattern <regex>", "Regex pattern (or literal with --literal) to match against field values");
+    apply.requiredOption("--replacement <text>", "Replacement string. Supports JS regex backreferences ($1, $&, $<name>)");
+    apply.option("--literal", "Treat --pattern as a literal string");
+    apply.option("--ignore-case", "Case-insensitive match");
+    apply.option("--flags <flags>", "Custom regex flags (g is always added). Default 'g'");
+    apply.option("--fields <names>", "Comma-separated field names to search (default: all author-facing fields)", shared_1.collectList, []);
+    apply.option("--include-system-fields", "Include __-prefixed system fields in the search (off by default; touching __Renderings via regex will mangle XML)");
+    apply.option("--root <path>", "Content-tree root (default: /sitecore/content)");
+    apply.option("--language <code>", "Restrict to one language");
+    apply.option("--limit <count>", "Cap on items inspected (default: 5000)", (v) => parseInt(v, 10));
+    apply.option("--max-mutations <count>", "Maximum number of items to mutate per run (default: 100). Defends against runaway regex matches", (v) => parseInt(v, 10));
+    apply.option("--index <name>", "Override the search index name");
+    apply.option("--include-system", "Include /sitecore/system items in the scan (off by default)");
+    apply.option("--cache", "Use the on-disk field cache for the discovery phase");
+    apply.addHelpText("after", "\nThe pattern is a JS RegExp (or literal with --literal). The\n" +
+        "replacement supports backreferences. Always run `scai hygiene audit\n" +
+        "find-replace list --pattern ...` first to verify match scope before\n" +
+        "applying. Pair with --what-if to preview the changes without\n" +
+        "touching the tenant.\n");
+    apply.action((0, shared_1.withApplyGate)(find_replace_1.runCleanupFindReplace));
+    command.addCommand(apply);
+    return command;
+};
+exports.createCleanupFindReplaceCommand = createCleanupFindReplaceCommand;

package/dist/commands/cleanup/index.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const createCleanupCommand: () => Command;

package/dist/commands/cleanup/index.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCleanupCommand = void 0;
+const commander_1 = require("commander");
+const archive_1 = require("./archive");
+const dead_templates_1 = require("./dead-templates");
+const duplicates_1 = require("./duplicates");
+const empty_folders_1 = require("./empty-folders");
+const field_set_1 = require("./field-set");
+const find_replace_1 = require("./find-replace");
+const language_versions_1 = require("./language-versions");
+const rename_1 = require("./rename");
+const roles_1 = require("./roles");
+const site_residue_1 = require("./site-residue");
+const slug_conflicts_1 = require("./slug-conflicts");
+const subtree_1 = require("./subtree");
+const users_1 = require("./users");
+const versions_1 = require("./versions");
+const workflow_1 = require("./workflow");
+const createCleanupCommand = () => {
+    const command = new commander_1.Command("cleanup").description("Mutating hygiene operations — versions, archive, templates, duplicates, find-replace, workflow, folders, roles, users. Honours --what-if and --allow-write.");
+    command.addCommand((0, archive_1.createCleanupArchiveCommand)());
+    command.addCommand((0, dead_templates_1.createCleanupDeadTemplatesCommand)());
+    command.addCommand((0, duplicates_1.createCleanupDuplicatesCommand)());
+    command.addCommand((0, empty_folders_1.createCleanupEmptyFoldersCommand)());
+    command.addCommand((0, field_set_1.createCleanupFieldSetCommand)());
+    command.addCommand((0, find_replace_1.createCleanupFindReplaceCommand)());
+    command.addCommand((0, language_versions_1.createCleanupLanguageVersionsCommand)());
+    command.addCommand((0, rename_1.createCleanupRenameCommand)());
+    command.addCommand((0, roles_1.createCleanupRolesCommand)());
+    command.addCommand((0, site_residue_1.createCleanupSiteResidueCommand)());
+    command.addCommand((0, slug_conflicts_1.createCleanupSlugConflictsCommand)());
+    command.addCommand((0, subtree_1.createCleanupSubtreeCommand)());
+    command.addCommand((0, users_1.createCleanupUsersCommand)());
+    command.addCommand((0, versions_1.createCleanupVersionsCommand)());
+    command.addCommand((0, workflow_1.createCleanupWorkflowCommand)());
+    command.addHelpText("after", "\nNote: after a large cascade delete the Authoring API template-cache\n" +
+        "can lag ~30-90s. `dead-templates purge` auto-retries past the settle\n" +
+        "window — only an unusually long lag needs a manual re-run.\n" +
+        "\nExamples (each subcommand's --help has its full set):\n" +
+        "  $ scai hygiene cleanup versions prune --root /sitecore/content/MySite --keep 5 --what-if\n" +
+        "  $ scai hygiene cleanup duplicates purge --root /sitecore/content/MySite --keep-rule oldest --what-if\n" +
+        "  $ scai hygiene cleanup dead-templates purge --root /sitecore/templates/Project --what-if\n" +
+        "  $ scai hygiene cleanup subtree delete --path /sitecore/content/MySite/Old --what-if\n" +
+        "  $ scai hygiene cleanup site-residue purge --what-if\n");
+    return command;
+};
+exports.createCleanupCommand = createCleanupCommand;

package/dist/commands/cleanup/language-versions.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const createCleanupLanguageVersionsCommand: () => Command;

package/dist/commands/cleanup/language-versions.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCleanupLanguageVersionsCommand = void 0;
+const commander_1 = require("commander");
+const language_version_add_1 = require("../../hygiene/tasks/cleanup/language-version-add");
+const shared_1 = require("../shared");
+const shared_2 = require("./shared");
+const createCleanupLanguageVersionsCommand = () => {
+    const command = new commander_1.Command("language-versions").description("Bulk-create language versions across items so translators can pick them up");
+    const add = new commander_1.Command("add").description("Add empty (or copied) language versions to items in --root");
+    (0, shared_2.addCleanupBaseOptions)(add);
+    add.requiredOption("--languages <codes>", "Comma-separated language codes to add (e.g. fr,es,de)", shared_1.collectList, []);
+    add.option("--from-language <code>", "Source language to copy fields from. Default: seed the new version empty");
+    add.option("--template-pattern <regex>", "Restrict to items whose templateName matches (strongly recommended)");
+    add.option("--root <path>", "Content-tree root (default: /sitecore/content)");
+    add.option("--limit <count>", "Cap on items inspected (default: 5000)", (v) => parseInt(v, 10));
+    add.option("--max-adds <count>", "Maximum number of (item, language) versions created per run (default: 500)", (v) => parseInt(v, 10));
+    add.option("--index <name>", "Override the search index name");
+    add.option("--include-system", "Include /sitecore/system items in the scan (off by default)");
+    add.option("--cache", "Use the on-disk field cache for the discovery phase");
+    add.action((0, shared_1.withApplyGate)(language_version_add_1.runCleanupLanguageVersionAdd));
+    command.addCommand(add);
+    return command;
+};
+exports.createCleanupLanguageVersionsCommand = createCleanupLanguageVersionsCommand;

package/dist/commands/cleanup/rename.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const createCleanupRenameCommand: () => Command;

package/dist/commands/cleanup/rename.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCleanupRenameCommand = void 0;
+const commander_1 = require("commander");
+const rename_1 = require("../../hygiene/tasks/cleanup/rename");
+const shared_1 = require("../shared");
+const shared_2 = require("./shared");
+const createCleanupRenameCommand = () => {
+    const command = new commander_1.Command("rename").description("Bulk-rename items by pattern (modifies item Name and thus the URL slug)");
+    const apply = new commander_1.Command("apply").description("Rename items whose name matches --pattern to the --replacement form");
+    (0, shared_2.addCleanupBaseOptions)(apply);
+    apply.requiredOption("--pattern <regex>", "JS regex (or literal with --literal) applied to item Name");
+    apply.requiredOption("--replacement <text>", "Replacement string. Supports JS regex backreferences ($1, $&, $<name>)");
+    apply.option("--literal", "Treat --pattern as a literal string");
+    apply.option("--ignore-case", "Case-insensitive match");
+    apply.option("--flags <flags>", "Custom regex flags (g intentionally not added)");
+    apply.option("--template-pattern <regex>", "Restrict to items whose templateName matches (strongly recommended)");
+    apply.option("--root <path>", "Content-tree root (default: /sitecore/content)");
+    apply.option("--limit <count>", "Cap on items inspected (default: 5000)", (v) => parseInt(v, 10));
+    apply.option("--max-renames <count>", "Maximum number of items renamed per run (default: 100)", (v) => parseInt(v, 10));
+    apply.option("--index <name>", "Override the search index name");
+    apply.option("--include-system", "Include /sitecore/system items in the scan (off by default)");
+    apply.option("--cache", "Use the on-disk field cache for the discovery phase");
+    apply.addHelpText("after", "\nRenames change the URL slug. Coordinate with redirects and sitemap\n" +
+        "regeneration in the surrounding workflow. To change the editor-visible\n" +
+        "display name (without changing the slug), use:\n" +
+        "  scai hygiene cleanup field-set apply --field '__Display Name' --value 'new name'\n");
+    apply.action((0, shared_1.withApplyGate)(rename_1.runCleanupRename));
+    command.addCommand(apply);
+    return command;
+};
+exports.createCleanupRenameCommand = createCleanupRenameCommand;

package/dist/commands/cleanup/roles.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const createCleanupRolesCommand: () => Command;

package/dist/commands/cleanup/roles.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCleanupRolesCommand = void 0;
+const commander_1 = require("commander");
+const roles_1 = require("../../hygiene/tasks/cleanup/roles");
+const shared_1 = require("../shared");
+const shared_2 = require("./shared");
+const createCleanupRolesCommand = () => {
+    const command = new commander_1.Command("roles").description("Delete empty roles (the cleanup counterpart to `audit empty-roles`)");
+    const purgeEmpty = new commander_1.Command("purge-empty").description("Delete every role flagged by `audit empty-roles list`");
+    (0, shared_2.addCleanupBaseOptions)(purgeEmpty);
+    purgeEmpty.option("--domain <name>", "Restrict to a specific domain");
+    purgeEmpty.option("--max-deletions <count>", "Cap on total deletions per run (default 50)", (v) => parseInt(v, 10));
+    purgeEmpty.addHelpText("after", "\nReview `audit empty-roles list` output BEFORE running this — some empty roles\n" +
+        "are platform-internal and removing them breaks Sitecore's role model.\n");
+    purgeEmpty.action((0, shared_1.withApplyGate)(roles_1.runCleanupRoles));
+    command.addCommand(purgeEmpty);
+    return command;
+};
+exports.createCleanupRolesCommand = createCleanupRolesCommand;

package/dist/commands/cleanup/shared.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const addCleanupBaseOptions: (command: Command) => Command;

package/dist/commands/cleanup/shared.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addCleanupBaseOptions = void 0;
+const shared_1 = require("../shared");
+const addCleanupBaseOptions = (command) => {
+    (0, shared_1.addEnvironmentOption)(command);
+    (0, shared_1.addConfigOption)(command);
+    (0, shared_1.addWhatIfOption)(command);
+    (0, shared_1.addApplyOption)(command);
+    (0, shared_1.addAllowWriteOption)(command);
+    (0, shared_1.addForceOption)(command);
+    (0, shared_1.addVerbosityOptions)(command);
+    return command;
+};
+exports.addCleanupBaseOptions = addCleanupBaseOptions;

package/dist/commands/cleanup/site-residue.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const createCleanupSiteResidueCommand: () => Command;

package/dist/commands/cleanup/site-residue.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCleanupSiteResidueCommand = void 0;
+const commander_1 = require("commander");
+const site_residue_1 = require("../../hygiene/tasks/cleanup/site-residue");
+const shared_1 = require("../shared");
+const shared_2 = require("./shared");
+const createCleanupSiteResidueCommand = () => {
+    const command = new commander_1.Command("site-residue").description("Delete SXA tenant/site folders left behind after a Sites-API delete (templates/Project, layout/Renderings/Project, media library/Project)");
+    const purge = new commander_1.Command("purge").description("Delete orphan tenant/site subtrees identified by `audit site-residue`. Defaults to plan-mode; combine --what-if with --allow-write to mutate.");
+    (0, shared_2.addCleanupBaseOptions)(purge);
+    purge.option("--root <path>", "Additional root to scan on top of the SXA defaults. Repeat or comma-separate.", (value, previous = []) => previous.concat(value
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0)), []);
+    purge.option("--content-root <path>", "Override the content root walked when discovering active sites (default /sitecore/content)");
+    purge.option("--skip-ref-check", "Skip the inbound-ref pre-flight scan. Faster but loses the safety net — pair with `audit broken-links` if you use this.");
+    purge.option("--index <name>", "Override the search index name (default: sitecore_master_index)");
+    purge.option("--concurrency <count>", "Concurrent deletes / pre-flight scans (default: 4)", (v) => parseInt(v, 10));
+    purge.action((0, shared_1.withApplyGate)(site_residue_1.runCleanupSiteResidue));
+    command.addCommand(purge);
+    command.addHelpText("after", "\nSafety:\n" +
+        "  - Defaults to plan-mode. Add --allow-write to mutate.\n" +
+        "  - Pre-flight scans every active tenant for refs into the doomed tree.\n" +
+        "    Orphans with inbound refs are skipped unless --force is passed.\n" +
+        "  - Recommended sequence:\n" +
+        "      $ scai hygiene cleanup site-residue purge --what-if          # plan + ref check\n" +
+        "      $ scai hygiene cleanup site-residue purge --allow-write       # execute\n" +
+        "      $ scai hygiene audit broken-links list                        # verify no breaks\n");
+    return command;
+};
+exports.createCleanupSiteResidueCommand = createCleanupSiteResidueCommand;

package/dist/commands/cleanup/slug-conflicts.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const createCleanupSlugConflictsCommand: () => Command;

package/dist/commands/cleanup/slug-conflicts.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCleanupSlugConflictsCommand = void 0;
+const commander_1 = require("commander");
+const slug_conflicts_1 = require("../../hygiene/tasks/cleanup/slug-conflicts");
+const shared_1 = require("../shared");
+const shared_2 = require("./shared");
+const createCleanupSlugConflictsCommand = () => {
+    const command = new commander_1.Command("slug-conflicts").description("Resolve sibling-name conflicts surfaced by `audit slug-conflicts` (delete or rename losers per --keep-rule)");
+    const purge = new commander_1.Command("purge").description("Delete or rename losing siblings per --keep-rule (default: oldest wins, action delete)");
+    (0, shared_2.addCleanupBaseOptions)(purge);
+    purge.option("--root <path>", "Content-tree root (default: /sitecore/content)");
+    purge.option("--language <code>", "Restrict to one language (default: include all)");
+    purge.option("--limit <count>", "Cap on the number of items inspected (default: 5000)", (v) => parseInt(v, 10));
+    purge.option("--index <name>", "Override the search index name");
+    purge.option("--include-system", "Include /sitecore/system items in the scan (off by default)");
+    purge.option("--case-insensitive", "Treat sibling names as case-insensitive (default: on; pass --no-case-insensitive to disable)");
+    purge.option("--no-case-insensitive", "Treat sibling names as case-sensitive (off by default — most renderers do case-insensitive URL resolution)");
+    purge.addOption(new commander_1.Option("--keep-rule <rule>", "Which member of each conflict group survives")
+        .choices(["oldest", "newest", "shortest-path", "interactive"])
+        .default("oldest"));
+    purge.addOption(new commander_1.Option("--action <action>", "What to do with the losers")
+        .choices(["delete", "rename"])
+        .default("delete"));
+    purge.option("--rename-suffix <template>", "Suffix template for --action rename. Placeholders: {shortId} (8-char itemId prefix), {full} (32-char id). Default: '-{shortId}'.");
+    purge.option("--concurrency <count>", "Delete/rename concurrency (default: 4)", (v) => parseInt(v, 10));
+    purge.option("--check-refs", "Pre-scan inbound references for every loser. In preview, attaches counts to each row (warn-only). Under --apply, fails the run if any loser has positive counts.");
+    purge.option("--ref-check-root <path>", "Content root the inbound-ref scan walks. Default '/sitecore' (full tenant). Narrow if you know refs only come from a subtree. Ignored without --check-refs.");
+    purge.addHelpText("after", "\nAction trade-offs:\n" +
+        "  --action delete   — `deleteItem(permanently: true)` on losers. Inbound\n" +
+        "                       refs to deleted items become broken — run\n" +
+        "                       `scai hygiene audit broken-links list` afterward.\n" +
+        "  --action rename   — `renameItem(name: oldName + suffix)`. Preserves\n" +
+        "                       inbound refs (the itemId doesn't change) but\n" +
+        "                       leaves stale-named siblings under the parent.\n" +
+        "                       URLs depending on the old slug will break.\n" +
+        "\nRef-check trade-offs:\n" +
+        "  --check-refs        Pre-scans inbound refs per loser (one `audit\n" +
+        "                       references` scan each, with field cache). In\n" +
+        "                       preview (default), attaches counts to the\n" +
+        "                       output so operators see blast radius. Under\n" +
+        "                       --apply, refuses to mutate when any loser has\n" +
+        "                       inbound refs — pair with --action rename or\n" +
+        "                       clear the refs first. Cost scales with the\n" +
+        "                       number of losers; narrow --ref-check-root on\n" +
+        "                       large tenants.\n" +
+        "\nKeep-rule note: the audit report has no created/updated dates, so\n" +
+        "  `oldest` and `newest` fall back to itemId-stable ordering. Use\n" +
+        "  `--keep-rule interactive` when the survivor decision matters per-item.\n");
+    purge.action((0, shared_1.withApplyGate)(slug_conflicts_1.runCleanupSlugConflicts));
+    command.addCommand(purge);
+    return command;
+};
+exports.createCleanupSlugConflictsCommand = createCleanupSlugConflictsCommand;

package/dist/commands/cleanup/subtree.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const createCleanupSubtreeCommand: () => Command;

package/dist/commands/cleanup/subtree.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCleanupSubtreeCommand = void 0;
+const commander_1 = require("commander");
+const subtree_1 = require("../../hygiene/tasks/cleanup/subtree");
+const shared_1 = require("../shared");
+const shared_2 = require("./shared");
+const createCleanupSubtreeCommand = () => {
+    const command = new commander_1.Command("subtree").description("Delete a Sitecore subtree bottom-up, with hard-block on external inbound references");
+    const del = new commander_1.Command("delete").description("Walk a subtree leaf-first and delete every descendant + the root");
+    (0, shared_2.addCleanupBaseOptions)(del);
+    del.requiredOption("--path <content-tree-path>", "Subtree root to delete");
+    del.option("--scan-root <path>", "Content root to scan for inbound references (default: /sitecore — the entire CMS)");
+    del.option("--orphan-external-refs <mode>", "How to handle external items whose fields reference the subtree. Default: refuse with blocker list. 'clear' empties the entire referring field. 'prune' surgically removes only the entries pointing at the subtree (preserves sibling values in multi-list / treelist fields and `<r>` elements in `__Renderings` layout XML). 'leave' skips the ref scan entirely — fastest, accepts dangling refs, expects `audit broken-links` follow-up.");
+    del.option("--max-deletions <count>", "Hard cap on items deleted in one run (default: 1000)", (v) => parseInt(v, 10));
+    del.option("--index <name>", "Override the search index name (default: sitecore_master_index)");
+    del.option("--fields <name>", "Restrict inbound-ref scan to these field names. Repeat or comma-separate.", (v, prev = []) => prev.concat(v
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0)), []);
+    del.action((0, shared_1.withApplyGate)(subtree_1.runCleanupSubtree));
+    command.addCommand(del);
+    return command;
+};
+exports.createCleanupSubtreeCommand = createCleanupSubtreeCommand;

package/dist/commands/cleanup/users.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const createCleanupUsersCommand: () => Command;

package/dist/commands/cleanup/users.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCleanupUsersCommand = void 0;
+const commander_1 = require("commander");
+const users_1 = require("../../hygiene/tasks/cleanup/users");
+const shared_1 = require("../shared");
+const shared_2 = require("./shared");
+const createCleanupUsersCommand = () => {
+    const command = new commander_1.Command("users").description("Delete stale users (the cleanup counterpart to `audit stale-users`)");
+    const purgeStale = new commander_1.Command("purge-stale").description("Delete users inactive for more than --not-active-days (default 365)");
+    (0, shared_2.addCleanupBaseOptions)(purgeStale);
+    purgeStale.option("--not-active-days <count>", "Inactivity threshold in days (default 365)", (v) => parseInt(v, 10));
+    purgeStale.option("--max-deletions <count>", "Cap on total deletions per run (default 25)", (v) => parseInt(v, 10));
+    purgeStale.option("--include-admins", "Include administrators (strongly discouraged)");
+    purgeStale.option("--include-service-accounts", "Include likely service accounts (their lastLoginDate doesn't reflect OAuth access)");
+    purgeStale.option("--use-activity-date", "Use UserProfile.lastActivityDate instead of lastLoginDate");
+    purgeStale.addHelpText("after", "\nDefault threshold is 365 days (vs 180 for the audit) — deleting users is\n" +
+        "more destructive than flagging them, so the bar is higher.\n");
+    purgeStale.action((0, shared_1.withApplyGate)(users_1.runCleanupUsers));
+    command.addCommand(purgeStale);
+    return command;
+};
+exports.createCleanupUsersCommand = createCleanupUsersCommand;

package/dist/commands/cleanup/versions.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const createCleanupVersionsCommand: () => Command;

package/dist/commands/cleanup/versions.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCleanupVersionsCommand = void 0;
+const commander_1 = require("commander");
+const versions_archive_1 = require("../../hygiene/tasks/cleanup/versions-archive");
+const versions_prune_1 = require("../../hygiene/tasks/cleanup/versions-prune");
+const shared_1 = require("../shared");
+const shared_2 = require("./shared");
+const createCleanupVersionsCommand = () => {
+    const command = new commander_1.Command("versions").description("Prune or archive per-item version history down to the N most recent versions");
+    // ── prune (destructive) ──────────────────────────────────────────
+    const prune = new commander_1.Command("prune").description("Permanently delete versions older than the N most recent per (item, language)");
+    (0, shared_2.addCleanupBaseOptions)(prune);
+    prune.requiredOption("--keep <count>", "Number of most-recent versions to keep per (item, language)", (v) => parseInt(v, 10));
+    prune.requiredOption("--root <path>", "Content-tree root to scope the prune (e.g. /sitecore/content/MySite)");
+    prune.option("--language <code>", "Restrict pruning to one language (default: all languages found per item)");
+    prune.option("--limit <count>", "Cap on the number of items inspected", (v) => parseInt(v, 10));
+    prune.option("--index <name>", "Override the search index name (default: sitecore_master_index)");
+    prune.option("--concurrency <count>", "Concurrency for version reads and deletes", (v) => parseInt(v, 10));
+    prune.option("--include-system", "Include /sitecore/system and platform items in the prune");
+    prune.action((0, shared_1.withApplyGate)(versions_prune_1.runCleanupVersionsPrune));
+    command.addCommand(prune);
+    // ── archive (soft / reversible) ──────────────────────────────────
+    const archive = new commander_1.Command("archive").description("Move versions older than the N most recent per (item, language) to the Sitecore archive (reversible)");
+    (0, shared_2.addCleanupBaseOptions)(archive);
+    archive.requiredOption("--keep <count>", "Number of most-recent versions to keep per (item, language)", (v) => parseInt(v, 10));
+    archive.requiredOption("--root <path>", "Content-tree root to scope the archive");
+    archive.option("--language <code>", "Restrict to one language");
+    archive.option("--limit <count>", "Cap on items inspected", (v) => parseInt(v, 10));
+    archive.option("--index <name>", "Override the search index name");
+    archive.option("--concurrency <count>", "Concurrency", (v) => parseInt(v, 10));
+    archive.option("--include-system", "Include platform items");
+    archive.option("--archive-name <name>", "Name of the Sitecore archive bucket (default: tenant default)");
+    archive.addHelpText("after", "\nUnlike `versions prune`, archived versions can be restored via the\n" +
+        "Sitecore admin UI (restoreArchivedVersion) — this is the reversible\n" +
+        "alternative for cases where you want to trim version history but keep\n" +
+        "an undo path.\n");
+    archive.action((0, shared_1.withApplyGate)(versions_archive_1.runCleanupVersionsArchive));
+    command.addCommand(archive);
+    return command;
+};
+exports.createCleanupVersionsCommand = createCleanupVersionsCommand;

package/dist/commands/cleanup/workflow.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const createCleanupWorkflowCommand: () => Command;

package/dist/commands/cleanup/workflow.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCleanupWorkflowCommand = void 0;
+const commander_1 = require("commander");
+const workflow_advance_1 = require("../../hygiene/tasks/cleanup/workflow-advance");
+const workflow_apply_1 = require("../../hygiene/tasks/cleanup/workflow-apply");
+const shared_1 = require("../shared");
+const shared_2 = require("./shared");
+const createCleanupWorkflowCommand = () => {
+    const command = new commander_1.Command("workflow").description("Mutating workflow operations (advance stale items, bulk-attach a workflow, etc.)");
+    const advance = new commander_1.Command("advance").description("Execute a workflow command on items stuck past --stale-days");
+    (0, shared_2.addCleanupBaseOptions)(advance);
+    advance.requiredOption("--command-name <name>", "Workflow command name (e.g. 'Submit', 'Approve'). Resolved case-insensitively against the item's workflow.");
+    advance.option("--stale-days <count>", "Days since last update for an item to be eligible (default 30)", (v) => parseInt(v, 10));
+    advance.option("--from-state <name>", "Only act on items currently in this state name");
+    advance.option("--comments <text>", "Comment recorded with the workflow execution (audit trail)");
+    advance.option("--root <path>", "Content root (default: /sitecore/content)");
+    advance.option("--max-advances <count>", "Cap on items advanced per run (default 100)", (v) => parseInt(v, 10));
+    advance.option("--limit <count>", "Cap on items inspected", (v) => parseInt(v, 10));
+    advance.option("--index <name>", "Override the search index");
+    advance.option("--include-system", "Include /sitecore/system items");
+    advance.action((0, shared_1.withApplyGate)(workflow_advance_1.runCleanupWorkflowAdvance));
+    command.addCommand(advance);
+    const apply = new commander_1.Command("apply").description("Bulk-attach a workflow to items under --root (sets __Workflow + __Workflow state directly). Use to backfill content authored before the workflow existed.");
+    (0, shared_2.addCleanupBaseOptions)(apply);
+    apply.requiredOption("--workflow <ref>", "Workflow GUID, content-tree path, or display/item name (case-insensitive)");
+    apply.option("--state <ref>", "Target state (GUID or name). Defaults to the workflow's __Initial state.");
+    apply.option("--template <ref>", "Only attach to items conforming to this template (GUID or absolute /sitecore/templates path).");
+    apply.option("--reattach", "Overwrite items already attached to a different workflow. Off by default — already-attached items are skipped so the verb defaults to a safe backfill.");
+    apply.option("--stale-days <count>", "Only act on items not updated for at least N days. Optional — omit to attach to every match.", (v) => parseInt(v, 10));
+    apply.option("--root <path>", "Content root (default: /sitecore/content)");
+    apply.option("--max-applies <count>", "Cap on items attached per run (default 100)", (v) => parseInt(v, 10));
+    apply.option("--limit <count>", "Cap on items inspected (default 5000)", (v) => parseInt(v, 10));
+    apply.option("--index <name>", "Override the search index");
+    apply.option("--include-system", "Include /sitecore/system items");
+    apply.action((0, shared_1.withApplyGate)(workflow_apply_1.runCleanupWorkflowApply));
+    command.addCommand(apply);
+    return command;
+};
+exports.createCleanupWorkflowCommand = createCleanupWorkflowCommand;

package/dist/commands/config.d.ts

@@ -1,3 +1,2 @@
 import { Command } from "commander";
 export declare const createConfigCommand: () => Command;
-//# sourceMappingURL=config.d.ts.map