@copado/agentia-cli 0.122.0-alpha.0 → 1.0.0-beta.0

package/dist/lib/work-commit.js

@@ -1,350 +1,23 @@
-import { CicdGateway } from './cicd-gateway.js';
-import { cellValue } from './format.js';
-import { normalizeSalesforceId } from './salesforce-id.js';
-export const WORK_COMMIT_ACTIONS = ['Add', 'Delete', 'RetrieveOnly', 'SelectiveCommit', 'Full'];
-export const WORK_COMMIT_DEFAULT_TIMEOUT_SECONDS = 300;
-export const WORK_COMMIT_PLATFORM_EXPERIENCES = ['sfdx', 'salesforce'];
-export const WORK_COMMIT_METADATA_CATEGORY_HELP = 'Metadata category for simple input. Maps to change field c. For Salesforce metadata, always set SFDX so Copado stores c:SFDX. Omitting it omits c, and SFDX deploy steps log "Salesforce changes not found." and skip the deploy while the job can still report Successful.';
-export const WORK_COMMIT_CHANGES_HELP = 'Commit changes using API aliases or field names. Mutually exclusive with simple metadata fields. For Salesforce metadata, each change must include c: "SFDX" (or category: "SFDX") so Copado classifies the entry for SFDX deploy.';
-const SELECTIVE_BUNDLE_TYPES = new Set([
-    'AuraDefinitionBundle',
-    'DataPackageKitDefinition',
-    'DigitalExperience',
-    'ExperienceBundle',
-    'GenAiFunction',
-    'GenAiPlannerBundle',
-    'LightningComponentBundle',
-    'WaveTemplateBundle',
-]);
-const SUCCESSFUL_JOB_STATUSES = new Set(['Success', 'Successful']);
-const FAILED_JOB_STATUSES = new Set(['Canceled', 'Error', 'Failed', 'Skipped']);
-const POLL_BACKOFF_SECONDS = [2, 3, 5, 10];
-export class WorkCommitValidationError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'WorkCommitValidationError';
-    }
-}
-export class WorkCommitJobFailedError extends Error {
-    jobMonitor;
-    result;
-    constructor(jobMonitor, result) {
-        const status = jobMonitor.jobExecutionStatus ?? 'unknown';
-        const jobId = jobMonitor.jobExecutionId?.trim();
-        const prefix = jobId && jobId.length > 0 ? `Commit job ${jobId}` : 'Commit job';
-        const detail = jobMonitor.jobExecutionErrorMessage?.trim();
-        super(detail && detail.length > 0 ? `${prefix} finished with status ${status}: ${detail}` : `${prefix} finished with status ${status}.`);
-        this.name = 'WorkCommitJobFailedError';
-        this.jobMonitor = jobMonitor;
-        this.result = result;
-    }
-}
-export class WorkCommitTimeoutError extends Error {
-    jobMonitor;
-    result;
-    constructor(timeoutSeconds, jobMonitor, result) {
-        const jobId = jobMonitor?.jobExecutionId?.trim();
-        const suffix = jobId && jobId.length > 0 ? ` Last job execution Id: ${jobId}.` : '';
-        super(`Commit job did not finish within ${timeoutSeconds}s.${suffix}`);
-        this.name = 'WorkCommitTimeoutError';
-        this.jobMonitor = jobMonitor;
-        this.result = result;
-    }
-}
-const defaultSleep = async (ms) => new Promise((resolve) => {
-    setTimeout(resolve, ms);
-});
-let sleepFn = defaultSleep;
-// Test-only hook
-export function setWorkCommitSleepForTests(nextSleep) {
-    sleepFn = nextSleep;
-}
-// Test-only hook
-export function resetWorkCommitSleepForTests() {
-    sleepFn = defaultSleep;
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function normalizeKnownTopLevelKeys(value) {
-    return {
-        ...value,
-        ...(value.base_branch === undefined ? {} : { baseBranch: value.base_branch }),
-        ...(value.commit_id === undefined ? {} : { commitId: value.commit_id }),
-        ...(value.data_template_sync_config === undefined ? {} : { dataTemplateSyncConfig: value.data_template_sync_config }),
-        ...(value.execute_commit === undefined ? {} : { executeCommit: value.execute_commit }),
-        ...(value.recreate_feature_branch === undefined ? {} : { recreateFeatureBranch: value.recreate_feature_branch }),
-        ...(value.user_story_id === undefined ? {} : { userStoryId: value.user_story_id }),
-    };
-}
-function optionalString(value, label) {
-    if (value === undefined || value === null) {
-        return undefined;
-    }
-    if (typeof value !== 'string') {
-        throw new WorkCommitValidationError(`${label} must be a string.`);
-    }
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : undefined;
-}
-function requiredString(value, label) {
-    const stringValue = optionalString(value, label);
-    if (stringValue === undefined) {
-        throw new WorkCommitValidationError(`${label} is required.`);
-    }
-    return stringValue;
-}
-function optionalBoolean(value, label) {
-    if (value === undefined || value === null) {
-        return undefined;
-    }
-    if (typeof value !== 'boolean') {
-        throw new WorkCommitValidationError(`${label} must be a boolean.`);
-    }
-    return value;
-}
-function normalizeAction(value) {
-    const action = optionalString(value, 'change action') ?? 'Add';
-    if (!WORK_COMMIT_ACTIONS.includes(action)) {
-        throw new WorkCommitValidationError(`Unsupported change action '${action}'. Use one of: ${WORK_COMMIT_ACTIONS.join(', ')}.`);
-    }
-    return action;
-}
-function normalizeSelections(value) {
-    if (value === undefined || value === null) {
-        return undefined;
-    }
-    if (!Array.isArray(value)) {
-        throw new WorkCommitValidationError('change selections must be an array of strings.');
-    }
-    const selections = value.map((item) => requiredString(item, 'change selection'));
-    return selections.length > 0 ? selections : undefined;
-}
-export function normalizeWorkCommitChange(value) {
-    if (!isRecord(value)) {
-        throw new WorkCommitValidationError('Each change must be a JSON object.');
-    }
-    const action = normalizeAction(value.a ?? value.action);
-    const name = requiredString(value.n ?? value.name, 'change name');
-    const type = requiredString(value.t ?? value.type, 'change type');
-    const category = optionalString(value.c ?? value.category, 'change category');
-    const message = optionalString(value.m ?? value.message, 'change message');
-    const rawJson = value.j ?? value.rawJson ?? value.raw_json;
-    const selections = normalizeSelections(value.selections);
-    if (action === 'SelectiveCommit' && SELECTIVE_BUNDLE_TYPES.has(type) && (selections === undefined || selections.length === 0)) {
-        throw new WorkCommitValidationError(`SelectiveCommit for ${type} requires one or more selections.`);
-    }
-    return {
-        a: action,
-        ...(category === undefined ? {} : { c: category }),
-        ...(rawJson === undefined ? {} : { j: rawJson }),
-        ...(message === undefined ? {} : { m: message }),
-        n: name,
-        ...(selections === undefined ? {} : { selections }),
-        t: type,
-    };
-}
-export function normalizeWorkCommitInput(value) {
-    if (!isRecord(value)) {
-        throw new WorkCommitValidationError('Commit request must be a JSON object.');
-    }
-    const normalized = normalizeKnownTopLevelKeys(value);
-    const { changes } = normalized;
-    if (!Array.isArray(changes)) {
-        throw new WorkCommitValidationError('Commit request requires changes.');
-    }
-    return {
-        baseBranch: optionalString(normalized.baseBranch, 'baseBranch') ?? null,
-        changes,
-        commitId: optionalString(normalized.commitId, 'commitId'),
-        dataTemplateSyncConfig: Array.isArray(normalized.dataTemplateSyncConfig)
-            ? normalized.dataTemplateSyncConfig
-            : undefined,
-        executeCommit: optionalBoolean(normalized.executeCommit, 'executeCommit'),
-        message: optionalString(normalized.message, 'message'),
-        recreateFeatureBranch: optionalBoolean(normalized.recreateFeatureBranch, 'recreateFeatureBranch'),
-        userStoryId: optionalString(normalized.userStoryId, 'userStoryId'),
-    };
-}
-export function buildWorkCommitRequest(input, defaults) {
-    const userStoryId = normalizeSalesforceId(input.userStoryId ?? defaults.userStoryId);
-    const message = requiredString(input.message ?? defaults.message, 'message');
-    const changes = input.changes.map((change) => normalizeWorkCommitChange(change));
-    if (changes.length === 0) {
-        throw new WorkCommitValidationError('Commit request requires at least one change.');
-    }
-    const executeCommit = input.executeCommit ?? true;
-    if (!executeCommit && input.commitId === undefined) {
-        throw new WorkCommitValidationError('commitId is required when executeCommit is false.');
-    }
-    return {
-        ...(input.baseBranch === undefined ? {} : { baseBranch: input.baseBranch }),
-        changes,
-        ...(input.commitId === undefined ? {} : { commitId: input.commitId }),
-        ...(input.dataTemplateSyncConfig === undefined ? {} : { dataTemplateSyncConfig: input.dataTemplateSyncConfig }),
-        executeCommit,
-        message,
-        recreateFeatureBranch: input.recreateFeatureBranch ?? false,
-        userStoryId,
-    };
-}
-export function workCommitPreflightEndpoint(userStoryId) {
-    return `/release/commit/user-story/${normalizeSalesforceId(userStoryId)}`;
-}
-export function workCommitEndpoint() {
-    return '/release/commit';
-}
-export function workCommitJobMonitorEndpoint(jobExecutionId) {
-    return `/release/job-monitor/execution/${normalizeSalesforceId(jobExecutionId)}`;
-}
-export function normalizeWorkCommitPlatformExperience(value) {
-    const normalized = (value ?? 'sfdx').trim().toLowerCase();
-    if (!WORK_COMMIT_PLATFORM_EXPERIENCES.includes(normalized)) {
-        throw new WorkCommitValidationError(`Unsupported platform experience '${value}'. Use one of: ${WORK_COMMIT_PLATFORM_EXPERIENCES.join(', ')}.`);
-    }
-    return normalized;
-}
-function isTerminalJobStatus(status) {
-    return status !== undefined && status !== null && (SUCCESSFUL_JOB_STATUSES.has(status) || FAILED_JOB_STATUSES.has(status));
-}
-function isFailedJobStatus(status) {
-    return status !== undefined && status !== null && FAILED_JOB_STATUSES.has(status);
-}
-function resolveWorkCommitResultRecord(commit) {
-    if (commit.userStoryCommit?.id !== undefined && commit.userStoryCommit.id !== null) {
-        return {
-            resultId: commit.userStoryCommit.id,
-            resultName: commit.userStoryCommit.name,
-            resultSource: 'userStoryCommit',
-        };
-    }
-    if (commit.jobExecution?.id !== undefined && commit.jobExecution.id !== null) {
-        return {
-            resultId: commit.jobExecution.id,
-            resultName: commit.jobExecution.name,
-            resultSource: 'jobExecution',
-        };
-    }
-    return {};
-}
-export async function waitForWorkCommitJob(options) {
-    const { hooks, jobExecutionId, platformExperience, timeoutSeconds } = options;
-    const deadline = Date.now() + timeoutSeconds * 1000;
-    let lastResult;
-    let pollCount = 0;
-    for (;;) {
-        // eslint-disable-next-line no-await-in-loop -- job polling must be sequential
-        const result = await CicdGateway.call({
-            endpoint: workCommitJobMonitorEndpoint(jobExecutionId),
-            headers: { 'platform-experience': platformExperience },
-            method: 'GET',
-        });
-        lastResult = result;
-        const status = result.jobExecutionStatus;
-        hooks.log(`Commit job ${jobExecutionId}: ${status ?? 'unknown'}`);
-        if (isTerminalJobStatus(status)) {
-            if (isFailedJobStatus(status)) {
-                throw new WorkCommitJobFailedError(result);
-            }
-            return result;
-        }
-        const delaySeconds = POLL_BACKOFF_SECONDS[Math.min(pollCount, POLL_BACKOFF_SECONDS.length - 1)];
-        const remainingMs = deadline - Date.now();
-        if (remainingMs <= 0) {
-            throw new WorkCommitTimeoutError(timeoutSeconds, lastResult);
-        }
-        // eslint-disable-next-line no-await-in-loop -- bounded polling backoff
-        await sleepFn(Math.min(delaySeconds * 1000, remainingMs));
-        pollCount += 1;
-    }
-}
-export async function performWorkCommit(options) {
-    const { hooks, initialPlatformExperience, request, timeoutSeconds, wait } = options;
-    const initialPlatform = normalizeWorkCommitPlatformExperience(initialPlatformExperience);
-    const preflight = await hooks.withSpinner('Checking user story commit readiness', () => CicdGateway.call({
-        endpoint: workCommitPreflightEndpoint(request.userStoryId),
-        headers: { 'platform-experience': initialPlatform },
-        method: 'GET',
-    }));
-    const platformExperience = normalizeWorkCommitPlatformExperience(preflight.platformExperience ?? initialPlatform);
-    const commit = await hooks.withSpinner('Starting cloud commit', () => CicdGateway.call({
-        body: request,
-        endpoint: workCommitEndpoint(),
-        headers: {
-            'Content-Type': 'application/json',
-            'platform-experience': platformExperience,
-        },
-        method: 'POST',
-    }));
-    const resultRecord = resolveWorkCommitResultRecord(commit);
-    const jobExecutionId = commit.jobExecution?.id ?? undefined;
-    let jobMonitor;
-    try {
-        jobMonitor =
-            wait && jobExecutionId !== undefined && jobExecutionId !== null && jobExecutionId.trim().length > 0
-                ? await hooks.withSpinner('Waiting for commit job', () => waitForWorkCommitJob({ hooks, jobExecutionId, platformExperience, timeoutSeconds }))
-                : undefined;
-    }
-    catch (error) {
-        if (error instanceof WorkCommitJobFailedError || error instanceof WorkCommitTimeoutError) {
-            const failedMonitor = error.jobMonitor;
-            const partialResult = {
-                commit,
-                ...(failedMonitor === undefined ? {} : { jobMonitor: failedMonitor }),
-                platformExperience,
-                preflight,
-                request,
-                ...resultRecord,
-                wait,
-            };
-            if (error instanceof WorkCommitJobFailedError) {
-                throw new WorkCommitJobFailedError(error.jobMonitor, partialResult);
-            }
-            throw new WorkCommitTimeoutError(timeoutSeconds, failedMonitor, partialResult);
-        }
-        throw error;
-    }
-    return {
-        commit,
-        ...(jobMonitor === undefined ? {} : { jobMonitor }),
-        platformExperience,
-        preflight,
-        request,
-        ...resultRecord,
-        wait,
-    };
-}
-function formatRecord(label, record) {
-    if (record === undefined || record === null) {
-        return [];
-    }
-    const lines = [
-        `${label}: ${cellValue(record.name ?? record.id)}`,
-        `  ID: ${cellValue(record.id)}`,
-        `  Status: ${cellValue(record.status)}`,
-    ];
-    const link = record.attributes?.link;
-    if (link !== undefined && link !== null && link.trim().length > 0) {
-        lines.push(`  Link: ${link}`);
-    }
-    return lines;
-}
-export function formatWorkCommitResult(result) {
-    const lines = [
-        `User Story: ${result.request.userStoryId}`,
-        `Result ID: ${cellValue(result.resultId)}`,
-        `Result Source: ${cellValue(result.resultSource)}`,
-        `Platform Experience: ${result.platformExperience}`,
-        `Commit Type: ${cellValue(result.commit.commitType)}`,
-        ...formatRecord('User Story Commit', result.commit.userStoryCommit),
-        ...formatRecord('Job Execution', result.commit.jobExecution),
-    ];
-    if (result.jobMonitor !== undefined) {
-        lines.push(`Final Job Status: ${cellValue(result.jobMonitor.jobExecutionStatus)}`);
-        if (result.jobMonitor.jobExecutionErrorMessage) {
-            lines.push(`Final Job Error: ${result.jobMonitor.jobExecutionErrorMessage}`);
-        }
-    }
-    return lines.join('\n');
-}
-//# sourceMappingURL=work-commit.js.map
+import {modules} from './runtime.js';
+const WORK_COMMIT_ACTIONS = modules["work-commit.js"]["WORK_COMMIT_ACTIONS"]
+const WORK_COMMIT_CHANGES_HELP = modules["work-commit.js"]["WORK_COMMIT_CHANGES_HELP"]
+const WORK_COMMIT_DEFAULT_TIMEOUT_SECONDS = modules["work-commit.js"]["WORK_COMMIT_DEFAULT_TIMEOUT_SECONDS"]
+const WORK_COMMIT_METADATA_CATEGORY_HELP = modules["work-commit.js"]["WORK_COMMIT_METADATA_CATEGORY_HELP"]
+const WORK_COMMIT_PLATFORM_EXPERIENCES = modules["work-commit.js"]["WORK_COMMIT_PLATFORM_EXPERIENCES"]
+const WorkCommitJobFailedError = modules["work-commit.js"]["WorkCommitJobFailedError"]
+const WorkCommitTimeoutError = modules["work-commit.js"]["WorkCommitTimeoutError"]
+const WorkCommitValidationError = modules["work-commit.js"]["WorkCommitValidationError"]
+const buildWorkCommitRequest = modules["work-commit.js"]["buildWorkCommitRequest"]
+const formatWorkCommitResult = modules["work-commit.js"]["formatWorkCommitResult"]
+const normalizeWorkCommitChange = modules["work-commit.js"]["normalizeWorkCommitChange"]
+const normalizeWorkCommitInput = modules["work-commit.js"]["normalizeWorkCommitInput"]
+const normalizeWorkCommitPlatformExperience = modules["work-commit.js"]["normalizeWorkCommitPlatformExperience"]
+const performWorkCommit = modules["work-commit.js"]["performWorkCommit"]
+const resetWorkCommitSleepForTests = modules["work-commit.js"]["resetWorkCommitSleepForTests"]
+const resolveWorkCommitPlatformExperience = modules["work-commit.js"]["resolveWorkCommitPlatformExperience"]
+const setWorkCommitSleepForTests = modules["work-commit.js"]["setWorkCommitSleepForTests"]
+const waitForWorkCommitJob = modules["work-commit.js"]["waitForWorkCommitJob"]
+const workCommitEndpoint = modules["work-commit.js"]["workCommitEndpoint"]
+const workCommitJobMonitorEndpoint = modules["work-commit.js"]["workCommitJobMonitorEndpoint"]
+const workCommitPreflightEndpoint = modules["work-commit.js"]["workCommitPreflightEndpoint"]
+export {WORK_COMMIT_ACTIONS, WORK_COMMIT_CHANGES_HELP, WORK_COMMIT_DEFAULT_TIMEOUT_SECONDS, WORK_COMMIT_METADATA_CATEGORY_HELP, WORK_COMMIT_PLATFORM_EXPERIENCES, WorkCommitJobFailedError, WorkCommitTimeoutError, WorkCommitValidationError, buildWorkCommitRequest, formatWorkCommitResult, normalizeWorkCommitChange, normalizeWorkCommitInput, normalizeWorkCommitPlatformExperience, performWorkCommit, resetWorkCommitSleepForTests, resolveWorkCommitPlatformExperience, setWorkCommitSleepForTests, waitForWorkCommitJob, workCommitEndpoint, workCommitJobMonitorEndpoint, workCommitPreflightEndpoint};

package/dist/lib/work-defaults.js

@@ -1,50 +1,5 @@
-import { getUserContext } from './user-context.js';
-import { applySourceCredentialEnvironmentRule } from './work-types.js';
-const PROJECT_DEFAULT_TO_PAYLOAD_KEY = {
-    credential: 'sourceCredential',
-    environment: 'sourceEnvironment',
-    epic: 'epic',
-    feature: 'feature',
-    project: 'project',
-    sprint: 'sprintId',
-    team: 'team',
-};
-export async function buildWorkDefaultsPayload(resolved, options = {}) {
-    const getUserContextFn = options.getUserContext ?? getUserContext;
-    const resolveAssignee = options.resolveAssignee ?? true;
-    const payload = {};
-    const values = Object.fromEntries(resolved.map((entry) => [entry.key, entry.value]));
-    for (const defaultKey of Object.keys(PROJECT_DEFAULT_TO_PAYLOAD_KEY)) {
-        const value = values[defaultKey];
-        if (typeof value === 'string' && value.trim().length > 0) {
-            const payloadKey = PROJECT_DEFAULT_TO_PAYLOAD_KEY[defaultKey];
-            Object.assign(payload, { [payloadKey]: value });
-        }
-    }
-    if (resolveAssignee && values.assignMe === true) {
-        const userContext = await getUserContextFn();
-        const userId = userContext.id;
-        if (userId === undefined || userId.trim().length === 0) {
-            throw new Error('Current user ID is unavailable from the CICD gateway context.');
-        }
-        payload.assignee = userId;
-    }
-    return payload;
-}
-export function mergeWorkMutationPayload(explicit, defaults) {
-    const merged = { ...defaults };
-    for (const [key, value] of Object.entries(explicit)) {
-        if (value !== undefined) {
-            merged[key] = value;
-        }
-    }
-    return merged;
-}
-export async function buildWorkCreatePayload(explicit, resolved, options = {}) {
-    const defaults = await buildWorkDefaultsPayload(resolved, {
-        ...options,
-        resolveAssignee: options.resolveAssignee ?? explicit.assignee === undefined,
-    });
-    return applySourceCredentialEnvironmentRule(mergeWorkMutationPayload(explicit, defaults));
-}
-//# sourceMappingURL=work-defaults.js.map
+import {modules} from './runtime.js';
+const buildWorkCreatePayload = modules["work-defaults.js"]["buildWorkCreatePayload"]
+const buildWorkDefaultsPayload = modules["work-defaults.js"]["buildWorkDefaultsPayload"]
+const mergeWorkMutationPayload = modules["work-defaults.js"]["mergeWorkMutationPayload"]
+export {buildWorkCreatePayload, buildWorkDefaultsPayload, mergeWorkMutationPayload};

package/dist/lib/work-done.js

@@ -1,136 +1,5 @@
-import { Flags } from '@oclif/core';
-import { CicdGateway } from './cicd-gateway.js';
-import { listPendingChanges } from './git-worktree.js';
-import { performWorkPush, resolveActiveFeatureWorkItem, resolveWorkPushContext, resolveWorkPushNeed, WorkPushValidationError, } from './work-push.js';
-import { formatWorkCommandMessage, workDoneEndpoint, } from './work-types.js';
-export const workDoneFlags = {
-    'skip-nested-metadata-detection': Flags.boolean({
-        default: false,
-        description: 'Do not detect the nested metadata changed across the branch when pushing (also configurable via skipNestedMetadataDetection in .agentia/config.json or .agentia/config.user.json)',
-    }),
-};
-export function pickWorkDoneFlags(flags) {
-    const picked = {};
-    for (const key of Object.keys(workDoneFlags)) {
-        const value = flags[key];
-        if (typeof value === 'boolean') {
-            Object.assign(picked, { [key]: value });
-        }
-    }
-    return picked;
-}
-export async function runWorkDone(command, flags) {
-    const startedAt = Date.now();
-    let branch;
-    let workItem;
-    try {
-        ;
-        ({ branch, workItem } = await resolveActiveFeatureWorkItem());
-    }
-    catch (error) {
-        if (error instanceof WorkPushValidationError) {
-            command.error(error.message, {
-                exit: error.exit,
-                suggestions: error.suggestions,
-            });
-        }
-        throw error;
-    }
-    const pendingFiles = await listPendingChanges();
-    if (pendingFiles.length > 0) {
-        command.error([
-            'Uncommitted tracked changes present. Commit them, then try again:',
-            ...pendingFiles.map((file) => `  ${file}`),
-        ].join('\n'), {
-            exit: 2,
-            suggestions: ['git add -A && git commit', `${command.config.bin} cicd work submit --done`],
-        });
-    }
-    command.display(() => {
-        command.log(`Branch: ${branch}`);
-        command.log(`Work item: ${workItem}`);
-    });
-    let needsPush;
-    let skippedForDataSteps = false;
-    try {
-        const pushNeed = await resolveWorkPushNeed(branch);
-        needsPush = pushNeed.needsPush;
-        skippedForDataSteps = pushNeed.skippedForDataSteps;
-    }
-    catch (error) {
-        if (error instanceof WorkPushValidationError) {
-            command.error(error.message, {
-                exit: error.exit,
-                suggestions: error.suggestions,
-            });
-        }
-        throw error;
-    }
-    let pushResult;
-    if (needsPush) {
-        let pushContext;
-        try {
-            pushContext = await resolveWorkPushContext();
-        }
-        catch (error) {
-            if (error instanceof WorkPushValidationError) {
-                command.error(error.message, {
-                    exit: error.exit,
-                    suggestions: error.suggestions,
-                });
-            }
-            throw error;
-        }
-        command.display(() => {
-            command.log(`Base branch: ${pushContext.baseBranch}`);
-            command.log(`Dev org branch: ${pushContext.devOrgBranch}`);
-            command.log('Unpushed commits detected; pushing before submit --done.');
-        });
-        try {
-            pushResult = await performWorkPush({
-                ...pushContext,
-                hooks: {
-                    display: (render) => command.display(render),
-                    log: (message) => command.log(message),
-                    withSpinner: (message, action) => command.withSpinner(message, action),
-                },
-                skipNestedMetadataDetection: flags['skip-nested-metadata-detection'],
-            });
-        }
-        catch (error) {
-            if (error instanceof WorkPushValidationError) {
-                command.error(error.message, {
-                    exit: error.exit,
-                    suggestions: error.suggestions,
-                });
-            }
-            throw error;
-        }
-    }
-    else if (!skippedForDataSteps) {
-        command.display(() => {
-            command.log('Branch is up to date with origin; skipping push.');
-        });
-    }
-    const doneBody = { workItem };
-    const done = await command.withSpinner('Marking work item done', () => CicdGateway.call({
-        body: doneBody,
-        endpoint: workDoneEndpoint(),
-        headers: {
-            'Content-Type': 'application/json',
-        },
-        method: 'POST',
-    }));
-    command.display(() => {
-        command.log(formatWorkCommandMessage(done.message));
-    });
-    command.logElapsed(startedAt);
-    return {
-        branch,
-        done,
-        push: pushResult,
-        pushed: needsPush,
-        workItem,
-    };
-}
-//# sourceMappingURL=work-done.js.map
+import {modules} from './runtime.js';
+const pickWorkDoneFlags = modules["work-done.js"]["pickWorkDoneFlags"]
+const runWorkDone = modules["work-done.js"]["runWorkDone"]
+const workDoneFlags = modules["work-done.js"]["workDoneFlags"]
+export {pickWorkDoneFlags, runWorkDone, workDoneFlags};