@copado/agentia-cli 1.0.0-beta.1 → 1.0.0-beta.2

package/dist/commands/cicd/work/commit.js

@@ -1,332 +1,18 @@
-import { Args, Flags } from '@oclif/core';
-import { readFileSync } from 'node:fs';
-import { AgentiaCommand } from '../../../lib/agentia-command.js';
-import { resolveWorkItemId, WorkActiveResolutionError } from '../../../lib/work-active.js';
-import { buildWorkCommitRequest, formatWorkCommitResult, normalizeWorkCommitInput, performWorkCommit, resolveWorkCommitPlatformExperience, WORK_COMMIT_ACTIONS, WORK_COMMIT_DEFAULT_TIMEOUT_SECONDS, WORK_COMMIT_METADATA_CATEGORY_HELP, WorkCommitJobFailedError, WorkCommitTimeoutError, WorkCommitValidationError, } from '../../../lib/work-commit.js';
-import { formatWorkLocalCommitResult, performWorkLocalCommit, WorkLocalCommitValidationError, } from '../../../lib/work-local-commit.js';
-const CLOUD_ONLY_FLAGS = [
-    'action',
-    'base-branch',
-    'commit-id',
-    'execute-commit',
-    'file',
-    'metadata-category',
-    'metadata-message',
-    'metadata-name',
-    'metadata-raw-json',
-    'metadata-type',
-    'recreate-feature-branch',
-    'selection',
-    'stdin',
-    'wait',
-    'wait-timeout',
-];
-const LOCAL_ONLY_FLAGS = ['all', 'apex-test-classes', 'full-metadata', 'permissions'];
-/** Explicitly provided flags only; values that came from an oclif default do not count. */
-function providedFlags(names, flags, metadata) {
-    return names.filter((name) => flags[name] !== undefined && metadata.flags[name]?.setFromDefault !== true);
-}
-function readStdin() {
-    if (process.stdin.isTTY) {
-        throw new WorkCommitValidationError('Cannot read --stdin from an interactive terminal. Pipe JSON input or use --file <path>.');
-    }
-    return new Promise((resolve, reject) => {
-        let data = '';
-        process.stdin.setEncoding('utf8');
-        process.stdin.on('data', (chunk) => {
-            data += chunk;
-        });
-        process.stdin.on('end', () => resolve(data));
-        process.stdin.on('error', reject);
-    });
-}
-function readJsonFile(path) {
-    try {
-        return readFileSync(path, 'utf8');
-    }
-    catch (error) {
-        throw new WorkCommitValidationError(`Cannot read JSON request file ${path}: ${error.message}`);
-    }
-}
-function parseJsonValue(raw, label) {
-    try {
-        return JSON.parse(raw);
-    }
-    catch (error) {
-        throw new WorkCommitValidationError(`${label} must contain valid JSON: ${error.message}`);
-    }
-}
-function hasSimpleChangeFlags(flags) {
-    return (flags.action !== undefined ||
-        flags['metadata-category'] !== undefined ||
-        flags['metadata-message'] !== undefined ||
-        flags['metadata-name'] !== undefined ||
-        flags['metadata-raw-json'] !== undefined ||
-        flags['metadata-type'] !== undefined ||
-        flags.selection !== undefined);
-}
-function simpleInputFromFlags(flags) {
-    const rawJson = flags['metadata-raw-json'] === undefined
-        ? undefined
-        : parseJsonValue(flags['metadata-raw-json'], '--metadata-raw-json');
-    return {
-        baseBranch: flags['base-branch'] ?? null,
-        changes: [
-            {
-                ...(flags.action === undefined ? {} : { a: flags.action }),
-                ...(flags['metadata-category'] === undefined ? {} : { c: flags['metadata-category'] }),
-                ...(rawJson === undefined ? {} : { j: rawJson }),
-                ...(flags['metadata-message'] === undefined ? {} : { m: flags['metadata-message'] }),
-                n: flags['metadata-name'],
-                ...(flags.selection === undefined ? {} : { selections: flags.selection }),
-                t: flags['metadata-type'],
-            },
-        ],
-        commitId: flags['commit-id'],
-        executeCommit: flags['execute-commit'],
-        message: flags.message,
-        recreateFeatureBranch: flags['recreate-feature-branch'],
-    };
-}
-async function jsonInputFromFlags(flags) {
-    const raw = flags.file === undefined ? await readStdin() : readJsonFile(flags.file);
-    const input = normalizeWorkCommitInput(parseJsonValue(raw, flags.file === undefined ? 'stdin' : flags.file));
-    return {
-        ...input,
-        ...(flags['base-branch'] === undefined ? {} : { baseBranch: flags['base-branch'] }),
-        ...(flags['commit-id'] === undefined ? {} : { commitId: flags['commit-id'] }),
-        ...(flags['execute-commit'] ? {} : { executeCommit: false }),
-        ...(flags.message === undefined ? {} : { message: flags.message }),
-        ...(flags['recreate-feature-branch'] ? { recreateFeatureBranch: true } : {}),
-    };
-}
-async function commitInputFromFlags(flags) {
-    const jsonModes = [flags.file !== undefined, flags.stdin].filter(Boolean).length;
-    const simpleMode = hasSimpleChangeFlags(flags);
-    if (jsonModes > 1) {
-        throw new WorkCommitValidationError('Use only one JSON input mode: --file or --stdin.');
-    }
-    if (jsonModes > 0 && simpleMode) {
-        throw new WorkCommitValidationError('Use JSON input or simple metadata flags, not both.');
-    }
-    if (jsonModes > 0) {
-        return jsonInputFromFlags(flags);
-    }
-    if (!simpleMode) {
-        throw new WorkCommitValidationError('Requires simple metadata flags such as --metadata-name and --metadata-type, or JSON input with --file/--stdin.');
-    }
-    return simpleInputFromFlags(flags);
-}
-export default class WorkCommit extends AgentiaCommand {
-    static args = {
-        id: Args.string({
-            description: 'User story ID (defaults to the active work item from `work set`)',
-            required: false,
-        }),
-    };
+import CloudCommit from '../cloud/commit.js';
+/**
+ * Compatibility alias of `cicd cloud commit`.
+ * Prefer `agentia cicd cloud commit` in scripts and docs.
+ */
+export default class WorkCommit extends CloudCommit {
     static description = [
+        'Compatibility alias of cicd cloud commit.',
         'Create a Copado cloud metadata commit for a user story.',
-        'Requires --cloud: preflights the story, submits POST /release/commit, and polls the job monitor by default.',
-        'For local Git work, use git add/commit then `cicd work publish`. Permission and full-metadata selections belong on `cicd work publish`.',
+        'Prefer: agentia cicd cloud commit.',
     ].join(' ');
     static examples = [
+        '<%= config.bin %> cicd cloud commit --message "Commit AccountService" --metadata-name AccountService --metadata-type ApexClass --metadata-category SFDX --action Add',
         '<%= config.bin %> <%= command.id %> --cloud --message "Commit AccountService" --metadata-name AccountService --metadata-type ApexClass --metadata-category SFDX --action Add',
-        '<%= config.bin %> <%= command.id %> a07XXXXXXXXXXXXXXX --cloud --message "Update Aura files" --metadata-name accountEditor --metadata-type AuraDefinitionBundle --metadata-category SFDX --action SelectiveCommit --selection accountEditor/accountEditor.cmp --selection accountEditor/accountEditorController.js',
-        '<%= config.bin %> <%= command.id %> --cloud --file commit-request.json  # {"message":"Commit AccountService","changes":[{"a":"Add","c":"SFDX","n":"AccountService","t":"ApexClass"}]}',
-        'cat commit-request.json | <%= config.bin %> <%= command.id %> --cloud --stdin --json',
     ];
-    static flags = {
-        action: Flags.string({
-            description: 'Metadata action for simple flag input. Defaults to Add.',
-            options: [...WORK_COMMIT_ACTIONS],
-        }),
-        'base-branch': Flags.string({
-            description: 'Optional base branch to include in the commit request.',
-        }),
-        cloud: Flags.boolean({
-            default: false,
-            description: 'Create a Copado cloud metadata commit (POST /release/commit). Required. For local Git work, use git commit then `cicd work publish`.',
-        }),
-        'commit-id': Flags.string({
-            description: 'Existing local Git commit identifier to register when --no-execute-commit is used.',
-        }),
-        'execute-commit': Flags.boolean({
-            allowNo: true,
-            default: true,
-            description: 'Execute the Copado commit job. Use --no-execute-commit only with --commit-id.',
-        }),
-        file: Flags.string({
-            char: 'f',
-            description: 'Path to a JSON commit request body.',
-        }),
-        message: Flags.string({
-            char: 'm',
-            description: 'Commit message. Required unless provided by JSON input.',
-        }),
-        'metadata-category': Flags.string({
-            description: WORK_COMMIT_METADATA_CATEGORY_HELP,
-        }),
-        'metadata-message': Flags.string({
-            description: 'Optional per-change message for simple flag input.',
-        }),
-        'metadata-name': Flags.string({
-            description: 'Metadata full name for simple flag input.',
-        }),
-        'metadata-raw-json': Flags.string({
-            description: 'Optional raw metadata JSON value for simple flag input.',
-        }),
-        'metadata-type': Flags.string({
-            description: 'Metadata type for simple flag input, for example ApexClass.',
-        }),
-        'recreate-feature-branch': Flags.boolean({
-            default: false,
-            description: 'Ask Copado to recreate the feature branch before committing.',
-        }),
-        selection: Flags.string({
-            description: 'Selected file inside a bundle for SelectiveCommit. Can be provided multiple times.',
-            multiple: true,
-        }),
-        stdin: Flags.boolean({
-            default: false,
-            description: 'Read a JSON commit request body from stdin.',
-        }),
-        wait: Flags.boolean({
-            allowNo: true,
-            default: true,
-            description: 'Poll the commit job to a terminal status when a jobExecution Id is returned.',
-        }),
-        'wait-timeout': Flags.integer({
-            default: WORK_COMMIT_DEFAULT_TIMEOUT_SECONDS,
-            description: 'Maximum seconds to wait for the commit job.',
-        }),
-    };
-    async run() {
-        const { args, flags, metadata } = await this.parse(WorkCommit);
-        const commitFlags = flags;
-        const flagMetadata = metadata;
-        // Local git commit (`--local`, `--permissions`, `--full-metadata`) is not exposed.
-        // Implementation remains in runLocalCommit / src/lib/work-local-commit.ts.
-        if (!commitFlags.cloud) {
-            this.error('This command creates Copado cloud metadata commits. For local Git work, use git commit then `cicd work publish`. Pass --cloud for a Copado cloud commit. Permission and full-metadata selections belong on `cicd work publish`.', {
-                exit: 2,
-                suggestions: [
-                    'git add -A && git commit',
-                    `${this.config.bin} cicd work publish`,
-                    `${this.config.bin} cicd work commit --cloud --message "<message>" --metadata-name <name> --metadata-type <type> --metadata-category SFDX`,
-                ],
-            });
-        }
-        const localOnly = providedFlags(LOCAL_ONLY_FLAGS, flags, flagMetadata);
-        if (localOnly.length > 0) {
-            this.error(`Cloud commit does not support ${localOnly.map((name) => `--${name}`).join(', ')}.`, {
-                exit: 2,
-                suggestions: [`${this.config.bin} cicd work publish`],
-            });
-        }
-        if (!Number.isInteger(commitFlags['wait-timeout']) || commitFlags['wait-timeout'] <= 0) {
-            this.error('--wait-timeout must be a positive integer.', { exit: 2 });
-        }
-        let workItemId;
-        try {
-            workItemId = await resolveWorkItemId(args.id);
-        }
-        catch (error) {
-            if (error instanceof WorkActiveResolutionError) {
-                this.error(error.message, {
-                    exit: 1,
-                    suggestions: [`${this.config.bin} cicd work set <id>`],
-                });
-            }
-            throw error;
-        }
-        try {
-            const input = await commitInputFromFlags(commitFlags);
-            const request = buildWorkCommitRequest(input, { message: commitFlags.message, userStoryId: workItemId });
-            const initialPlatformExperience = await resolveWorkCommitPlatformExperience({
-                userStoryId: workItemId,
-            });
-            const result = await performWorkCommit({
-                hooks: {
-                    log: (message) => this.display(() => this.log(message)),
-                    withSpinner: (message, action) => this.withSpinner(message, action),
-                },
-                initialPlatformExperience,
-                request,
-                timeoutSeconds: commitFlags['wait-timeout'],
-                wait: commitFlags.wait,
-            });
-            this.display(() => {
-                this.log(formatWorkCommitResult(result));
-            });
-            return result;
-        }
-        catch (error) {
-            if (error instanceof WorkCommitValidationError) {
-                this.error(error.message, { exit: 2 });
-            }
-            if (error instanceof WorkCommitJobFailedError || error instanceof WorkCommitTimeoutError) {
-                this.display(() => {
-                    if (error.result !== undefined) {
-                        this.log(formatWorkCommitResult(error.result));
-                    }
-                });
-                error.oclif = { exit: 1 };
-                throw error;
-            }
-            throw error;
-        }
-    }
-    toErrorJson(err) {
-        const base = super.toErrorJson(err);
-        if (err instanceof WorkCommitJobFailedError || err instanceof WorkCommitTimeoutError) {
-            return {
-                ...base,
-                error: {
-                    ...(base.error && typeof base.error === 'object' ? base.error : {}),
-                    ...(err.jobMonitor === undefined ? {} : { jobMonitor: err.jobMonitor }),
-                    ...(err.result === undefined ? {} : { result: err.result }),
-                },
-            };
-        }
-        return base;
-    }
-    // Local git commit path remains implemented but is not exposed on this command.
-    async runLocalCommit(id, commitFlags, flagMetadata) {
-        const cloudOnly = providedFlags(CLOUD_ONLY_FLAGS, commitFlags, flagMetadata);
-        if (id !== undefined) {
-            cloudOnly.unshift('<id>');
-        }
-        if (cloudOnly.length > 0) {
-            const unsupported = cloudOnly.map((name) => (name === '<id>' ? name : `--${name}`)).join(', ');
-            this.error(`Local commit does not support ${unsupported}.`, {
-                exit: 2,
-                suggestions: [`${this.config.bin} cicd work commit --cloud`],
-            });
-        }
-        try {
-            const result = await performWorkLocalCommit({
-                all: commitFlags.all === true,
-                ...(commitFlags['apex-test-classes'] === undefined
-                    ? {}
-                    : { apexTestClasses: commitFlags['apex-test-classes'] }),
-                ...(commitFlags['full-metadata'] === undefined ? {} : { fullMetadata: commitFlags['full-metadata'] }),
-                ...(commitFlags.message === undefined ? {} : { message: commitFlags.message }),
-                ...(commitFlags.permissions === undefined ? {} : { permissions: commitFlags.permissions }),
-            });
-            this.display(() => {
-                this.log(formatWorkLocalCommitResult(result));
-            });
-            return result;
-        }
-        catch (error) {
-            if (error instanceof WorkLocalCommitValidationError) {
-                this.error(error.message, {
-                    exit: error.exit,
-                    ...(error.suggestions === undefined ? {} : { suggestions: error.suggestions }),
-                });
-            }
-            throw error;
-        }
-    }
+    static hidden = true;
 }
 //# sourceMappingURL=commit.js.map

package/dist/commands/cicd/work/environment-sync.js

@@ -0,0 +1,120 @@
+import { Flags } from '@oclif/core';
+import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { assertEnvironmentSyncDestOrgSelector, formatWorkEnvironmentSyncResult, performWorkEnvironmentSync, WorkEnvironmentSyncConflictError, WorkEnvironmentSyncValidationError, } from '../../../lib/work-environment-sync.js';
+export default class WorkEnvironmentSync extends AgentiaCommand {
+    static description = [
+        'Sync committed metadata from the next environment onto the destination environment (or current feature branch).',
+        'Back-promotes every user story behind the destination environment from the next environment branch.',
+        'GET user stories ahead and behind. If none are behind, log that and stop. Otherwise create a back-promotion and POST those behind stories onto the promotion.',
+        'Resolves the next-environment Git branch from --destination-environment or --dev-org-branch (the dest pipeline connection destinationBranch, or that destination environment\'s outbound branch).',
+        'Merges origin/<next-env> with --no-ff --no-commit, restores every other path from HEAD, commits the guessed pathspecs,',
+        'and pushes the dest org branch (and the feature branch when HEAD starts with feature/).',
+        'If guessed pathspecs still conflict, PATCH the back-promotion status to Merge Conflict, resolve the files, and re-run with --promotion and --continue. The promotion destination environment supplies the dest org branch and the next-env branch.',
+        'To discard a conflicted merge, re-run with --promotion and --abort (runs git merge --abort and sets the back-promotion status to Draft).',
+        'After a successful sync, PATCH the back-promotion status to Completed.',
+    ].join(' ');
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --destination-environment=dev1',
+        '<%= config.bin %> <%= command.id %> --dev-org-branch=dev1-sfp',
+        '<%= config.bin %> <%= command.id %> --promotion=P29334 --continue',
+        '<%= config.bin %> <%= command.id %> --promotion=P29334 --abort',
+        '<%= config.bin %> <%= command.id %> --destination-environment=dev1 --json',
+    ];
+    static flags = {
+        abort: Flags.boolean({
+            default: false,
+            description: 'Abort an in-progress merge (`git merge --abort`) and set the back-promotion status to Draft. Requires --promotion. Exclusive with --continue.',
+            exclusive: ['continue'],
+        }),
+        continue: Flags.boolean({
+            default: false,
+            description: 'Commit resolved merge conflicts and finish the remaining environment-sync git steps.',
+            exclusive: ['abort'],
+        }),
+        'destination-credential': Flags.string({
+            description: 'Credential ID posted as destinationCredentialId when creating the back-promotion. Copado requires a credential on the next/source environment (PRO-033 if a dest/dev credential is sent) and then stores the dest/dev credential. Defaults to that source environment defaultCredential, otherwise the first source credential.',
+        }),
+        'destination-environment': Flags.string({
+            description: 'Destination org environment name or Id. Resolves to that environment\'s pipeline connection Git branch.',
+            exclusive: ['dev-org-branch'],
+        }),
+        'dev-org-branch': Flags.string({
+            description: 'Destination org Git branch. Defaults to lastDevOrgBranch from `cicd work set`.',
+            exclusive: ['destination-environment'],
+        }),
+        'pipeline-id': Flags.string({
+            description: 'Pipeline ID. Defaults to the active work item from `cicd work set`.',
+        }),
+        promotion: Flags.string({
+            description: 'Back-promotion Id or name to PATCH when this run stops on merge conflicts, finishes successfully, continues, or aborts. Included in the conflict continue and abort commands. Defaults to the back-promotion created in this run.',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(WorkEnvironmentSync);
+        try {
+            await assertEnvironmentSyncDestOrgSelector({
+                abort: flags.abort === true,
+                continue: flags.continue === true,
+                destinationEnvironment: flags['destination-environment'],
+                devOrgBranch: flags['dev-org-branch'],
+                promotion: flags.promotion,
+            });
+            const result = await performWorkEnvironmentSync({
+                abort: flags.abort === true,
+                cliBin: this.config.bin,
+                continue: flags.continue === true,
+                hooks: {
+                    log: (message) => {
+                        this.display(() => {
+                            this.log(message);
+                        });
+                    },
+                    withSpinner: (message, action) => this.withSpinner(message, action),
+                },
+                json: this.jsonEnabled(),
+                ...(flags['destination-credential'] === undefined
+                    ? {}
+                    : { destinationCredentialId: flags['destination-credential'] }),
+                ...(flags['destination-environment'] === undefined
+                    ? {}
+                    : { destinationEnvironment: flags['destination-environment'] }),
+                ...(flags['dev-org-branch'] === undefined ? {} : { devOrgBranch: flags['dev-org-branch'] }),
+                ...(flags['pipeline-id'] === undefined ? {} : { pipelineId: flags['pipeline-id'] }),
+                ...(flags.promotion === undefined ? {} : { promotion: flags.promotion }),
+            });
+            this.display(() => {
+                const formatted = formatWorkEnvironmentSyncResult(result);
+                if (formatted.length > 0) {
+                    this.log(formatted);
+                }
+            });
+            return result;
+        }
+        catch (error) {
+            if (error instanceof WorkEnvironmentSyncConflictError) {
+                const { suggestions } = error;
+                const suggestionOptions = suggestions === undefined ? {} : { suggestions };
+                if (this.jsonEnabled()) {
+                    const message = error.gitStatus === undefined || error.gitStatus.length === 0
+                        ? error.message
+                        : `${error.message}\n\n${error.gitStatus}`;
+                    this.error(message, { exit: error.exit, ...suggestionOptions });
+                }
+                this.error(error.message, { exit: false, ...suggestionOptions });
+                if (error.gitStatus !== undefined && error.gitStatus.length > 0) {
+                    this.log('');
+                    this.log(error.gitStatus);
+                }
+                this.exit(error.exit);
+            }
+            if (error instanceof WorkEnvironmentSyncValidationError) {
+                this.error(error.message, {
+                    exit: error.exit,
+                    ...(error.suggestions === undefined ? {} : { suggestions: error.suggestions }),
+                });
+            }
+            throw error;
+        }
+    }
+}
+//# sourceMappingURL=environment-sync.js.map

package/dist/commands/cicd/work/get.js

@@ -1,8 +1,9 @@
-import { Args } from '@oclif/core';
+import { Args, Flags } from '@oclif/core';
 import { AgentiaCommand } from '../../../lib/agentia-command.js';
 import { CicdGateway } from '../../../lib/cicd-gateway.js';
 import { resolveWorkItemId, WorkActiveResolutionError } from '../../../lib/work-active.js';
-import { formatUserStoryDetail, workEndpoint } from '../../../lib/work-types.js';
+import { formatUserStoriesAheadBehindLines, reportUserStoriesAheadBehindForStory, } from '../../../lib/work-submit-ahead-behind.js';
+import { formatUserStoryDetail, workEndpoint, } from '../../../lib/work-types.js';
 export default class WorkGet extends AgentiaCommand {
     static args = {
         id: Args.string({
@@ -15,9 +16,17 @@ export default class WorkGet extends AgentiaCommand {
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> a0SKC000000CmZ2AU',
         '<%= config.bin %> <%= command.id %> a0SKC000000CmZ2AU --json',
+        '<%= config.bin %> <%= command.id %> a0SKC000000CmZ2AU --user-stories-ahead-behind',
+        '<%= config.bin %> <%= command.id %> a0SKC000000CmZ2AU --user-stories-ahead-behind --json',
     ];
+    static flags = {
+        'user-stories-ahead-behind': Flags.boolean({
+            default: false,
+            description: 'When the user story has a pipeline and source environment, compare user stories ahead of and behind the next pipeline environment',
+        }),
+    };
     async run() {
-        const { args } = await this.parse(WorkGet);
+        const { args, flags } = await this.parse(WorkGet);
         let workItemId;
         try {
             workItemId = await resolveWorkItemId(args.id);
@@ -35,10 +44,22 @@ export default class WorkGet extends AgentiaCommand {
             endpoint: workEndpoint(workItemId),
             method: 'GET',
         }));
+        let userStoriesAheadBehind;
+        if (flags['user-stories-ahead-behind']) {
+            userStoriesAheadBehind = await reportUserStoriesAheadBehindForStory(userStory, {
+                warn: (message) => this.warn(message),
+            });
+        }
         this.display(() => {
             this.log(formatUserStoryDetail(userStory));
+            if (userStoriesAheadBehind !== undefined) {
+                this.log(formatUserStoriesAheadBehindLines(userStoriesAheadBehind));
+            }
         });
-        return userStory;
+        return {
+            ...userStory,
+            ...(userStoriesAheadBehind === undefined ? {} : { userStoriesAheadBehind }),
+        };
     }
 }
 //# sourceMappingURL=get.js.map