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

package/dist/lib/work-flags.js

@@ -1,258 +1,16 @@
-import { Flags } from '@oclif/core';
-import { buildListPaginationQuery, listPaginationFlags } from './list-pagination.js';
-import { applySourceCredentialEnvironmentRule } from './work-types.js';
-export const workMutationStringFlags = {
-    'acceptance-criteria': Flags.string({
-        description: 'Acceptance criteria (maximum 255 characters)',
-    }),
-    'as-a': Flags.string({
-        description: 'User story "as a" clause (maximum 255 characters)',
-    }),
-    assignee: Flags.string({
-        description: 'Assignee ID',
-    }),
-    'cancellation-reason': Flags.string({
-        description: 'Cancellation reason',
-    }),
-    'close-date': Flags.string({
-        description: 'Close date',
-    }),
-    epic: Flags.string({
-        description: 'Epic',
-    }),
-    feature: Flags.string({
-        description: 'Feature',
-    }),
-    'functional-requirements': Flags.string({
-        description: 'Functional requirements (maximum 30000 characters)',
-    }),
-    'owner-id': Flags.string({
-        description: 'Owner ID',
-    }),
-    project: Flags.string({
-        description: 'Project ID',
-    }),
-    'record-type': Flags.string({
-        description: 'Record type',
-    }),
-    'release-id': Flags.string({
-        description: 'Release ID',
-    }),
-    'so-that': Flags.string({
-        description: 'User story "so that" clause (maximum 255 characters)',
-    }),
-    'source-credential': Flags.string({
-        description: 'Source credential ID. When set, sourceEnvironment is sent as null so Salesforce assigns the environment from the credential.',
-    }),
-    'source-environment': Flags.string({
-        description: 'Source environment ID. Ignored when --source-credential is also set.',
-    }),
-    'sprint-id': Flags.string({
-        description: 'Sprint ID',
-    }),
-    status: Flags.string({
-        description: 'Status',
-    }),
-    team: Flags.string({
-        description: 'Team',
-    }),
-    'technical-specifications': Flags.string({
-        description: 'Technical specifications (maximum 30000 characters)',
-    }),
-    theme: Flags.string({
-        description: 'Theme',
-    }),
-    title: Flags.string({
-        description: 'Title (maximum 255 characters)',
-    }),
-    'want-to': Flags.string({
-        description: 'User story "want to" clause (maximum 255 characters)',
-    }),
-};
-export const workMutationIntegerFlags = {
-    'actual-points': Flags.integer({
-        description: 'Actual points',
-    }),
-    'planned-points': Flags.integer({
-        description: 'Planned points',
-    }),
-    priority: Flags.integer({
-        description: 'Priority',
-    }),
-};
-export const workMutationBooleanFlags = {
-    'excluded-from-cbm': Flags.boolean({
-        allowNo: true,
-        description: 'Exclude from CBM',
-    }),
-};
-const WORK_MUTATION_FLAG_TO_PAYLOAD_KEY = {
-    'acceptance-criteria': 'acceptanceCriteria',
-    'actual-points': 'actualPoints',
-    'as-a': 'asA',
-    assignee: 'assignee',
-    'cancellation-reason': 'cancellationReason',
-    'close-date': 'closeDate',
-    epic: 'epic',
-    'excluded-from-cbm': 'excludedFromCbm',
-    feature: 'feature',
-    'functional-requirements': 'functionalRequirements',
-    'owner-id': 'ownerId',
-    'planned-points': 'plannedPoints',
-    priority: 'priority',
-    project: 'project',
-    'record-type': 'recordType',
-    'release-id': 'releaseId',
-    'so-that': 'soThat',
-    'source-credential': 'sourceCredential',
-    'source-environment': 'sourceEnvironment',
-    'sprint-id': 'sprintId',
-    status: 'status',
-    team: 'team',
-    'technical-specifications': 'technicalSpecifications',
-    theme: 'theme',
-    title: 'title',
-    'want-to': 'wantTo',
-};
-const MUTATION_FLAG_KEYS = Object.keys(WORK_MUTATION_FLAG_TO_PAYLOAD_KEY);
-export const WORK_STRING_VALIDATION_KEYS = [
-    'acceptanceCriteria',
-    'asA',
-    'assignee',
-    'cancellationReason',
-    'closeDate',
-    'epic',
-    'feature',
-    'functionalRequirements',
-    'ownerId',
-    'project',
-    'recordType',
-    'releaseId',
-    'soThat',
-    'sourceCredential',
-    'sourceEnvironment',
-    'sprintId',
-    'status',
-    'team',
-    'technicalSpecifications',
-    'theme',
-    'title',
-    'wantTo',
-];
-export const WORK_SHORT_TEXT_MAX_LENGTH = 255;
-export const WORK_LONG_TEXT_MAX_LENGTH = 30_000;
-export const ACCEPTANCE_CRITERIA_MAX_LENGTH = WORK_SHORT_TEXT_MAX_LENGTH;
-export const workListFilterFlags = {
-    ...listPaginationFlags,
-    'assigned-to-me': Flags.boolean({
-        description: 'Filter by the current user as assignee',
-    }),
-    'assignee-id': Flags.string({
-        description: 'Filter by assignee ID',
-    }),
-    'assignee-name': Flags.string({
-        description: 'Filter by assignee name',
-    }),
-    name: Flags.string({
-        description: 'Filter by name',
-    }),
-    'owned-by-me': Flags.boolean({
-        description: 'Filter by the current user as owner',
-    }),
-    'owner-id': Flags.string({
-        description: 'Filter by owner ID',
-    }),
-    'owner-name': Flags.string({
-        description: 'Filter by owner name',
-    }),
-    'project-id': Flags.string({
-        description: 'Filter by project ID',
-    }),
-    'project-name': Flags.string({
-        description: 'Filter by project name',
-    }),
-    status: Flags.string({
-        description: 'Filter by status',
-    }),
-    title: Flags.string({
-        description: 'Filter by title',
-    }),
-};
-const WORK_LIST_FILTER_FLAG_TO_KEY = {
-    'assignee-id': 'assigneeId',
-    'assignee-name': 'assigneeName',
-    name: 'name',
-    'owner-id': 'ownerId',
-    'owner-name': 'ownerName',
-    'project-id': 'projectId',
-    'project-name': 'projectName',
-    status: 'status',
-    title: 'title',
-};
-export function buildWorkListFilters(flags) {
-    const filters = {};
-    for (const flagKey of Object.keys(WORK_LIST_FILTER_FLAG_TO_KEY)) {
-        const value = flags[flagKey];
-        if (typeof value === 'string') {
-            const filterKey = WORK_LIST_FILTER_FLAG_TO_KEY[flagKey];
-            Object.assign(filters, { [filterKey]: value });
-        }
-    }
-    return { ...filters, ...buildListPaginationQuery(flags) };
-}
-export const workMutationFlags = {
-    ...workMutationBooleanFlags,
-    ...workMutationIntegerFlags,
-    ...workMutationStringFlags,
-};
-export function collectWorkMutationFlagKeys(flags) {
-    const selected = [];
-    for (const key of MUTATION_FLAG_KEYS) {
-        if (flags[key] !== undefined) {
-            selected.push(key);
-        }
-    }
-    return selected;
-}
-export function buildWorkMutationPayload(flags) {
-    const payload = {};
-    for (const flagKey of MUTATION_FLAG_KEYS) {
-        const value = flags[flagKey];
-        if (value !== undefined) {
-            const payloadKey = WORK_MUTATION_FLAG_TO_PAYLOAD_KEY[flagKey];
-            Object.assign(payload, { [payloadKey]: value });
-        }
-    }
-    return applySourceCredentialEnvironmentRule(payload);
-}
-export function validateNonEmptyStringFields(payload, keys) {
-    for (const key of keys) {
-        const value = payload[key];
-        if (typeof value === 'string' && value.trim().length === 0) {
-            return `${key} value cannot be empty`;
-        }
-    }
-    return undefined;
-}
-export function validateWorkMutationPayload(payload) {
-    const nonEmptyError = validateNonEmptyStringFields(payload, WORK_STRING_VALIDATION_KEYS);
-    if (nonEmptyError !== undefined) {
-        return nonEmptyError;
-    }
-    const shortTextKeys = ['acceptanceCriteria', 'asA', 'soThat', 'title', 'wantTo'];
-    for (const key of shortTextKeys) {
-        const value = payload[key];
-        if (typeof value === 'string' && value.length > WORK_SHORT_TEXT_MAX_LENGTH) {
-            return `${key} must contain at most ${WORK_SHORT_TEXT_MAX_LENGTH} characters (received ${value.length})`;
-        }
-    }
-    const longTextKeys = ['functionalRequirements', 'technicalSpecifications'];
-    for (const key of longTextKeys) {
-        const value = payload[key];
-        if (typeof value === 'string' && value.length > WORK_LONG_TEXT_MAX_LENGTH) {
-            return `${key} must contain at most ${WORK_LONG_TEXT_MAX_LENGTH} characters (received ${value.length})`;
-        }
-    }
-    return undefined;
-}
-//# sourceMappingURL=work-flags.js.map
+import {modules} from './runtime.js';
+const ACCEPTANCE_CRITERIA_MAX_LENGTH = modules["work-flags.js"]["ACCEPTANCE_CRITERIA_MAX_LENGTH"]
+const WORK_LONG_TEXT_MAX_LENGTH = modules["work-flags.js"]["WORK_LONG_TEXT_MAX_LENGTH"]
+const WORK_SHORT_TEXT_MAX_LENGTH = modules["work-flags.js"]["WORK_SHORT_TEXT_MAX_LENGTH"]
+const WORK_STRING_VALIDATION_KEYS = modules["work-flags.js"]["WORK_STRING_VALIDATION_KEYS"]
+const buildWorkListFilters = modules["work-flags.js"]["buildWorkListFilters"]
+const buildWorkMutationPayload = modules["work-flags.js"]["buildWorkMutationPayload"]
+const collectWorkMutationFlagKeys = modules["work-flags.js"]["collectWorkMutationFlagKeys"]
+const validateNonEmptyStringFields = modules["work-flags.js"]["validateNonEmptyStringFields"]
+const validateWorkMutationPayload = modules["work-flags.js"]["validateWorkMutationPayload"]
+const workListFilterFlags = modules["work-flags.js"]["workListFilterFlags"]
+const workMutationBooleanFlags = modules["work-flags.js"]["workMutationBooleanFlags"]
+const workMutationFlags = modules["work-flags.js"]["workMutationFlags"]
+const workMutationIntegerFlags = modules["work-flags.js"]["workMutationIntegerFlags"]
+const workMutationStringFlags = modules["work-flags.js"]["workMutationStringFlags"]
+export {ACCEPTANCE_CRITERIA_MAX_LENGTH, WORK_LONG_TEXT_MAX_LENGTH, WORK_SHORT_TEXT_MAX_LENGTH, WORK_STRING_VALIDATION_KEYS, buildWorkListFilters, buildWorkMutationPayload, collectWorkMutationFlagKeys, validateNonEmptyStringFields, validateWorkMutationPayload, workListFilterFlags, workMutationBooleanFlags, workMutationFlags, workMutationIntegerFlags, workMutationStringFlags};

