@peernova/cuneiform-sf 1.0.2 → 1.0.4-beta.8

package/lib/commands/cuneiform/definition/purge.d.ts

@@ -0,0 +1,105 @@
+import { CuneiformCommand } from '../../../base/cuneiform-command.js';
+import { type BlockedDefinition } from '../../../operations/DefinitionPurgeOperation.js';
+/**
+ * Command result type for JSON output.
+ */
+export type DefinitionPurgeResult = {
+    /** Whether the operation was successful */
+    success: boolean;
+    /** Number of definitions deleted */
+    deleted: number;
+    /** Number of definitions skipped */
+    skipped: number;
+    /** Number of definitions that failed to delete */
+    failed: number;
+    /** Number of definitions queued (have related requests in queue) */
+    queued: number;
+    /** Total number of definitions processed */
+    total: number;
+    /** Whether this was a dry run */
+    dryRun: boolean;
+    /** Definitions blocked by summaries */
+    blockedBySummaries: BlockedDefinition[];
+    /** Whether the operation was cancelled by the user */
+    cancelled?: boolean;
+    /** Error message if failed */
+    error?: string;
+};
+/**
+ * Purges profiling definitions from a Salesforce org.
+ *
+ * Aligned with the definition create command's UX:
+ * - Inclusive AND filter model (--objects, --filter, --pattern, --method, --category, --status)
+ * - Per-definition progress output with [DELETED]/[SKIP]/[FAIL] indicators
+ * - Separate blocked sections with actionable guidance
+ * - Summary line: Deleted: X | Skipped: Y | Failed: Z | Total: N
+ * - --dry-run preview mode
+ */
+export default class DefinitionPurge extends CuneiformCommand<DefinitionPurgeResult> {
+    static readonly summary: string;
+    static readonly description: string;
+    static readonly examples: string[];
+    static readonly flags: {
+        'target-org': import("@oclif/core/interfaces").OptionFlag<import("@salesforce/core").Org, import("@oclif/core/interfaces").CustomOptions>;
+        'api-version': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        keys: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        objects: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        filter: import("@oclif/core/interfaces").OptionFlag<"standard" | "custom" | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        pattern: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        method: import("@oclif/core/interfaces").OptionFlag<"metadata" | "historical" | "comparative" | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        category: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        status: import("@oclif/core/interfaces").OptionFlag<"ERROR" | "NOT PROFILED" | "IN PROGRESS" | "SUCCESS" | "COMPLETE w/ FAILURES" | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        namespace: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'no-prompt': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        format: import("@oclif/core/interfaces").OptionFlag<"table" | "json", import("@oclif/core/interfaces").CustomOptions>;
+    };
+    /**
+     * Maps error codes to i18n message keys with optional parameter interpolation.
+     */
+    private static readonly ERROR_CODE_MAP;
+    private static readonly REASON_LABELS;
+    private static readonly QUEUED_REASON;
+    private static formatReason;
+    private static isQueuedError;
+    /**
+     * Renders a padded row for the progress table.
+     * The first column (#) is right-aligned; all others are left-aligned.
+     */
+    private static formatProgressRow;
+    /**
+     * Returns the status indicator for a progress event.
+     */
+    private static statusIndicator;
+    /**
+     * Computes column widths from header and row data.
+     * The first column (row number) gets a minimum width of 4.
+     */
+    private static computeColumnWidths;
+    /**
+     * Executes the purge command.
+     */
+    run(): Promise<DefinitionPurgeResult>;
+    /**
+     * Displays progress events as a dynamically-sized table.
+     */
+    private displayProgressTable;
+    /**
+     * Displays the categorized preview before user confirmation.
+     *
+     * Uses {@link paginateOutput} to page through large record sets interactively.
+     * Column widths are computed from ALL rows upfront so they remain consistent
+     * across pages. The header and separator are printed once before pagination.
+     *
+     * @param preview - Categorized preview data from the operation layer.
+     * @param skipPrompt - When true, renders all rows without interactive pagination.
+     * @returns Pagination result metadata, or undefined if no rows to display.
+     */
+    private displayPreview;
+    /**
+     * Displays purge results with create-aligned formatting.
+     */
+    private displayResults;
+}

