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

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

@@ -0,0 +1,737 @@
+/*
+ * 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 { execFile } from 'node:child_process';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+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 { ProfilingExecutionService } from '../../../services/ProfilingExecutionService.js';
+import { ProfilingSummaryService } from '../../../services/ProfilingSummaryService.js';
+import { RecordTypeService } from '../../../services/RecordTypeService.js';
+import { ObjectFilteringService } from '../../../services/ObjectFilteringService.js';
+import { OrgInfoService } from '../../../services/OrgInfoService.js';
+import { DefinitionCreateOperation, } from '../../../operations/DefinitionCreateOperation.js';
+import { DataAvailabilityService } from '../../../services/DataAvailabilityService.js';
+import { ProfilingRestClient } from '../../../adapters/rest/profiling-rest-client.js';
+import { parseNamespaceFilter } from '../../../services/namespace-filter.js';
+import { parsePortabilityRecipe } from '../../../models/portability-recipe.js';
+import { renderSummaryBox } from '../../../utils/formatting/command-display.js';
+import { resolveYearRange } from '../../../models/year-range.js';
+import { validateDateLiteral, resolveDateLiteralRange } from '../../../models/date-literal.js';
+import { displayOrgContext, displayResultsTables, resolveOperationFailure, buildPreConfirmSummary, } from '../../../utils/formatting/definition-create-display.js';
+Messages.importMessagesDirectoryFromMetaUrl(import.meta.url);
+const messages = Messages.loadMessages('@peernova/cuneiform-sf', 'definition.create');
+/**
+ * Creates profiling definitions for Salesforce objects.
+ */
+// eslint-disable-next-line sf-plugin/only-extend-SfCommand -- CuneiformCommand extends SfCommand with shared access gate logic
+export default class DefinitionCreate 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(),
+        objects: Flags.string({
+            summary: messages.getMessage('flags.objects.summary'),
+            char: 'b',
+            multiple: true,
+        }),
+        'from-file': Flags.file({
+            summary: messages.getMessage('flags.from-file.summary'),
+            exists: true,
+        }),
+        filter: Flags.option({
+            summary: messages.getMessage('flags.filter.summary'),
+            char: 'f',
+            options: ['all', 'standard', 'custom'],
+            default: 'all',
+        })(),
+        pattern: Flags.string({
+            summary: messages.getMessage('flags.pattern.summary'),
+            char: 'p',
+        }),
+        namespace: Flags.string({
+            summary: messages.getMessage('flags.namespace.summary'),
+            char: 'n',
+        }),
+        classification: Flags.option({
+            summary: messages.getMessage('flags.classification.summary'),
+            options: ['customer', 'internal', 'all'],
+            default: 'customer',
+        })(),
+        'with-records': Flags.boolean({
+            summary: messages.getMessage('flags.with-records.summary'),
+        }),
+        'without-records': Flags.boolean({
+            summary: messages.getMessage('flags.without-records.summary'),
+        }),
+        'with-record-types': Flags.boolean({
+            summary: messages.getMessage('flags.with-record-types.summary'),
+        }),
+        category: Flags.string({
+            summary: messages.getMessage('flags.category.summary'),
+            char: 'c',
+        }),
+        'min-records': Flags.integer({
+            summary: messages.getMessage('flags.min-records.summary'),
+            min: 0,
+            default: 0,
+        }),
+        limit: Flags.integer({
+            summary: messages.getMessage('flags.limit.summary'),
+            char: 'l',
+            min: 1,
+            default: 100,
+        }),
+        method: Flags.option({
+            summary: messages.getMessage('flags.method.summary'),
+            char: 't',
+            options: ['metadata', 'historical', 'comparative', 'recordtype', 'outcome', 'full'],
+            default: 'full',
+        })(),
+        recordtype: Flags.string({
+            summary: messages.getMessage('flags.recordtype.summary'),
+        }),
+        'record-type-status': Flags.option({
+            summary: messages.getMessage('flags.record-type-status.summary'),
+            options: ['active', 'all', 'inactive'],
+            default: 'active',
+        })(),
+        // eslint-disable-next-line sf-plugin/flag-min-max-default -- year defaults to current year at runtime when method requires it
+        year: Flags.integer({
+            summary: messages.getMessage('flags.year.summary'),
+            min: 2000,
+            max: 2050,
+        }),
+        // eslint-disable-next-line sf-plugin/flag-min-max-default -- depth defaults vary by method at runtime
+        depth: Flags.integer({
+            summary: messages.getMessage('flags.depth.summary'),
+            min: 1,
+            max: 10,
+        }),
+        // eslint-disable-next-line sf-plugin/flag-min-max-default -- from defaults to MIN_YEAR at runtime when to is specified
+        from: Flags.integer({
+            summary: messages.getMessage('flags.from.summary'),
+            min: 2000,
+            max: 2050,
+        }),
+        // eslint-disable-next-line sf-plugin/flag-min-max-default -- to defaults to current year at runtime when from is specified
+        to: Flags.integer({
+            summary: messages.getMessage('flags.to.summary'),
+            min: 2000,
+            max: 2050,
+        }),
+        'no-value-frequency': Flags.boolean({
+            summary: messages.getMessage('flags.no-value-frequency.summary'),
+        }),
+        'use-prior': Flags.boolean({
+            summary: messages.getMessage('flags.use-prior.summary'),
+        }),
+        'lifetime-primary': Flags.boolean({
+            summary: messages.getMessage('flags.lifetime-primary.summary'),
+        }),
+        'date-literal': Flags.string({
+            summary: messages.getMessage('flags.date-literal.summary'),
+        }),
+        'date-field': Flags.string({
+            summary: messages.getMessage('flags.date-field.summary'),
+            default: 'CreatedDate',
+        }),
+        profiled: Flags.boolean({
+            summary: messages.getMessage('flags.profiled.summary'),
+        }),
+        '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'),
+            default: false,
+        }),
+        profile: Flags.boolean({
+            summary: messages.getMessage('flags.profile.summary'),
+        }),
+        open: Flags.boolean({
+            summary: messages.getMessage('flags.open.summary'),
+        }),
+        logs: Flags.boolean({
+            summary: messages.getMessage('flags.logs.summary'),
+        }),
+        'name-prefix': Flags.string({
+            summary: messages.getMessage('flags.name-prefix.summary'),
+        }),
+        'name-suffix': Flags.string({
+            summary: messages.getMessage('flags.name-suffix.summary'),
+        }),
+        'time-category': Flags.string({
+            summary: messages.getMessage('flags.time-category.summary'),
+        }),
+        'segment-category': Flags.string({
+            summary: messages.getMessage('flags.segment-category.summary'),
+        }),
+        origin: Flags.string({
+            summary: messages.getMessage('flags.origin.summary'),
+            default: 'Created via the Cuneiform for Salesforce CLI.',
+        }),
+    };
+    /**
+     * Determines the effective --with-records value.
+     *
+     * When --method full is used and no explicit scope/filter flags are supplied by the user,
+     * defaults withRecords to true so the default scope is "customer objects with records."
+     * This prevents full profiling from targeting empty or system-only objects.
+     *
+     * Scope flags that suppress the default: --with-records, --without-records, --filter (non-default),
+     * --objects, --pattern.
+     */
+    static resolveWithRecords(method, withRecordsFlag, withoutRecordsFlag, objects, pattern, filter) {
+        if (method !== 'full')
+            return withRecordsFlag;
+        // If user explicitly supplied any scope-narrowing flags, respect their intent.
+        if (withRecordsFlag !== undefined || withoutRecordsFlag !== undefined)
+            return withRecordsFlag;
+        if (objects !== undefined && objects.length > 0)
+            return withRecordsFlag;
+        if (pattern !== undefined)
+            return withRecordsFlag;
+        if (filter !== 'all')
+            return withRecordsFlag;
+        // No explicit scope flags for --method full: default to withRecords=true
+        return true;
+    }
+    /**
+     * Executes the create command.
+     *
+     * @returns DefinitionCreateResult with success status and creation statistics
+     */
+    // eslint-disable-next-line complexity -- multi-flag validation, service wiring, and result mapping are inherently sequential
+    async run() {
+        const { flags } = await this.parse(DefinitionCreate);
+        const targetOrg = flags['target-org'].getUsername();
+        if (!targetOrg) {
+            this.error(messages.getMessage('errors.noTargetOrg'));
+        }
+        const dryRun = flags['dry-run'];
+        // CLI-4215 (REQ-002 / GAP.02): --from-file supplies a portability recipe (objects + run-level
+        // parameters) as bulk input. It is mutually exclusive with --objects/--pattern; when present it
+        // drives object selection, method, category, and the naming suffix, and enables
+        // portabilityNaming so names render as `${objectLabel} • ${nameSuffix}`.
+        let recipe;
+        const fromFile = flags['from-file'];
+        if (fromFile !== undefined) {
+            const hasObjectsFlag = flags.objects !== undefined && flags.objects.length > 0;
+            if (hasObjectsFlag || flags.pattern !== undefined) {
+                this.error(messages.getMessage('errors.fromFileMutualExclusion'));
+            }
+            const parsedRecipe = parsePortabilityRecipe(await readFile(fromFile, 'utf8'));
+            if (parsedRecipe.error !== undefined) {
+                this.error(parsedRecipe.error, { code: 'INVALID_RECIPE' });
+            }
+            recipe = parsedRecipe.value;
+        }
+        // Portability recipes default to metadata (one definition per object) — never the --method
+        // flag default ('full'), which would fan out colliding names (CLI-4215 H2).
+        const method = recipe ? recipe.method ?? 'metadata' : flags.method;
+        const parsedObjects = recipe
+            ? recipe.objects
+            : DefinitionCreate.parseMultiValueFlag(flags.objects, { caseInsensitive: true });
+        // Validate --with-records and --without-records mutual exclusion
+        if (flags['with-records'] && flags['without-records']) {
+            this.error(messages.getMessage('errors.mutuallyExclusiveRecordFlags'));
+        }
+        // Validate --min-records and --without-records mutual exclusion (CLI-1265)
+        if (flags['min-records'] > 0 && flags['without-records']) {
+            this.error(messages.getMessage('errors.minRecordsWithoutRecords'));
+        }
+        // Validate --recordtype requires a method that supports record type scoping
+        if (flags.recordtype && method === 'metadata') {
+            this.error(messages.getMessage('errors.recordtypeMethodRequired'));
+        }
+        // Validate --profiled mutual exclusion with --method metadata
+        if (flags.profiled && method === 'metadata') {
+            this.error(messages.getMessage('errors.profiledWithMetadata'));
+        }
+        // Validate --date-literal mutual exclusion with year-based flags
+        // Note: --depth is allowed with --date-literal (controls cascade depth)
+        const hasDateLiteral = flags['date-literal'] !== undefined;
+        const hasYearFlags = flags.year !== undefined || flags.from !== undefined || flags.to !== undefined;
+        if (hasDateLiteral && (hasYearFlags || flags['use-prior'])) {
+            this.error(messages.getMessage('errors.dateLiteralMutualExclusion'));
+        }
+        // Validate --lifetime-primary contract (CLI-2944)
+        // AC5: only valid with --method comparative.
+        // AC4: mutually exclusive with --use-prior.
+        // AC5a: mutually exclusive with --depth (no cascade for the lifetime-vs-X variant).
+        // AC3: requires a secondary filter (--date-literal, --year, or --from/--to).
+        if (flags['lifetime-primary']) {
+            if (method !== 'comparative') {
+                this.error(messages.getMessage('errors.lifetimePrimaryMethodRequired'));
+            }
+            if (flags['use-prior']) {
+                this.error(messages.getMessage('errors.lifetimePrimaryUsePriorMutualExclusion'));
+            }
+            if (flags.depth !== undefined) {
+                this.error(messages.getMessage('errors.lifetimePrimaryDepthMutualExclusion'));
+            }
+            if (!hasDateLiteral && !hasYearFlags) {
+                this.error(messages.getMessage('errors.lifetimePrimaryRequiresSecondaryFilter'));
+            }
+        }
+        // Resolve date literal range (when --date-literal is used)
+        let dateLiteralRange;
+        if (hasDateLiteral) {
+            const validationError = validateDateLiteral(flags['date-literal']);
+            if (validationError) {
+                this.error(validationError);
+            }
+            try {
+                dateLiteralRange = resolveDateLiteralRange({
+                    dateLiteral: flags['date-literal'],
+                    depth: flags.depth,
+                    dateField: flags['date-field'],
+                });
+            }
+            catch (err) {
+                this.error(err.message);
+            }
+        }
+        // Warn when year-related flags are used with metadata (no time dimension)
+        if (hasYearFlags && method === 'metadata') {
+            this.warn(messages.getMessage('warnings.yearIgnored'));
+        }
+        // Resolve year range with method-aware defaults (skipped when using date literals)
+        let yearRange;
+        if (dateLiteralRange) {
+            // Date literal mode: year range is empty (date literals replace year-based scoping)
+            yearRange = { entries: [] };
+        }
+        else {
+            try {
+                yearRange = resolveYearRange({
+                    year: flags.year,
+                    depth: flags.depth,
+                    from: flags.from,
+                    to: flags.to,
+                    usePrior: flags['use-prior'],
+                    method,
+                });
+            }
+            catch (err) {
+                this.error(messages.getMessage('errors.yearRangeInvalid', [err.message]));
+            }
+        }
+        // Extract single year for backward compatibility with operation layer
+        const year = yearRange.entries.length > 0 ? yearRange.entries[0].year : undefined;
+        // Resolve withRecords default for --method full
+        const withRecords = DefinitionCreate.resolveWithRecords(method, flags['with-records'], flags['without-records'], parsedObjects, flags.pattern, flags.filter);
+        // Parse --namespace at the command boundary into the typed NamespaceFilter
+        // discriminated union consumed by operation/service/adapter layers (CLI-3801).
+        const namespaceResult = parseNamespaceFilter(flags.namespace);
+        if (namespaceResult.error) {
+            this.error(messages.getMessage('errors.invalidNamespace', [namespaceResult.error]), {
+                code: 'INVALID_NAMESPACE',
+            });
+        }
+        // Initialize services
+        const { facade, soqlAdapter, restAdapter } = await this.initConnection(flags);
+        const definitionService = new ProfilingDefinitionService({ soqlAdapter, restAdapter });
+        const filteringService = new ObjectFilteringService({ restApiAdapter: restAdapter, soqlAdapter });
+        const profilingSummaryService = flags.profiled ? new ProfilingSummaryService({ soqlAdapter }) : undefined;
+        const recordTypeService = method === 'recordtype' || method === 'full' ? new RecordTypeService({ soqlAdapter }) : undefined;
+        const dataAvailabilityService = yearRange.entries.length > 0 ? new DataAvailabilityService({ soqlAdapter }) : undefined;
+        // REST client enables server-side definition creation (naming, categorization, dedup)
+        // When available, steps 3-7 of the pipeline delegate to the ISV REST API
+        const restClient = new ProfilingRestClient(restAdapter);
+        const operation = new DefinitionCreateOperation(definitionService, filteringService, undefined, profilingSummaryService, recordTypeService, dataAvailabilityService, restClient);
+        // Fetch org identity
+        this.spinner.start(messages.getMessage('spinner.connecting'));
+        const orgInfoService = new OrgInfoService({ connectionFacade: facade, soqlAdapter, restAdapter });
+        const orgIdentityResult = await orgInfoService.getOrgIdentity();
+        this.spinner.stop();
+        if (orgIdentityResult.success) {
+            displayOrgContext(this.log.bind(this), orgIdentityResult.data, facade.instanceUrl);
+        }
+        // Collect callback results for post-execution rendering
+        const callbackResults = [];
+        let hasObjectWarnings = false;
+        const previewState = {
+            recordCounts: new Map(),
+            objectLabels: new Map(),
+        };
+        // Build operation options
+        const operationOptions = {
+            targetOrg,
+            objects: parsedObjects,
+            pattern: flags.pattern,
+            filter: flags.filter,
+            namespace: namespaceResult.value,
+            classification: flags.classification,
+            withRecords,
+            withoutRecords: flags['without-records'],
+            withRecordTypes: flags['with-record-types'],
+            method,
+            recordType: flags.recordtype,
+            recordTypeStatus: flags['record-type-status'],
+            category: recipe?.category ?? flags.category,
+            minRecords: flags['min-records'],
+            limit: flags.limit,
+            // CLI-3402: --depth propagates the current-year default into options.year so the
+            // ISV's historicalWithYear gate fires for the depth-only cascade (per documented
+            // --depth contract: "When no anchor year is specified, defaults to the current year").
+            // Kept here instead of folding into hasYearFlags because hasYearFlags also drives the
+            // --date-literal mutual-exclusion check at line 306 where --depth IS intentionally allowed.
+            year: hasYearFlags || flags.depth !== undefined ? year : undefined,
+            yearRange,
+            noValueFrequency: flags['no-value-frequency'],
+            usePrior: flags['use-prior'],
+            lifetimePrimary: flags['lifetime-primary'],
+            dateLiteralRange,
+            profiled: flags.profiled,
+            namePrefix: flags['name-prefix'],
+            nameSuffix: recipe?.nameSuffix ?? flags['name-suffix'],
+            portabilityNaming: recipe !== undefined,
+            timeCategory: flags['time-category'],
+            segmentCategory: flags['segment-category'],
+            origin: flags.origin,
+            dryRun,
+            noPrompt: flags['no-prompt'],
+            // Precedence: dryRun (operation skips callback) > --json (auto-confirm) > --no-prompt (auto-confirm) > interactive prompt
+            onPreviewReady: async (preview) => this.handlePreviewReady(preview, method, flags['no-prompt'], previewState, callbackResults),
+            onProgress: (message) => {
+                if (message.startsWith('Object not found:')) {
+                    // Surface "not found" warnings immediately to the user
+                    const objectName = message.replace('Object not found: ', '');
+                    this.spinner.stop();
+                    this.warn(messages.getMessage('warnings.objectNotVerified', [objectName]));
+                    this.log('');
+                    hasObjectWarnings = true;
+                    return;
+                }
+                else if (message.includes('definitions to create') || message.includes('definition to create')) {
+                    // Phase 1 complete — stop spinner, preview table will render next
+                    this.spinner.stop();
+                }
+                else if (message.startsWith('Complete:')) {
+                    // Skip the final summary message — the table renders the results
+                    return;
+                }
+                else {
+                    this.spinner.status = message;
+                }
+            },
+            onObjectComplete: (objResult) => {
+                callbackResults.push({
+                    objectName: objResult.objectName,
+                    objectLabel: previewState.objectLabels.get(objResult.objectName),
+                    status: objResult.status,
+                    type: objResult.type,
+                    definitionKey: objResult.definitionKey,
+                    category: objResult.category,
+                    timeCategory: objResult.timeCategory,
+                    segmentCategory: objResult.segmentCategory,
+                    fieldCount: objResult.fieldCount,
+                });
+                // Update spinner with running progress counts
+                const counts = { created: 0, skipped: 0, failed: 0 };
+                for (const r of callbackResults) {
+                    if (r.status === 'success')
+                        counts.created++;
+                    else if (r.status === 'skip')
+                        counts.skipped++;
+                    else if (r.status === 'fail')
+                        counts.failed++;
+                }
+                const parts = [`${objResult.current}/${objResult.total}`];
+                if (counts.created > 0)
+                    parts.push(`${counts.created} ${messages.getMessage('spinner.status.created')}`);
+                if (counts.skipped > 0)
+                    parts.push(`${counts.skipped} ${messages.getMessage('spinner.status.skipped')}`);
+                if (counts.failed > 0)
+                    parts.push(`${counts.failed} ${messages.getMessage('spinner.status.failed')}`);
+                this.spinner.status = parts.join(', ');
+            },
+        };
+        // Execute operation
+        this.log('');
+        this.spinner.start(messages.getMessage('spinner.validatingObjects'));
+        const result = await operation.execute(operationOptions);
+        if (hasObjectWarnings) {
+            // Spinner was already stopped by the warning handler; suppress duplicate output
+            try {
+                this.spinner.stop('');
+            }
+            catch {
+                /* already stopped */
+            }
+        }
+        else {
+            this.spinner.stop();
+        }
+        // Handle failure
+        if (!result.success) {
+            return this.handleOperationFailure(result, targetOrg, dryRun);
+        }
+        const data = result.data;
+        // Handle cancellation
+        if (data.cancelled) {
+            this.log('');
+            this.log(messages.getMessage('output.cancelled'));
+            return {
+                success: true,
+                created: 0,
+                failed: 0,
+                skipped: data.skipped,
+                total: data.total,
+                dryRun,
+                failures: [],
+                results: [],
+            };
+        }
+        // Display results tables (suppress in JSON mode — printTable writes directly to stdout)
+        if (!this.jsonEnabled()) {
+            displayResultsTables(this.log.bind(this), this.warn.bind(this), callbackResults, data, dryRun, data.recordCounts ?? previewState.recordCounts);
+        }
+        // Display warnings if any (skip "Object not found" warnings already shown inline)
+        const remainingWarnings = (result.warnings ?? []).filter((w) => !w.startsWith('Object not found:'));
+        if (remainingWarnings.length > 0) {
+            this.log('');
+            for (const warning of remainingWarnings) {
+                this.warn(warning);
+            }
+        }
+        // Post-creation actions
+        await this.handlePostCreationActions(flags, data, dryRun, facade, soqlAdapter, restAdapter, facade.instanceUrl ?? '');
+        if (data.failed > 0) {
+            process.exitCode = 1;
+        }
+        return {
+            success: true,
+            created: data.created,
+            failed: data.failed,
+            skipped: data.skipped,
+            total: data.total,
+            dryRun,
+            failures: data.failures,
+            results: data.results,
+            availabilityGrid: data.availabilityGrid,
+        };
+    }
+    /**
+     * Two-stage confirmation: summary then detailed preview table.
+     */
+    async handlePreviewReady(preview, method, noPrompt, previewState, callbackResults) {
+        this.spinner.stop();
+        // eslint-disable-next-line no-param-reassign -- intentional state mutation for preview callback
+        previewState.recordCounts = preview.recordCounts;
+        for (const input of [...preview.toCreate, ...preview.toSkip]) {
+            if (input.objectLabel)
+                previewState.objectLabels.set(input.objectName, input.objectLabel);
+        }
+        // Stage 1: Summary
+        const uniqueObjects = new Set([
+            ...preview.toCreate.map((i) => i.objectName),
+            ...preview.toSkip.map((i) => i.objectName),
+        ]).size;
+        const preConfirmEntries = buildPreConfirmSummary(uniqueObjects, method, preview.toCreate.length, preview.toSkip.length);
+        // Suppress all display output in JSON mode — this.log() writes to stdout,
+        // which would produce invalid JSON when mixed with the JSON payload.
+        if (!this.jsonEnabled()) {
+            this.log('');
+            this.log(renderSummaryBox({
+                title: messages.getMessage('output.creationSummary'),
+                entries: preConfirmEntries,
+            }));
+        }
+        if (!this.jsonEnabled() && !noPrompt) {
+            this.log('');
+            const showDetail = await this.confirm({
+                message: messages.getMessage('prompt.showDetail'),
+            });
+            if (!showDetail)
+                return false;
+        }
+        // Stage 2: Detailed preview table
+        const previewCallbackResults = preview.toCreate.map((input) => ({
+            objectName: input.objectName,
+            objectLabel: input.objectLabel,
+            status: 'preview',
+            type: input.method,
+            category: input.category,
+            timeCategory: DefinitionCreateOperation.resolveTimeCategory(input),
+            segmentCategory: input.recordTypeName,
+        }));
+        const skipCallbackResults = preview.toSkip.map((input) => ({
+            objectName: input.objectName,
+            objectLabel: input.objectLabel,
+            status: 'skip',
+            type: input.method,
+            category: input.category,
+            timeCategory: DefinitionCreateOperation.resolveTimeCategory(input),
+            segmentCategory: input.recordTypeName,
+        }));
+        const previewData = {
+            created: preview.toCreate.length,
+            failed: 0,
+            skipped: preview.toSkip.length,
+            total: preview.total,
+            results: [],
+            failures: [],
+        };
+        // Display preview tables (suppress in JSON mode — printTable writes directly to stdout)
+        if (!this.jsonEnabled()) {
+            displayResultsTables(this.log.bind(this), this.warn.bind(this), [...previewCallbackResults, ...skipCallbackResults], previewData, true, preview.recordCounts);
+        }
+        if (this.jsonEnabled())
+            return true;
+        if (noPrompt)
+            return true;
+        this.log('');
+        const confirmed = await this.confirm({
+            message: messages.getMessage('prompt.confirm', [String(preview.toCreate.length)]),
+        });
+        if (confirmed) {
+            // eslint-disable-next-line no-param-reassign -- intentional array reset for callback results
+            callbackResults.length = 0;
+            this.spinner.start(messages.getMessage('output.creating', [preview.toCreate.length]));
+        }
+        return confirmed;
+    }
+    /**
+     * Handles operation failure by translating error codes to user-friendly messages.
+     */
+    handleOperationFailure(result, targetOrg, dryRun) {
+        const failure = resolveOperationFailure(result, targetOrg, dryRun, (errorCodeMap, errorCode, fallbackMessage, msgs) => DefinitionCreate.resolveErrorMessage(errorCodeMap, errorCode, fallbackMessage, msgs));
+        if (failure.type === 'exit') {
+            if (failure.log)
+                this.log(failure.log);
+            process.exitCode = 2;
+            return failure.result;
+        }
+        this.error(failure.message, { code: failure.code });
+    }
+    /**
+     * Handles post-creation actions: --profile, --open, --logs.
+     */
+    async handlePostCreationActions(flags, data, dryRun, _facade, soqlAdapter, restAdapter, instanceUrl) {
+        if (flags.profile && data.created > 0 && !dryRun) {
+            await this.triggerProfiling(data, soqlAdapter, restAdapter);
+        }
+        else if (flags.profile && dryRun) {
+            this.log('');
+            this.log(messages.getMessage('output.profileDryRun', [String(data.created)]));
+        }
+        if (flags.open && data.created > 0 && !dryRun) {
+            this.openInBrowser(data, instanceUrl);
+        }
+        if (flags.logs) {
+            await this.writeSessionLogs(data, dryRun);
+        }
+    }
+    /**
+     * Triggers fire-and-forget profiling for successfully created definitions.
+     */
+    async triggerProfiling(data, soqlAdapter, restAdapter) {
+        const successResults = data.results.filter((r) => r.status === 'success' && r.definitionId);
+        if (successResults.length === 0)
+            return;
+        const executionService = new ProfilingExecutionService({ restAdapter, soqlAdapter });
+        this.log('');
+        this.log(messages.getMessage('output.profilingStarting'));
+        for (const r of successResults) {
+            // eslint-disable-next-line no-await-in-loop -- Sequential triggers to avoid overwhelming the org
+            const execResult = await executionService.execute(r.definitionId);
+            if (execResult.success) {
+                this.log(messages.getMessage('output.profilingSuccess', [r.definitionName ?? '', execResult.data ?? '']));
+            }
+            else {
+                this.warn(messages.getMessage('warnings.profilingFailed', [
+                    r.definitionName ?? '',
+                    execResult.message ?? 'unknown error',
+                ]));
+            }
+        }
+    }
+    /**
+     * Opens the first created definition in the default browser.
+     */
+    openInBrowser(data, instanceUrl) {
+        const firstSuccess = data.results.find((r) => r.status === 'success' && r.definitionId);
+        if (!firstSuccess)
+            return;
+        const url = `${instanceUrl}/lightning/r/pnova__Profiling_Definition__c/${firstSuccess.definitionId}/view`;
+        const platform = process.platform;
+        if (platform === 'darwin') {
+            execFile('open', [url], () => { });
+        }
+        else if (platform === 'win32') {
+            execFile('cmd', ['/c', 'start', url], () => { });
+        }
+        else {
+            execFile('xdg-open', [url], () => { });
+        }
+        this.log('');
+        if (data.created > 1) {
+            this.log(messages.getMessage('output.openedMultiple', [String(data.created)]));
+        }
+        else {
+            this.log(messages.getMessage('output.openedSingle'));
+        }
+    }
+    /**
+     * Writes session logs to a timestamped directory.
+     */
+    async writeSessionLogs(data, dryRun) {
+        const now = new Date();
+        const timestamp = now
+            .toISOString()
+            .replace(/:/g, '-')
+            .replace(/\.\d+Z$/, '');
+        const sessionDir = join('.cuneiform', 'logs', 'definition-create', timestamp);
+        await mkdir(sessionDir, { recursive: true });
+        const sessionData = {
+            timestamp: now.toISOString(),
+            dryRun,
+            created: data.created,
+            failed: data.failed,
+            skipped: data.skipped,
+            total: data.total,
+            results: data.results,
+            failures: data.failures,
+        };
+        const createdDefs = data.results
+            .filter((r) => r.status === 'success')
+            .map((r) => ({
+            objectName: r.objectName,
+            definitionName: r.definitionName,
+            definitionId: r.definitionId,
+            definitionKey: r.definitionKey,
+        }));
+        const errors = data.failures.map((f) => ({
+            objectName: f.objectName,
+            error: f.error,
+            errorCode: f.errorCode,
+        }));
+        await Promise.all([
+            writeFile(join(sessionDir, 'session.json'), JSON.stringify(sessionData, null, 2)),
+            writeFile(join(sessionDir, 'definitions-created.json'), JSON.stringify(createdDefs, null, 2)),
+            writeFile(join(sessionDir, 'errors.json'), JSON.stringify(errors, null, 2)),
+        ]);
+        this.log('');
+        this.log(messages.getMessage('output.sessionLog', [`${sessionDir}/`]));
+    }
+}
+//# sourceMappingURL=create.js.map