package/dist/lib/work-local-commit.js

@@ -1,138 +1,7 @@
-import { readLastWorkItem, readLastWorkItemTitle, writeLastCommitSelections, } from './defaults-store.js';
-import { commitAllTrackedChanges, commitStagedChanges, getCurrentBranch, getHeadCommitId, isInsideGitWorkTree, listPendingChanges, listStagedChanges, } from './git-worktree.js';
-import { featureBranchName } from './work-types.js';
-export class WorkLocalCommitValidationError extends Error {
-    exit;
-    suggestions;
-    constructor(message, options = {}) {
-        super(message);
-        this.name = 'WorkLocalCommitValidationError';
-        this.exit = options.exit ?? 2;
-        if (options.suggestions !== undefined) {
-            this.suggestions = options.suggestions;
-        }
-    }
-}
-/** Splits a comma-separated flag value; returns an empty array for a blank value. */
-export function parseCommaSeparatedList(value) {
-    return value
-        .split(',')
-        .map((entry) => entry.trim())
-        .filter((entry) => entry.length > 0);
-}
-function normalizeSelection(value) {
-    if (value === undefined) {
-        return undefined;
-    }
-    return parseCommaSeparatedList(value).join(',');
-}
-async function resolveActiveFeatureBranchForLocalCommit() {
-    const workItem = (await readLastWorkItem())?.trim();
-    if (workItem === undefined || workItem.length === 0) {
-        throw new WorkLocalCommitValidationError('No work item recorded. Run `agentia cicd work set <work-item>` first.', { suggestions: ['agentia cicd work set <id>'] });
-    }
-    const expectedBranch = featureBranchName(workItem);
-    const branch = await getCurrentBranch();
-    if (branch !== expectedBranch) {
-        throw new WorkLocalCommitValidationError(`Current branch '${branch}' must be '${expectedBranch}'.`, {
-            suggestions: [`Checkout ${expectedBranch} (from \`agentia cicd work set\`).`],
-        });
-    }
-    return { branch, workItem };
-}
-/** Falls back to `<lastWorkItem> <lastWorkItemTitle>`, or `<lastWorkItem>` when no title is stored. */
-export async function resolveWorkLocalCommitMessage(explicitMessage) {
-    const explicit = explicitMessage?.trim();
-    const workItem = (await readLastWorkItem())?.trim();
-    if (explicit !== undefined && explicit.length > 0) {
-        return { message: explicit, ...(workItem === undefined ? {} : { workItem }) };
-    }
-    if (workItem === undefined || workItem.length === 0) {
-        throw new WorkLocalCommitValidationError('No commit message provided and no active work item recorded in .agentia/config.user.json.', { suggestions: ['agentia cicd work commit --local -m "<message>"', 'agentia cicd work set <id>'] });
-    }
-    const title = (await readLastWorkItemTitle())?.trim();
-    return {
-        message: title === undefined || title.length === 0 ? workItem : `${workItem} ${title}`,
-        workItem,
-    };
-}
-async function resolveCommittableFiles(all) {
-    if (all) {
-        const pendingFiles = await listPendingChanges();
-        if (pendingFiles.length === 0) {
-            throw new WorkLocalCommitValidationError('No tracked changes to commit.');
-        }
-        return pendingFiles;
-    }
-    const stagedFiles = await listStagedChanges();
-    if (stagedFiles.length === 0) {
-        throw new WorkLocalCommitValidationError('No staged changes to commit.', {
-            suggestions: ['git add <path>', 'agentia cicd work commit --local --all'],
-        });
-    }
-    return stagedFiles;
-}
-function gitFailureMessage(error) {
-    const stderr = typeof error === 'object' && error !== null && 'stderr' in error
-        ? String(error.stderr).trim()
-        : '';
-    const stdout = typeof error === 'object' && error !== null && 'stdout' in error
-        ? String(error.stdout).trim()
-        : '';
-    const detail = [stderr, stdout].filter((part) => part.length > 0).join('\n');
-    return detail.length > 0 ? detail : error instanceof Error ? error.message : String(error);
-}
-/**
- * Runs a plain `git commit` and records the Copado selections consumed later by `cicd work publish`.
- * No gateway call is made.
- */
-export async function performWorkLocalCommit(input) {
-    if (!(await isInsideGitWorkTree())) {
-        throw new WorkLocalCommitValidationError('Not inside a Git work tree. Run this command from the repository.');
-    }
-    const { branch, workItem } = await resolveActiveFeatureBranchForLocalCommit();
-    const { message } = await resolveWorkLocalCommitMessage(input.message);
-    const files = await resolveCommittableFiles(input.all);
-    try {
-        await (input.all ? commitAllTrackedChanges(message) : commitStagedChanges(message));
-    }
-    catch (error) {
-        throw new WorkLocalCommitValidationError(`git commit failed: ${gitFailureMessage(error)}`, { exit: 1 });
-    }
-    const commitId = await getHeadCommitId();
-    const selections = await writeLastCommitSelections({
-        ...(input.apexTestClasses === undefined ? {} : { apexTestClasses: normalizeSelection(input.apexTestClasses) }),
-        ...(input.fullMetadata === undefined ? {} : { fullMetadata: normalizeSelection(input.fullMetadata) }),
-        ...(input.permissions === undefined ? {} : { permissions: normalizeSelection(input.permissions) }),
-    });
-    return {
-        all: input.all,
-        branch,
-        commitId,
-        files,
-        message,
-        mode: 'local',
-        ...selections,
-        ...(workItem === undefined ? {} : { workItem }),
-    };
-}
-export function formatWorkLocalCommitResult(result) {
-    const lines = [
-        `Branch: ${result.branch}`,
-        ...(result.workItem === undefined ? [] : [`Work item: ${result.workItem}`]),
-        `Commit: ${result.commitId}`,
-        `Message: ${result.message}`,
-        `Files: ${result.files.length}`,
-    ];
-    if (result.lastPermissionSelected !== undefined) {
-        lines.push(`Permissions: ${result.lastPermissionSelected}`);
-    }
-    if (result.lastFullMetadataSelected !== undefined) {
-        lines.push(`Full metadata: ${result.lastFullMetadataSelected}`);
-    }
-    if (result.lastApexTestClassesSelected !== undefined) {
-        lines.push(`Apex test classes: ${result.lastApexTestClassesSelected}`);
-    }
-    return lines.join('\n');
-}
-//# sourceMappingURL=work-local-commit.js.map
+import {modules} from './runtime.js';
+const WorkLocalCommitValidationError = modules["work-local-commit.js"]["WorkLocalCommitValidationError"]
+const formatWorkLocalCommitResult = modules["work-local-commit.js"]["formatWorkLocalCommitResult"]
+const parseCommaSeparatedList = modules["work-local-commit.js"]["parseCommaSeparatedList"]
+const performWorkLocalCommit = modules["work-local-commit.js"]["performWorkLocalCommit"]
+const resolveWorkLocalCommitMessage = modules["work-local-commit.js"]["resolveWorkLocalCommitMessage"]
+export {WorkLocalCommitValidationError, formatWorkLocalCommitResult, parseCommaSeparatedList, performWorkLocalCommit, resolveWorkLocalCommitMessage};