package/lib/commands/cuneiform/definition/purge.js

@@ -0,0 +1,533 @@
+/*
+ * Copyright (c) 2026, PeerNova, Inc. All Rights Reserved.
+ * PROPRIETARY AND CONFIDENTIAL. Unauthorized copying, modification,
+ * or distribution is strictly prohibited. Use is governed by the
+ * Master Subscription Agreement (MSA) between PeerNova, Inc. and the
+ * licensee. See LICENSE file in the repo root.
+ */
+import { Flags } from '@salesforce/sf-plugins-core';
+import { Messages } from '@salesforce/core';
+import { CuneiformCommand } from '../../../base/cuneiform-command.js';
+import { ProfilingDefinitionService, } from '../../../services/ProfilingDefinitionService.js';
+import { DefinitionPurgeOperation, PurgeErrorCodes, PURGE_CANCELLED_MESSAGE, } from '../../../operations/DefinitionPurgeOperation.js';
+import { OrgInfoService } from '../../../services/OrgInfoService.js';
+import { renderOrgContext, displaySummaryBox } from '../../../utils/formatting/command-display.js';
+import { statusSymbol } from '../../../utils/formatting/indicators.js';
+import { formatNumber } from '../../../utils/formatting/numbers.js';
+import { paginateOutput } from '../../../utils/pagination/paginate-output.js';
+import { createDefaultIO } from '../../../utils/pagination/keypress-reader.js';
+Messages.importMessagesDirectoryFromMetaUrl(import.meta.url);
+const messages = Messages.loadMessages('@peernova/cuneiform-sf', 'definition.purge');
+/**
+ * Purges profiling definitions from a Salesforce org.
+ *
+ * Aligned with the definition create command's UX:
+ * - Inclusive AND filter model (--objects, --filter, --pattern, --method, --category, --status)
+ * - Per-definition progress output with [DELETED]/[SKIP]/[FAIL] indicators
+ * - Separate blocked sections with actionable guidance
+ * - Summary line: Deleted: X | Skipped: Y | Failed: Z | Total: N
+ * - --dry-run preview mode
+ */
+// eslint-disable-next-line sf-plugin/only-extend-SfCommand -- CuneiformCommand extends SfCommand with shared access gate logic
+export default class DefinitionPurge extends CuneiformCommand {
+    static summary = messages.getMessage('summary');
+    static description = messages.getMessage('description');
+    static examples = messages.getMessages('examples');
+    // eslint-disable-next-line sf-plugin/spread-base-flags -- CuneiformCommand has no additional flags to spread
+    static flags = {
+        'target-org': Flags.requiredOrg({
+            summary: messages.getMessage('flags.target-org.summary'),
+            char: 'o',
+            required: true,
+        }),
+        'api-version': Flags.orgApiVersion(),
+        all: Flags.boolean({
+            summary: messages.getMessage('flags.all.summary'),
+            char: 'a',
+        }),
+        keys: Flags.string({
+            summary: messages.getMessage('flags.keys.summary'),
+            char: 'k',
+            multiple: true,
+        }),
+        objects: Flags.string({
+            summary: messages.getMessage('flags.objects.summary'),
+            char: 'b',
+            multiple: true,
+        }),
+        filter: Flags.option({
+            summary: messages.getMessage('flags.filter.summary'),
+            char: 'f',
+            options: ['standard', 'custom'],
+        })(),
+        pattern: Flags.string({
+            summary: messages.getMessage('flags.pattern.summary'),
+            char: 'p',
+        }),
+        method: Flags.option({
+            summary: messages.getMessage('flags.method.summary'),
+            char: 't',
+            options: ['metadata', 'historical', 'comparative'],
+        })(),
+        category: Flags.string({
+            summary: messages.getMessage('flags.category.summary'),
+            char: 'c',
+        }),
+        status: Flags.option({
+            summary: messages.getMessage('flags.status.summary'),
+            char: 's',
+            options: ['NOT PROFILED', 'IN PROGRESS', 'SUCCESS', 'COMPLETE w/ FAILURES', 'ERROR'],
+        })(),
+        namespace: Flags.string({
+            summary: messages.getMessage('flags.namespace.summary'),
+            char: 'n',
+        }),
+        limit: Flags.integer({
+            summary: messages.getMessage('flags.limit.summary'),
+            char: 'l',
+            min: 1,
+            default: 50,
+        }),
+        'dry-run': Flags.boolean({
+            summary: messages.getMessage('flags.dry-run.summary'),
+            char: 'd',
+            default: false,
+        }),
+        'no-prompt': Flags.boolean({
+            summary: messages.getMessage('flags.no-prompt.summary'),
+            char: 'y',
+            default: false,
+        }),
+        format: Flags.option({
+            summary: messages.getMessage('flags.format.summary'),
+            options: ['table', 'json'],
+            default: 'table',
+        })(),
+    };
+    /**
+     * Maps error codes to i18n message keys with optional parameter interpolation.
+     */
+    static ERROR_CODE_MAP = {
+        [PurgeErrorCodes.NO_SELECTION_CRITERIA]: 'errors.noSelectionCriteria',
+        [PurgeErrorCodes.NO_ELIGIBLE_DEFINITIONS]: 'errors.noEligibleDefinitions',
+        [PurgeErrorCodes.QUERY_FAILED]: 'errors.queryFailed',
+        [PurgeErrorCodes.DELETE_FAILED]: 'errors.deleteFailed',
+    };
+    // eslint-disable-next-line camelcase -- Keys match service-layer snake_case reason codes
+    static REASON_LABELS = {
+        // eslint-disable-next-line camelcase -- Service-layer reason code
+        has_summaries: messages.getMessage('reason.hasSummaries'),
+        // eslint-disable-next-line camelcase -- Service-layer reason code
+        not_found: messages.getMessage('reason.notFound'),
+        // eslint-disable-next-line camelcase -- Service-layer reason code
+        lookup_failed: messages.getMessage('reason.lookupFailed'),
+    };
+    static QUEUED_REASON = messages.getMessage('reason.queuedKeyword');
+    static formatReason(reason) {
+        return DefinitionPurge.REASON_LABELS[reason] ?? reason;
+    }
+    static isQueuedError(reason) {
+        return reason?.toLowerCase().includes(DefinitionPurge.QUEUED_REASON) ?? false;
+    }
+    /**
+     * Renders a padded row for the progress table.
+     * The first column (#) is right-aligned; all others are left-aligned.
+     */
+    static formatProgressRow(cols, widths) {
+        return '  ' + cols.map((col, i) => (i === 0 ? col.padStart(widths[i]) : col.padEnd(widths[i]))).join('  ');
+    }
+    /**
+     * Returns the status indicator for a progress event.
+     */
+    static statusIndicator(event) {
+        if (event.status === 'deleted')
+            return `  ${statusSymbol('success')}`;
+        if (event.status === 'skipped')
+            return `  ${statusSymbol('warning')} ${DefinitionPurge.formatReason(event.reason ?? '')}`;
+        return `  ${statusSymbol('error')} ${DefinitionPurge.formatReason(event.reason ?? '')}`;
+    }
+    /**
+     * Computes column widths from header and row data.
+     * The first column (row number) gets a minimum width of 4.
+     */
+    static computeColumnWidths(headers, rows) {
+        return headers.map((h, i) => Math.max(i === 0 ? 4 : h.length, ...rows.map((r) => r[i].length)));
+    }
+    /**
+     * Executes the purge command.
+     */
+    async run() {
+        const { flags } = await this.parse(DefinitionPurge);
+        const targetOrg = flags['target-org'].getUsername();
+        if (!targetOrg) {
+            this.error(messages.getMessage('errors.noTargetOrg'));
+        }
+        const dryRun = flags['dry-run'];
+        const noPrompt = flags['no-prompt'];
+        // Warn when --all and explicit --limit are combined (limit is ignored with --all)
+        if (flags.all && this.argv.some((a) => a === '--limit' || a === '-l')) {
+            this.warn(messages.getMessage('warnings.limitIgnoredWithAll'));
+        }
+        // Initialize services
+        const { facade, soqlAdapter, restAdapter } = await this.initConnection(flags);
+        const definitionService = new ProfilingDefinitionService({ soqlAdapter, restAdapter });
+        const orgInfoService = new OrgInfoService({ connectionFacade: facade, soqlAdapter });
+        const operation = new DefinitionPurgeOperation(definitionService);
+        // Collect progress events, then render after completion for proper column sizing
+        const progressEvents = [];
+        // Build operation options
+        const operationOptions = {
+            targetOrg,
+            all: flags.all,
+            keys: DefinitionPurge.parseMultiValueFlag(flags.keys, { caseInsensitive: true }),
+            objectNames: DefinitionPurge.parseMultiValueFlag(flags.objects, { caseInsensitive: true }),
+            filter: flags.filter,
+            pattern: flags.pattern,
+            method: flags.method,
+            category: flags.category,
+            status: flags.status,
+            namespace: flags.namespace,
+            limit: flags.limit,
+            dryRun,
+            noPrompt,
+            onDefinitionsFound: (count) => {
+                const foundKey = count === 1 ? 'output.definitionsFound.singular' : 'output.definitionsFound.plural';
+                this.spinner.stop(messages.getMessage(foundKey, [formatNumber(count)]));
+                // Start delete spinner immediately when prompts are skipped
+                if (noPrompt || dryRun) {
+                    this.spinner.start(messages.getMessage('spinner.deletingDefinitions'));
+                }
+            },
+            onPreviewReady: async (preview) => {
+                // Display paginated preview table
+                const paginationResult = await this.displayPreview(preview, noPrompt);
+                // If user quit pagination early, treat as cancel
+                if (paginationResult?.action === 'quit')
+                    return false;
+                // Nothing to delete — show message and abort without prompting
+                if (preview.deletable.length === 0) {
+                    this.log(messages.getMessage('output.noDeletable'));
+                    return false;
+                }
+                // For --json mode, skip interactive prompt
+                if (this.jsonEnabled())
+                    return true;
+                // Prompt for confirmation
+                const confirmed = await this.confirm({
+                    message: preview.deletable.length === 1
+                        ? messages.getMessage('prompt.confirm.singular')
+                        : messages.getMessage('prompt.confirm.plural', [String(preview.deletable.length)]),
+                });
+                if (confirmed) {
+                    this.spinner.start(messages.getMessage('spinner.deletingDefinitions'));
+                }
+                return confirmed;
+            },
+            onProgress: (event) => {
+                progressEvents.push(event);
+                const counts = { deleted: 0, skipped: 0, failed: 0, queued: 0 };
+                for (const e of progressEvents) {
+                    if (e.status === 'deleted')
+                        counts.deleted++;
+                    else if (e.status === 'skipped')
+                        counts.skipped++;
+                    else if (DefinitionPurge.isQueuedError(e.reason))
+                        counts.queued++;
+                    else
+                        counts.failed++;
+                }
+                const parts = [`${formatNumber(event.current)}/${formatNumber(event.total)}`];
+                if (counts.deleted > 0)
+                    parts.push(`${formatNumber(counts.deleted)} ${messages.getMessage('spinner.status.deleted')}`);
+                if (counts.skipped > 0)
+                    parts.push(`${formatNumber(counts.skipped)} ${messages.getMessage('spinner.status.skipped')}`);
+                if (counts.failed > 0)
+                    parts.push(`${formatNumber(counts.failed)} ${messages.getMessage('spinner.status.failed')}`);
+                if (counts.queued > 0)
+                    parts.push(`${formatNumber(counts.queued)} ${messages.getMessage('spinner.status.queued')}`);
+                this.spinner.status = parts.join(', ');
+            },
+        };
+        // Fetch org identity first so it displays at the top
+        const modeText = dryRun ? `${messages.getMessage('output.initializing.dryRunMode')} ` : '';
+        this.log(messages.getMessage('output.initializing', [modeText]));
+        this.spinner.start(messages.getMessage('spinner.connecting'));
+        const orgIdentityResult = await orgInfoService.getOrgIdentity();
+        this.spinner.stop();
+        // Display org identity header (non-fatal if unavailable)
+        if (orgIdentityResult.success) {
+            this.log('');
+            this.log(renderOrgContext({
+                orgName: orgIdentityResult.data.organizationName,
+                orgId: orgIdentityResult.data.organizationId,
+                instanceUrl: facade.instanceUrl ?? '',
+                isSandbox: orgIdentityResult.data.isSandbox ?? false,
+            }));
+        }
+        // Execute purge
+        this.log('');
+        this.spinner.start(messages.getMessage('spinner.retrievingDefinitions'));
+        const result = await operation.execute(operationOptions);
+        this.spinner.stop();
+        // Handle no eligible definitions as a friendly message (not an error)
+        if (!result.success && result.errorCode === PurgeErrorCodes.NO_ELIGIBLE_DEFINITIONS) {
+            this.log('');
+            this.log(messages.getMessage('output.noEligible.message'));
+            this.log(messages.getMessage('output.noEligible.guidance'));
+            this.log('');
+            const zeroEntries = [
+                { key: messages.getMessage('output.summary.deleted'), value: formatNumber(0) },
+                { key: messages.getMessage('output.summary.skipped'), value: formatNumber(0) },
+                { key: messages.getMessage('output.summary.failed'), value: formatNumber(0) },
+                { key: messages.getMessage('output.summary.queued'), value: formatNumber(0) },
+                { key: messages.getMessage('output.summary.total'), value: formatNumber(0) },
+            ];
+            displaySummaryBox(this.log.bind(this), {
+                title: messages.getMessage('output.summaryHeader'),
+                entries: zeroEntries,
+            });
+            return {
+                success: true,
+                deleted: 0,
+                skipped: 0,
+                failed: 0,
+                queued: 0,
+                total: 0,
+                dryRun: dryRun ?? false,
+                blockedBySummaries: [],
+            };
+        }
+        // Handle user cancellation
+        if (result.success && result.message === PURGE_CANCELLED_MESSAGE) {
+            this.log('');
+            this.log(messages.getMessage('output.cancelled'));
+            return {
+                success: true,
+                deleted: 0,
+                skipped: 0,
+                failed: 0,
+                queued: 0,
+                total: result.data.total,
+                dryRun: dryRun ?? false,
+                cancelled: true,
+                blockedBySummaries: result.data.blockedBySummaries,
+            };
+        }
+        // Handle other failures as errors
+        if (!result.success) {
+            const errorMessage = DefinitionPurge.resolveErrorMessage(DefinitionPurge.ERROR_CODE_MAP, result.errorCode, result.message, messages);
+            this.error(errorMessage, { code: result.errorCode });
+        }
+        const data = result.data;
+        // Separate queued events from regular progress events
+        const queuedEvents = progressEvents.filter((e) => e.status === 'failed' && DefinitionPurge.isQueuedError(e.reason));
+        const regularEvents = progressEvents.filter((e) => !(e.status === 'failed' && DefinitionPurge.isQueuedError(e.reason)));
+        // Display progress table with dynamic column widths
+        this.displayProgressTable(regularEvents);
+        // Display results (blocked sections, summary)
+        this.displayResults(data, dryRun, flags.format, queuedEvents);
+        // Display warnings
+        if (result.warnings && result.warnings.length > 0) {
+            this.log('');
+            for (const warning of result.warnings) {
+                this.warn(warning);
+            }
+        }
+        return {
+            success: true,
+            deleted: data.deleted,
+            skipped: data.skipped,
+            failed: data.failed - queuedEvents.length,
+            queued: queuedEvents.length,
+            total: data.total,
+            dryRun: dryRun ?? false,
+            blockedBySummaries: data.blockedBySummaries,
+        };
+    }
+    /**
+     * Displays progress events as a dynamically-sized table.
+     */
+    displayProgressTable(events) {
+        if (events.length === 0)
+            return;
+        const headers = [
+            '#',
+            messages.getMessage('table.header.key'),
+            messages.getMessage('table.header.object'),
+            messages.getMessage('table.header.category'),
+            messages.getMessage('table.header.timeCategory'),
+            messages.getMessage('table.header.segmentCategory'),
+            messages.getMessage('table.header.status'),
+            messages.getMessage('table.header.deleted'),
+        ];
+        // Build row data
+        const rows = events.map((e, i) => {
+            const objectCol = e.objectLabel ?? e.objectName ?? '';
+            return [
+                String(i + 1),
+                e.key ?? '',
+                objectCol,
+                e.category ?? '',
+                e.timeCategory ?? '',
+                e.segmentCategory ?? '',
+                e.profilingStatus ?? '',
+                DefinitionPurge.statusIndicator(e),
+            ];
+        });
+        const widths = DefinitionPurge.computeColumnWidths(headers, rows);
+        this.log('');
+        this.log(DefinitionPurge.formatProgressRow(headers, widths));
+        this.log('  ' + widths.map((w) => '─'.repeat(w)).join('  '));
+        for (const row of rows) {
+            this.log(DefinitionPurge.formatProgressRow(row, widths));
+        }
+    }
+    /**
+     * Displays the categorized preview before user confirmation.
+     *
+     * Uses {@link paginateOutput} to page through large record sets interactively.
+     * Column widths are computed from ALL rows upfront so they remain consistent
+     * across pages. The header and separator are printed once before pagination.
+     *
+     * @param preview - Categorized preview data from the operation layer.
+     * @param skipPrompt - When true, renders all rows without interactive pagination.
+     * @returns Pagination result metadata, or undefined if no rows to display.
+     */
+    async displayPreview(preview, skipPrompt) {
+        const allDefs = [...preview.deletable, ...preview.blockedBySummaries];
+        if (allDefs.length === 0)
+            return undefined;
+        const headers = [
+            '#',
+            messages.getMessage('table.header.key'),
+            messages.getMessage('table.header.object'),
+            messages.getMessage('table.header.category'),
+            messages.getMessage('table.header.timeCategory'),
+            messages.getMessage('table.header.segmentCategory'),
+            messages.getMessage('table.header.status'),
+            messages.getMessage('table.header.canDelete'),
+        ];
+        const rows = allDefs.map((def, i) => {
+            let canDelete = `  ${statusSymbol('success')}`;
+            if (preview.blockedBySummaries.some((b) => b.id === def.id))
+                canDelete = `  ${statusSymbol('error')} ${messages.getMessage('reason.hasSummaries')}`;
+            // Show label only — fall back to API name if label is unavailable
+            const objectCol = def.objectLabel ?? def.objectName;
+            return [
+                String(i + 1),
+                def.key,
+                objectCol,
+                def.category ?? '',
+                def.timeCategory ?? '',
+                def.segmentCategory ?? '',
+                def.status,
+                canDelete,
+            ];
+        });
+        // Compute widths from ALL rows so columns stay aligned across pages
+        const widths = DefinitionPurge.computeColumnWidths(headers, rows);
+        // Print header and separator once before paginated rows
+        this.log('');
+        this.log(DefinitionPurge.formatProgressRow(headers, widths));
+        this.log('  ' + widths.map((w) => '─'.repeat(w)).join('  '));
+        // Paginate the row data — only create terminal IO when interactive prompts are possible
+        const isNonInteractive = skipPrompt === true || this.jsonEnabled();
+        const result = await paginateOutput(rows, (pageRows) => {
+            for (const row of pageRows) {
+                this.log(DefinitionPurge.formatProgressRow(row, widths));
+            }
+        }, {
+            noPrompt: skipPrompt,
+            jsonEnabled: this.jsonEnabled(),
+            io: isNonInteractive ? undefined : createDefaultIO(),
+        });
+        // Print summary after pagination completes
+        this.log('');
+        this.log(messages.getMessage('preview.summary', [
+            formatNumber(preview.deletable.length),
+            formatNumber(preview.blockedBySummaries.length),
+        ]));
+        this.log('');
+        return result;
+    }
+    /**
+     * Displays purge results with create-aligned formatting.
+     */
+    displayResults(data, dryRun, format, queuedEvents = []) {
+        this.log('');
+        // Dry-run banner
+        if (dryRun && data.preview) {
+            const bannerKey = data.preview.deletable === 1 ? 'dryRun.banner.singular' : 'dryRun.banner.plural';
+            this.log(messages.getMessage(bannerKey, [
+                formatNumber(data.preview.deletable),
+                formatNumber(data.preview.blockedBySummaries),
+            ]));
+            this.log('');
+            if (format === 'table' && data.preview.definitions.length > 0) {
+                const dryRunHeaders = [
+                    '#',
+                    messages.getMessage('table.column.key'),
+                    messages.getMessage('table.column.name'),
+                    messages.getMessage('table.column.object'),
+                    messages.getMessage('table.column.status'),
+                    messages.getMessage('table.column.action'),
+                ];
+                const dryRunRows = data.preview.definitions.map((d, i) => [
+                    String(i + 1),
+                    d.key,
+                    d.name,
+                    d.objectName,
+                    d.status,
+                    d.action.toUpperCase(),
+                ]);
+                const dryRunWidths = DefinitionPurge.computeColumnWidths(dryRunHeaders, dryRunRows);
+                this.log(DefinitionPurge.formatProgressRow(dryRunHeaders, dryRunWidths));
+                this.log('  ' + dryRunWidths.map((w) => '─'.repeat(w)).join('  '));
+                for (const row of dryRunRows) {
+                    this.log(DefinitionPurge.formatProgressRow(row, dryRunWidths));
+                }
+            }
+        }
+        // Blocked by summaries section
+        if (data.blockedBySummaries.length > 0) {
+            this.log('');
+            this.log(messages.getMessage('blockedBySummaries.header'));
+            if (format === 'table') {
+                const bsHeaders = [
+                    '#',
+                    messages.getMessage('table.column.key'),
+                    messages.getMessage('table.column.name'),
+                    messages.getMessage('table.column.object'),
+                ];
+                const bsRows = data.blockedBySummaries.map((d, i) => [String(i + 1), d.key, d.name, d.objectName]);
+                const bsWidths = DefinitionPurge.computeColumnWidths(bsHeaders, bsRows);
+                this.log(DefinitionPurge.formatProgressRow(bsHeaders, bsWidths));
+                this.log('  ' + bsWidths.map((w) => '─'.repeat(w)).join('  '));
+                for (const row of bsRows) {
+                    this.log(DefinitionPurge.formatProgressRow(row, bsWidths));
+                }
+            }
+        }
+        // Queued section (definitions with related requests in queue)
+        if (queuedEvents.length > 0) {
+            this.log('');
+            this.log(messages.getMessage('queued.header'));
+            this.displayProgressTable(queuedEvents);
+        }
+        // Summary section (aligned with create command)
+        const queuedCount = queuedEvents.length;
+        const adjustedFailed = data.failed - queuedCount;
+        const summaryEntries = [
+            { key: messages.getMessage('output.summary.deleted'), value: formatNumber(data.deleted) },
+            { key: messages.getMessage('output.summary.skipped'), value: formatNumber(data.skipped) },
+            { key: messages.getMessage('output.summary.failed'), value: formatNumber(adjustedFailed) },
+            { key: messages.getMessage('output.summary.queued'), value: formatNumber(queuedCount) },
+            { key: messages.getMessage('output.summary.total'), value: formatNumber(data.total) },
+        ];
+        displaySummaryBox(this.log.bind(this), {
+            title: messages.getMessage('output.summaryHeader'),
+            entries: summaryEntries,
+        });
+    }
+}
+//# sourceMappingURL=purge.js.map