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

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

@@ -0,0 +1,252 @@
+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';
+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 CloudCommit extends AgentiaCommand {
+    static args = {
+        id: Args.string({
+            description: 'User story ID (defaults to the active work item from `work set`)',
+            required: false,
+        }),
+    };
+    static description = [
+        'Create a Copado cloud metadata commit for a user story.',
+        '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`.',
+    ].join(' ');
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --message "Commit AccountService" --metadata-name AccountService --metadata-type ApexClass --metadata-category SFDX --action Add',
+        '<%= config.bin %> <%= command.id %> a07XXXXXXXXXXXXXXX --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 %> --file commit-request.json  # {"message":"Commit AccountService","changes":[{"a":"Add","c":"SFDX","n":"AccountService","t":"ApexClass"}]}',
+        'cat commit-request.json | <%= config.bin %> <%= command.id %> --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: 'Ignored. Cloud is implied by cicd cloud commit.',
+            hidden: true,
+        }),
+        '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 } = await this.parse(CloudCommit);
+        const commitFlags = flags;
+        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;
+    }
+}
+//# sourceMappingURL=commit.js.map

package/dist/commands/cicd/cloud/promote.js

@@ -0,0 +1,139 @@
+import { confirm } from '@inquirer/prompts';
+import { Args, Flags } from '@oclif/core';
+import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { formatPromotionRunResult, isPromotionRunExecutionError, parseIgnoredMetadataJson, performPromotionRun, PROMOTION_RUN_DEFAULT_TIMEOUT_SECONDS, promotionRunErrorJson, PromotionRunValidationError, resolvePromotionIdForWorkItem, } from '../../../lib/promotion-run.js';
+import { resolveWorkItemId, WorkActiveResolutionError } from '../../../lib/work-active.js';
+export default class CloudPromote extends AgentiaCommand {
+    static args = {
+        id: Args.string({
+            description: 'User Story ID (defaults to the active work item from `work set`)',
+            required: false,
+        }),
+    };
+    static description = [
+        'Promote the explicit or active User Story through its Copado Promotion.',
+        'Selects promote-only unless --deploy is passed.',
+    ].join(' ');
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> a07XXXXXXXXXXXXXXX --promotion-id a0BXXXXXXXXXXXXXXX',
+        '<%= config.bin %> <%= command.id %> --deploy --json',
+    ];
+    static flags = {
+        cloud: Flags.boolean({
+            default: false,
+            description: 'Ignored. Cloud is implied by cicd cloud promote.',
+            hidden: true,
+        }),
+        deploy: Flags.boolean({
+            default: false,
+            description: 'Use merge_and_deploy instead of promote-only merge.',
+        }),
+        'deployment-step-id': Flags.string({
+            description: 'Ordered deployment-step Salesforce ID. Can be provided multiple times with --deploy.',
+            multiple: true,
+        }),
+        'ignored-metadata-json': Flags.string({
+            description: 'JSON array to persist through ignored-metadata before starting the promotion.',
+        }),
+        'promotion-id': Flags.string({
+            description: 'Explicit 18-character Promotion ID when the User Story belongs to multiple promotions.',
+        }),
+        'recreate-promotion-branch': Flags.boolean({
+            description: 'Recreate the promotion branch before execution. Requires confirmation or --yes.',
+        }),
+        wait: Flags.boolean({
+            allowNo: true,
+            default: true,
+            description: 'Poll promotion and deployment executions to terminal status.',
+        }),
+        'wait-timeout': Flags.integer({
+            default: PROMOTION_RUN_DEFAULT_TIMEOUT_SECONDS,
+            description: 'Maximum total seconds to wait for promotion and deployment executions.',
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            default: false,
+            description: 'Confirm promotion branch recreation without prompting.',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(CloudPromote);
+        const promoteFlags = flags;
+        if (!Number.isInteger(promoteFlags['wait-timeout']) || promoteFlags['wait-timeout'] <= 0) {
+            this.error('--wait-timeout must be a positive integer.', { exit: 2 });
+        }
+        if (!promoteFlags.deploy && promoteFlags['deployment-step-id'] !== undefined) {
+            this.error('--deployment-step-id requires --deploy.', { 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 promotionId = await this.withSpinner('Resolving User Story promotion', () => resolvePromotionIdForWorkItem(workItemId, promoteFlags['promotion-id']));
+            if (promoteFlags['recreate-promotion-branch'] === true && !promoteFlags.yes) {
+                if (this.jsonEnabled() || !process.stdin.isTTY) {
+                    this.error('Promotion branch recreation requires confirmation. Pass --yes for headless or JSON execution.', {
+                        exit: 2,
+                    });
+                }
+                const confirmed = await confirm({
+                    default: false,
+                    message: `Recreate the promotion branch for ${promotionId}? Existing promotion branch changes may be replaced.`,
+                });
+                if (!confirmed) {
+                    this.error('Promotion canceled.', { exit: 1 });
+                }
+            }
+            const result = await performPromotionRun({
+                deploymentStepIds: promoteFlags['deployment-step-id'],
+                hooks: {
+                    log: (message) => this.display(() => this.log(message)),
+                    withSpinner: (message, action) => this.withSpinner(message, action),
+                },
+                ignoredMetadata: parseIgnoredMetadataJson(promoteFlags['ignored-metadata-json']),
+                operation: promoteFlags.deploy ? 'merge_and_deploy' : 'merge',
+                promotionId,
+                recreatePromotionBranch: promoteFlags['recreate-promotion-branch'],
+                timeoutSeconds: promoteFlags['wait-timeout'],
+                wait: promoteFlags.wait,
+            });
+            const workResult = { ...result, workItemId };
+            this.display(() => {
+                this.log(`User Story: ${workItemId}`);
+                this.log(formatPromotionRunResult(result));
+            });
+            return workResult;
+        }
+        catch (error) {
+            if (error instanceof PromotionRunValidationError) {
+                this.error(error.message, { exit: 2 });
+            }
+            if (isPromotionRunExecutionError(error)) {
+                this.display(() => {
+                    if (error.result !== undefined) {
+                        this.log(`User Story: ${workItemId}`);
+                        this.log(formatPromotionRunResult(error.result));
+                    }
+                });
+                error.oclif = { exit: 1 };
+            }
+            throw error;
+        }
+    }
+    toErrorJson(err) {
+        const base = super.toErrorJson(err);
+        return promotionRunErrorJson(base, err);
+    }
+}
+//# sourceMappingURL=promote.js.map

package/dist/commands/cicd/health-check.js

@@ -0,0 +1,77 @@
+import { Flags, ux } from '@oclif/core';
+import { AgentiaCommand } from '../../lib/agentia-command.js';
+import { table } from '../../lib/format.js';
+import { analyzeGitRepository, gitSizerRows } from '../../lib/git-sizer.js';
+import { runOrganizationHealthChecks, } from '../../lib/health-check.js';
+function displayStatus(status) {
+    const label = status.toUpperCase();
+    switch (status) {
+        case 'fail': {
+            return ux.colorize('red', label);
+        }
+        case 'pass': {
+            return ux.colorize('green', label);
+        }
+        case 'warn': {
+            return ux.colorize('yellow', label);
+        }
+        default: {
+            return label;
+        }
+    }
+}
+export default class HealthCheck extends AgentiaCommand {
+    static description = 'Run organization-scoped governance health checks';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --json',
+        '<%= config.bin %> <%= command.id %> --git-sizer',
+        '<%= config.bin %> <%= command.id %> --git-sizer --path /path/to/clone',
+    ];
+    static flags = {
+        'git-sizer': Flags.boolean({
+            default: false,
+            description: 'Also analyze a local Git clone with git-sizer',
+        }),
+        path: Flags.string({
+            dependsOn: ['git-sizer'],
+            description: 'Local Git clone for --git-sizer. Defaults to the current directory.',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(HealthCheck);
+        const result = await this.withSpinner('Running organization health checks', runOrganizationHealthChecks);
+        if (flags['git-sizer']) {
+            result.gitSizer = await analyzeGitRepository({ repoPath: flags.path });
+        }
+        this.display(() => {
+            this.log(table([
+                { alias: 'Status', value: 'status' },
+                { alias: 'Check', value: 'name' },
+                { alias: 'Severity', value: 'severity' },
+                { alias: 'Impact', value: 'impact', wrap: true },
+            ], result.checks.map((check) => ({ ...check, status: displayStatus(check.status) }))));
+            this.log(`Summary: ${result.summary.total} total, ${result.summary.pass} pass, ` +
+                `${result.summary.warn} warn, ${result.summary.fail} fail`);
+            if (result.gitSizer) {
+                this.logGitSizer(result.gitSizer);
+            }
+        });
+        return result;
+    }
+    logGitSizer(report) {
+        this.log('');
+        this.log(`Git repository size (${report.path})`);
+        if (report.status !== 'ok' || !report.metrics) {
+            this.log(report.message ?? `git-sizer ${report.status}`);
+            return;
+        }
+        this.log(table([
+            { alias: 'Metric', value: 'description', wrap: true },
+            { alias: 'Value', value: 'value' },
+            { alias: 'Unit', value: 'unit' },
+            { alias: 'Concern', value: 'levelOfConcern' },
+        ], gitSizerRows(report.metrics)));
+    }
+}
+//# sourceMappingURL=health-check.js.map