package/dist/lib/work-local-run-tests.js

@@ -1,61 +1,5 @@
-import { CicdGateway } from './cicd-gateway.js';
-import { workRunTestsLocalEndpoint, } from './work-types.js';
-/** Records a local quality-gate run on the work item. Failures are reported via onWarning and never thrown. */
-export async function reportLocalRunTests(options) {
-    const body = {
-        status: options.status,
-        workItem: options.workItem,
-    };
-    // Send mixed stdout+stderr exactly as captured (chunk arrival order); do not trim.
-    if (options.logs !== undefined && options.logs.length > 0) {
-        body.logs = options.logs;
-    }
-    options.onLog?.('Uploading local quality gates results...');
-    try {
-        await CicdGateway.call({
-            body,
-            endpoint: workRunTestsLocalEndpoint(),
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            method: 'POST',
-        });
-        options.onLog?.('Done.');
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        options.onWarning?.(`Failed to report local quality gates result (${options.status}): ${message}`);
-    }
-}
-/** Reports success or skipped when local quality gates were available; no-ops otherwise. */
-export async function reportLocalQualityGatesOutcome(options) {
-    if (options.qualityGates.ran) {
-        await reportLocalRunTests({
-            logs: options.qualityGates.output,
-            onLog: options.onLog,
-            onWarning: options.onWarning,
-            status: 'success',
-            workItem: options.workItem,
-        });
-        return;
-    }
-    if (options.qualityGates.skipped) {
-        await reportLocalRunTests({
-            onLog: options.onLog,
-            onWarning: options.onWarning,
-            status: 'skipped',
-            workItem: options.workItem,
-        });
-    }
-}
-/** Reports failure for a local quality-gates script error. */
-export async function reportLocalQualityGatesFailure(options) {
-    await reportLocalRunTests({
-        logs: options.error.output,
-        onLog: options.onLog,
-        onWarning: options.onWarning,
-        status: 'failure',
-        workItem: options.workItem,
-    });
-}
-//# sourceMappingURL=work-local-run-tests.js.map
+import {modules} from './runtime.js';
+const reportLocalQualityGatesFailure = modules["work-local-run-tests.js"]["reportLocalQualityGatesFailure"]
+const reportLocalQualityGatesOutcome = modules["work-local-run-tests.js"]["reportLocalQualityGatesOutcome"]
+const reportLocalRunTests = modules["work-local-run-tests.js"]["reportLocalRunTests"]
+export {reportLocalQualityGatesFailure, reportLocalQualityGatesOutcome, reportLocalRunTests};

package/dist/lib/work-publish-command.js

@@ -1,88 +1,5 @@
-import { Flags } from '@oclif/core';
-import { listPendingChanges } from './git-worktree.js';
-import { performWorkPush, resolveWorkPushContext, WorkPushValidationError } from './work-push.js';
-export const WORK_PUBLISH_DESCRIPTION = [
-    'Publish the current feature/<lastWorkItem> branch and register commits with Copado.',
-    'Requires a clean working tree, base branch, and dev org branch from `.agentia/config.user.json`.',
-    'Fetches origin/<lastBaseBranch>, then registers only commits in origin/<lastBaseBranch>..HEAD and diffs nested parent XML at merge-base(origin/<lastBaseBranch>, HEAD) versus HEAD, so origin/base-only history is ignored.',
-    'When there are no commits since origin/<lastBaseBranch>, or origin already has HEAD, fails with "No changes to publish" unless `--permissions` and/or `--full-metadata` is set, in which case it creates an empty commit so a tip commit id exists.',
-    'Applies Copado environment-variable then yaml replacements to the added and modified files in origin/<lastBaseBranch>..HEAD (passed to the jars as `--include`; yaml `-b` is the feature branch, matching Copado Commit), commits both as a single follow-up commit, locks the tip commit, runs `git push origin <branch>`,',
-    'reports the nested metadata changed across the branch, such as the CustomField behind a profile field-permission edit, plus the parent components it would ignore,',
-    'calls headless work/push with one changeListUpdate list of Action:MetadataType:MetadataName corrections: lastPermissionSelected and --permissions plus the nested metadata of the changed profiles and permission sets as RetrieveOnly, lastFullMetadataSelected and --full-metadata plus brand-new nested parent files as fullMetadata, the ignored parents as unchanged, the nested metadata deleted on the branch as Del, and the remaining nested metadata as Add, then merges the feature branch into the recorded dev org branch.',
-    'The changed profiles and permission sets themselves are never sent as corrections, so they stay in the change list and deploy only the permissions their RetrieveOnly entries select. Brand-new nested parent files are an exception: they are sent as fullMetadata so the complete file travels.',
-    '`cicd work push` is a compatibility alias of this command.',
-].join(' ');
-export const workPublishFlags = {
-    'full-metadata': Flags.string({
-        description: 'Comma-separated type-prefixed metadata such as Profile:Sales_User,PermissionSet:Sales_Onboarding, added for this publish and sent as headless push fullMetadata corrections. The named metadata is committed as a complete file, so it is never decomposed into nested metadata. Not stored.',
-    }),
-    permissions: Flags.string({
-        description: 'Comma-separated type-prefixed metadata such as CustomField:Account.SLA__c,ApexClass:AccountService, added for this publish and sent as headless push RetrieveOnly corrections. Not stored.',
-    }),
-    'skip-nested-metadata-detection': Flags.boolean({
-        default: false,
-        description: 'Do not detect the nested metadata changed across the branch (also configurable via skipNestedMetadataDetection in .agentia/config.json or .agentia/config.user.json)',
-    }),
-};
-export async function runWorkPublish(command, flags) {
-    const startedAt = Date.now();
-    let context;
-    try {
-        context = await resolveWorkPushContext();
-    }
-    catch (error) {
-        if (error instanceof WorkPushValidationError) {
-            command.error(error.message, {
-                exit: error.exit,
-                suggestions: error.suggestions,
-            });
-        }
-        throw error;
-    }
-    const { baseBranch, branch, devOrgBranch, workItem, workItemId } = context;
-    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 publish`],
-        });
-    }
-    command.display(() => {
-        command.log(`Branch: ${branch}`);
-        command.log(`Work item: ${workItem}`);
-        command.log(`Base branch: ${baseBranch}`);
-        command.log(`Dev org branch: ${devOrgBranch}`);
-    });
-    try {
-        const result = await performWorkPush({
-            baseBranch,
-            branch,
-            devOrgBranch,
-            ...(flags['full-metadata'] === undefined ? {} : { fullMetadata: flags['full-metadata'] }),
-            hooks: {
-                display: (render) => command.display(render),
-                log: (message) => command.log(message),
-                withSpinner: (message, action) => command.withSpinner(message, action),
-            },
-            ...(flags.permissions === undefined ? {} : { permissions: flags.permissions }),
-            skipNestedMetadataDetection: flags['skip-nested-metadata-detection'],
-            workItem,
-            workItemId,
-        });
-        command.logElapsed(startedAt);
-        return result;
-    }
-    catch (error) {
-        if (error instanceof WorkPushValidationError) {
-            command.error(error.message, {
-                exit: error.exit,
-                suggestions: error.suggestions,
-            });
-        }
-        throw error;
-    }
-}
-//# sourceMappingURL=work-publish-command.js.map
+import {modules} from './runtime.js';
+const WORK_PUBLISH_DESCRIPTION = modules["work-publish-command.js"]["WORK_PUBLISH_DESCRIPTION"]
+const runWorkPublish = modules["work-publish-command.js"]["runWorkPublish"]
+const workPublishFlags = modules["work-publish-command.js"]["workPublishFlags"]
+export {WORK_PUBLISH_DESCRIPTION, runWorkPublish, workPublishFlags};