@copado/agentia-cli 1.0.0 → 1.2.0

package/dist/commands/cicd/extension/install.js

@@ -0,0 +1,127 @@
+import { confirm } from '@inquirer/prompts';
+import { Args, Flags } from '@oclif/core';
+import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { installExtension } from '../../../lib/extension/install.js';
+import { parseVersionFromRef, versionTagName } from '../../../lib/extension/manifest.js';
+export default class ExtensionInstall extends AgentiaCommand {
+    static args = {
+        source: Args.string({
+            description: 'Git repository URL, owner/repo slug, or local directory path',
+            required: false,
+        }),
+    };
+    static description = 'Install a Copado extension from a git URL or local folder: upsert functions and job templates via the CICD Gateway; deploy force-app with Salesforce CLI unless excluded';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> https://gitlab.com/org/my-ext.git --version 1.2.0 --yes',
+        '<%= config.bin %> <%= command.id %> ./my-extension --version 0.1.0 --exclude-sf-deploy --yes',
+        '<%= config.bin %> <%= command.id %> /tmp/my-extension.git --ref v0.1.0 --sf-alias destOrg --yes',
+        '<%= config.bin %> <%= command.id %> ./my-extension --version 1.2.0 --exclude-sf-deploy --yes --json',
+    ];
+    static experimental = true;
+    static flags = {
+        'dry-run': Flags.boolean({
+            default: false,
+            description: 'Materialize and validate, print the install plan, but do not upsert or deploy',
+        }),
+        'exclude-sf-deploy': Flags.boolean({
+            default: false,
+            description: 'Skip Salesforce metadata deploy even when force-app is present',
+        }),
+        'ignore-unknown-assets': Flags.boolean({
+            default: false,
+            description: 'Ignore unsupported manifest asset arrays instead of failing',
+        }),
+        ref: Flags.string({
+            description: 'Git ref to install (tag, branch, or commit). Prefer --version for semver tags.',
+            required: false,
+        }),
+        'sf-alias': Flags.string({
+            description: 'Salesforce CLI org alias or username for force-app deploy (required when force-app is present unless --exclude-sf-deploy)',
+            required: false,
+        }),
+        source: Flags.string({
+            description: 'Git URL or local path (alternative to the positional source argument)',
+            required: false,
+        }),
+        url: Flags.string({
+            description: 'Deprecated alias of --source',
+            hidden: true,
+            required: false,
+        }),
+        version: Flags.string({
+            description: 'Semver version to install (checks out tag vX.Y.Z)',
+            required: false,
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            default: false,
+            description: 'Skip the interactive confirmation prompt (required for non-interactive / --json installs that are not --dry-run)',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ExtensionInstall);
+        const source = flags.source ?? flags.url ?? args.source;
+        if (source === undefined || source.trim().length === 0) {
+            this.error('Provide a git URL or local path as a positional argument or --source.', { exit: 2 });
+        }
+        await this.confirmInstallIfNeeded(source.trim(), {
+            dryRun: flags['dry-run'],
+            ref: flags.ref,
+            version: flags.version,
+            yes: flags.yes,
+        });
+        let result;
+        try {
+            result = await this.withSpinner('Installing extension', () => installExtension({
+                dryRun: flags['dry-run'],
+                excludeSfDeploy: flags['exclude-sf-deploy'],
+                ignoreUnknownAssets: flags['ignore-unknown-assets'],
+                ref: flags.ref,
+                sfAlias: flags['sf-alias'],
+                source,
+                version: flags.version,
+                // Confirmation already handled above (or skipped for --yes / --dry-run).
+                yes: true,
+            }));
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error), { exit: 1 });
+        }
+        this.display(() => {
+            this.log(`${result.dryRun ? 'Dry-run install plan for' : 'Installed'} ${result.manifest.name}${result.manifest.version === undefined ? '' : `@${result.manifest.version}`}`);
+            this.log(`Source: ${result.source} (${result.ref})`);
+            this.log(`Functions: ${result.functions.map((item) => item.apiName).join(', ') || '(none)'}`);
+            this.log(`Templates: ${result.templates.map((item) => item.apiName).join(', ') || '(none)'}`);
+            if (result.forceAppDeployed) {
+                this.log('Salesforce source: deployed');
+            }
+            else if (result.salesforceSkipped) {
+                this.log('Salesforce source: skipped');
+            }
+        });
+        return result;
+    }
+    async confirmInstallIfNeeded(source, flags) {
+        if (flags.yes === true || flags.dryRun === true)
+            return;
+        const refLabel = this.resolveRefLabel(flags.ref, flags.version);
+        const message = `Install Copado extension from untrusted source ${source} (${refLabel})?`;
+        if (this.jsonEnabled()) {
+            this.error(`${message} Re-run with --yes to confirm.`, { exit: 1 });
+        }
+        const accepted = await confirm({ default: false, message });
+        if (!accepted) {
+            this.error('Extension install cancelled.', { exit: 1 });
+        }
+    }
+    resolveRefLabel(ref, version) {
+        if (ref !== undefined && ref.trim().length > 0)
+            return ref.trim();
+        if (version !== undefined && version.trim().length > 0) {
+            const parsed = parseVersionFromRef(version) ?? version.trim();
+            return versionTagName(parsed);
+        }
+        return 'default branch / latest tag / local folder';
+    }
+}
+//# sourceMappingURL=install.js.map

package/dist/commands/cicd/extension/package.js

@@ -0,0 +1,35 @@
+import { Flags } from '@oclif/core';
+import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { packageExtension } from '../../../lib/extension/package.js';
+export default class ExtensionPackage extends AgentiaCommand {
+    static description = 'Validate a Copado extension for publish (requires semver version; optional --version bump)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --version 1.2.0 --json',
+    ];
+    static experimental = true;
+    static flags = {
+        version: Flags.string({
+            description: 'Set or bump the manifest semver version before validating',
+            required: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ExtensionPackage);
+        let result;
+        try {
+            result = await packageExtension({ version: flags.version });
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error), { exit: 1 });
+        }
+        this.display(() => {
+            this.log(`Packaged extension ${result.manifest.name}@${result.manifest.version}`);
+            this.log(`Functions: ${(result.manifest.functions ?? []).length}`);
+            this.log(`Templates: ${(result.manifest.templates ?? []).length}`);
+            this.log(`Salesforce source: ${result.validation.forceAppPresent ? result.validation.salesforceSourceDir : '(none)'}`);
+        });
+        return { manifest: result.manifest };
+    }
+}
+//# sourceMappingURL=package.js.map

package/dist/commands/cicd/extension/publish.js

@@ -0,0 +1,61 @@
+import { Flags } from '@oclif/core';
+import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { publishExtension } from '../../../lib/extension/publish.js';
+export default class ExtensionPublish extends AgentiaCommand {
+    static description = 'Push the current extension commit and create an annotated semver git tag (vX.Y.Z) for install pinning';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --version 1.2.0 --remote origin --json',
+        '<%= config.bin %> <%= command.id %> --version 0.1.0 --local --force',
+    ];
+    static experimental = true;
+    static flags = {
+        'allow-dirty': Flags.boolean({
+            description: 'Allow publish with a dirty working tree',
+            default: false,
+        }),
+        force: Flags.boolean({
+            description: 'Recreate the local tag and push even if the tag already exists',
+            default: false,
+        }),
+        local: Flags.boolean({
+            description: 'Create the annotated tag locally without pushing to a remote (offline / local e2e)',
+            default: false,
+        }),
+        remote: Flags.string({
+            description: 'Git remote to push (default origin; ignored with --local)',
+            default: 'origin',
+        }),
+        version: Flags.string({
+            description: 'Require this semver in the manifest before tagging (writes it only if already committed; fails if the bump is uncommitted)',
+            required: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ExtensionPublish);
+        let result;
+        try {
+            result = await this.withSpinner('Publishing extension', () => publishExtension({
+                allowDirty: flags['allow-dirty'],
+                force: flags.force,
+                local: flags.local,
+                remote: flags.remote,
+                version: flags.version,
+            }));
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error), { exit: 1 });
+        }
+        this.display(() => {
+            this.log(`Published ${result.manifest.name}@${result.manifest.version}${result.localOnly ? ' (local tag only)' : ''}`);
+            if (result.remote !== undefined)
+                this.log(`Remote: ${result.remote}`);
+            this.log(`Branch: ${result.branch}`);
+            this.log(`Commit: ${result.commit}`);
+            this.log(`Tag: ${result.tag}`);
+            this.log(`Install: ${result.installCommand}`);
+        });
+        return result;
+    }
+}
+//# sourceMappingURL=publish.js.map

package/dist/commands/cicd/extension/uninstall.js

@@ -0,0 +1,99 @@
+import { confirm } from '@inquirer/prompts';
+import { Args, Flags } from '@oclif/core';
+import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { parseVersionFromRef, versionTagName } from '../../../lib/extension/manifest.js';
+import { uninstallExtension } from '../../../lib/extension/uninstall.js';
+export default class ExtensionUninstall extends AgentiaCommand {
+    static args = {
+        source: Args.string({
+            description: 'Git repository URL, owner/repo slug, or local directory path',
+            required: false,
+        }),
+    };
+    static description = 'Uninstall a Copado extension by deleting the functions and job templates listed in its manifest from the authenticated Copado org';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> ./my-extension --version 0.1.0 --yes',
+        '<%= config.bin %> <%= command.id %> https://gitlab.com/org/my-ext.git --ref v0.1.0 --yes --json',
+    ];
+    static experimental = true;
+    static flags = {
+        'dry-run': Flags.boolean({
+            default: false,
+            description: 'Show which assets would be deleted without calling the gateway',
+        }),
+        ref: Flags.string({
+            description: 'Git ref to read the manifest from',
+            required: false,
+        }),
+        source: Flags.string({
+            description: 'Git URL or local path (alternative to the positional source argument)',
+            required: false,
+        }),
+        version: Flags.string({
+            description: 'Semver version whose tag (vX.Y.Z) supplies the manifest',
+            required: false,
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            default: false,
+            description: 'Skip the interactive confirmation prompt (required for non-interactive / --json uninstalls that are not --dry-run)',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ExtensionUninstall);
+        const source = flags.source ?? args.source;
+        if (source === undefined || source.trim().length === 0) {
+            this.error('Provide a git URL or local path as a positional argument or --source.', { exit: 2 });
+        }
+        await this.confirmUninstallIfNeeded(source.trim(), {
+            dryRun: flags['dry-run'],
+            ref: flags.ref,
+            version: flags.version,
+            yes: flags.yes,
+        });
+        let result;
+        try {
+            result = await this.withSpinner('Uninstalling extension', () => uninstallExtension({
+                dryRun: flags['dry-run'],
+                ref: flags.ref,
+                source,
+                version: flags.version,
+                // Confirmation already handled above (or skipped for --yes / --dry-run).
+                yes: true,
+            }));
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error), { exit: 1 });
+        }
+        this.display(() => {
+            this.log(`${result.dryRun ? 'Dry-run uninstall plan for' : 'Uninstalled'} ${result.manifest.name}${result.manifest.version === undefined ? '' : `@${result.manifest.version}`}`);
+            this.log(`Source: ${result.source} (${result.ref})`);
+            this.log(`Functions: ${result.functions.map((item) => `${item.apiName}${item.deleted ? '' : ' (failed)'}`).join(', ') || '(none)'}`);
+            this.log(`Templates: ${result.templates.map((item) => `${item.apiName}${item.deleted ? '' : ' (failed)'}`).join(', ') || '(none)'}`);
+        });
+        return result;
+    }
+    async confirmUninstallIfNeeded(source, flags) {
+        if (flags.yes === true || flags.dryRun === true)
+            return;
+        const refLabel = this.resolveRefLabel(flags.ref, flags.version);
+        const message = `Uninstall Copado extension from ${source} (${refLabel})? This deletes listed functions and job templates from the authenticated Copado org.`;
+        if (this.jsonEnabled()) {
+            this.error(`${message} Re-run with --yes to confirm.`, { exit: 1 });
+        }
+        const accepted = await confirm({ default: false, message });
+        if (!accepted) {
+            this.error('Extension uninstall cancelled.', { exit: 1 });
+        }
+    }
+    resolveRefLabel(ref, version) {
+        if (ref !== undefined && ref.trim().length > 0)
+            return ref.trim();
+        if (version !== undefined && version.trim().length > 0) {
+            const parsed = parseVersionFromRef(version) ?? version.trim();
+            return versionTagName(parsed);
+        }
+        return 'default branch / latest tag / local folder';
+    }
+}
+//# sourceMappingURL=uninstall.js.map

package/dist/commands/cicd/extension/validate.js

@@ -0,0 +1,47 @@
+import { Flags } from '@oclif/core';
+import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { validateExtension } from '../../../lib/extension/manifest.js';
+export default class ExtensionValidate extends AgentiaCommand {
+    static description = 'Validate a Copado extension manifest against copado/functions and copado/templates on disk';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --require-version --json',
+    ];
+    static experimental = true;
+    static flags = {
+        'require-version': Flags.boolean({
+            description: 'Require a semver version field (needed for package/publish)',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ExtensionValidate);
+        let result;
+        try {
+            result = await validateExtension(process.cwd(), { requireVersion: flags['require-version'] });
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error), { exit: 2 });
+        }
+        this.display(() => {
+            this.log(`Extension: ${result.manifest.name}`);
+            if (result.manifest.version !== undefined)
+                this.log(`Version: ${result.manifest.version}`);
+            this.log(`Salesforce source present: ${result.forceAppPresent ? 'yes' : 'no'} (${result.salesforceSourceDir})`);
+            if (result.ok) {
+                this.log('Validation passed.');
+            }
+            else {
+                this.log('Validation failed:');
+                for (const issue of result.issues) {
+                    this.log(`- ${issue.message}`);
+                }
+            }
+        });
+        if (!result.ok) {
+            this.error('Extension validation failed.', { exit: 1 });
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=validate.js.map

package/dist/commands/cicd/extension-configuration/get.js

@@ -0,0 +1,24 @@
+import { Args } from '@oclif/core';
+import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { fetchExtensionConfiguration } from '../../../lib/extension-configuration-ops.js';
+import { formatExtensionConfigurationDetail, } from '../../../lib/extension-configuration-types.js';
+export default class ExtensionConfigurationGet extends AgentiaCommand {
+    static args = {
+        id: Args.string({
+            description: 'Extension configuration ID or name',
+            required: true,
+        }),
+    };
+    static description = 'Get a Copado extension configuration';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> <configuration-id>',
+        '<%= config.bin %> <%= command.id %> <configuration-id> --json',
+    ];
+    async run() {
+        const { args } = await this.parse(ExtensionConfigurationGet);
+        const configuration = await this.withSpinner('Fetching extension configuration', () => fetchExtensionConfiguration(args.id));
+        this.display(() => this.log(formatExtensionConfigurationDetail(configuration)));
+        return configuration;
+    }
+}
+//# sourceMappingURL=get.js.map

package/dist/commands/cicd/extension-configuration/list.js

@@ -0,0 +1,49 @@
+import { Flags } from '@oclif/core';
+import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { fetchExtensionConfigurations } from '../../../lib/extension-configuration-ops.js';
+import { formatExtensionConfigurationTable, } from '../../../lib/extension-configuration-types.js';
+import { displayListPagination, listPaginationFlags } from '../../../lib/list-pagination.js';
+export default class ExtensionConfigurationList extends AgentiaCommand {
+    static description = 'List Copado extension configurations';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --tool Selenium --active --json',
+    ];
+    static flags = {
+        ...listPaginationFlags,
+        active: Flags.boolean({
+            allowNo: true,
+            description: 'Filter by active status',
+        }),
+        name: Flags.string({
+            description: 'Filter by extension configuration name',
+        }),
+        'test-type': Flags.string({
+            description: 'Filter by test type',
+        }),
+        tool: Flags.string({
+            description: 'Filter by extension tool',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ExtensionConfigurationList);
+        const page = await this.withSpinner('Fetching extension configurations', () => fetchExtensionConfigurations({
+            active: flags.active,
+            cursor: flags.cursor,
+            name: flags.name,
+            pageSize: flags['page-size'],
+            testType: flags['test-type'],
+            tool: flags.tool,
+        }));
+        this.display(() => {
+            if (page.data.length === 0) {
+                this.log('No extension configurations found.');
+                return;
+            }
+            this.log(formatExtensionConfigurationTable(page.data));
+            displayListPagination(this.log.bind(this), page);
+        });
+        return page;
+    }
+}
+//# sourceMappingURL=list.js.map

package/dist/commands/cicd/extension-configuration/open.js

@@ -0,0 +1,38 @@
+import { Args } from '@oclif/core';
+import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { openNavigationTarget } from '../../../lib/navigation-open.js';
+import { resolveNavigationTarget } from '../../../lib/navigation.js';
+import { assertSalesforceLifecycleId } from '../../../lib/pipeline-lifecycle-id.js';
+export default class ExtensionConfigurationOpen extends AgentiaCommand {
+    static args = {
+        id: Args.string({
+            description: 'Extension configuration Salesforce ID',
+            required: true,
+        }),
+    };
+    static description = 'Open a Copado extension configuration in the browser';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> <configuration-id>',
+        '<%= config.bin %> <%= command.id %> <configuration-id> --json',
+    ];
+    async run() {
+        const { args } = await this.parse(ExtensionConfigurationOpen);
+        let configurationId;
+        try {
+            configurationId = assertSalesforceLifecycleId(args.id, 'Extension configuration ID');
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error), { exit: 2 });
+        }
+        const target = await this.withSpinner('Resolving navigation URL', () => resolveNavigationTarget({
+            id: configurationId,
+            resourceType: 'extension_configuration',
+        }));
+        await openNavigationTarget(target, {
+            jsonEnabled: this.jsonEnabled(),
+            log: this.log.bind(this),
+        });
+        return target;
+    }
+}
+//# sourceMappingURL=open.js.map

package/dist/commands/cicd/metadata/content/get.js

@@ -59,7 +59,7 @@ export function buildMetadataContentRequests(flags) {
     return [buildMetadataContentRequest(flags)];
 }
 export default class MetadataContent extends AgentiaCommand {
-    static description = 'Retrieve metadata file content via the CICD gateway';
+    static description = 'Retrieve metadata file content';
     static examples = [
         '<%= config.bin %> <%= command.id %> --metadata-type ApexClass --api-name MyClass --pipeline-id <id> --source-org-id <id>',
         '<%= config.bin %> <%= command.id %> --metadata-type ApexClass --api-name MyClass --show',

package/dist/commands/cicd/metadata/dependency/list.js

@@ -199,7 +199,7 @@ async function enrichDependencyResult(result, localPathsBySelection, moduleType)
     };
 }
 export default class DependencyGet extends AgentiaCommand {
-    static description = 'Retrieve metadata dependencies via the CICD gateway';
+    static description = 'Retrieve metadata dependencies';
     static examples = [
         '<%= config.bin %> <%= command.id %> --metadata-name MyClass --metadata-type ApexClass --pipeline-id <id> --source-org-id <id> --source-credential-id <id>',
         'cat request.json | <%= config.bin %> <%= command.id %> --stdin',
@@ -239,7 +239,7 @@ export default class DependencyGet extends AgentiaCommand {
         }),
         'platform-experience': Flags.string({
             default: 'salesforce',
-            description: 'Gateway platform experience header',
+            description: 'Platform experience header',
             options: [...PLATFORM_EXPERIENCES],
         }),
         'result-id': Flags.string({

package/dist/commands/cicd/metadata/explore.js

@@ -0,0 +1,81 @@
+import { Flags } from '@oclif/core';
+import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { AI_METADATA_ACTIONS, buildAiMetadataToolRequest, callAiMetadataTool, } from '../../../lib/metadata-explore.js';
+export default class MetadataExplore extends AgentiaCommand {
+    static description = [
+        'Explore Salesforce metadata through Org Intelligence.',
+        'Uses the project default credential when --credential-id is omitted;',
+        'otherwise pass --credential-id, or both --session-id and --endpoint.',
+    ].join(' ');
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --action list --object-type ApexClass',
+        "<%= config.bin %> <%= command.id %> --action list --object-type ApexClass --pattern 'Account*'",
+        '<%= config.bin %> <%= command.id %> --action read --object-type ApexClass --full-name MyClass',
+        '<%= config.bin %> <%= command.id %> --action find_references --object-type ApexClass --full-name MyClass',
+        "<%= config.bin %> <%= command.id %> --action search --pattern 'Cont*' --credential-id <id>",
+        '<%= config.bin %> <%= command.id %> --action describe_type --object-type CustomObject --json',
+    ];
+    static experimental = true;
+    static flags = {
+        action: Flags.string({
+            description: 'Metadata action: list, search, read_documentation, describe_type, read, find_references, run_apex_tests',
+            options: [...AI_METADATA_ACTIONS],
+            required: true,
+        }),
+        'apex-unit-tests': Flags.string({
+            description: 'Comma-separated Apex test classes. Required for run_apex_tests.',
+        }),
+        // Deferred write/deploy flags (re-add with matching AI_METADATA_ACTIONS when shipping mutate):
+        // 'async-id': Flags.string({
+        //   description: 'Deployment Id from a previous validate/deploy for deploy_validated or check_async_id',
+        // }),
+        'credential-id': Flags.string({
+            description: 'Copado credential Id for the target org. Defaults to the CICD project default credential when set.',
+        }),
+        endpoint: Flags.string({
+            description: 'Salesforce instance URL (with --session-id) when not using a credential. Exclusive with --credential-id.',
+        }),
+        'full-name': Flags.string({
+            description: 'Fully qualified metadata name (required for read; list results emit this as fullName)',
+        }),
+        // 'metadata-files': Flags.string({
+        //   description:
+        //     'YAML/XML Metadata API files for validate (with --full-name). Each file starts with ~~~~~~~~~~ <pathname> <type> <name> ~~~~~~~~~',
+        // }),
+        'object-type': Flags.string({
+            description: 'Metadata type, for example ApexClass, CustomObject, or Flow',
+        }),
+        // 'organization-name': Flags.string({
+        //   description: 'Optional label for logging; not used to select the target org',
+        // }),
+        pattern: Flags.string({
+            default: '*',
+            description: 'Wildcard pattern for list/search (name without namespace), for example Account* or *Info',
+        }),
+        'session-id': Flags.string({
+            description: 'Salesforce session Id (with --endpoint) when not using a credential. Exclusive with --credential-id.',
+        }),
+        // 'test-level': Flags.string({
+        //   description:
+        //     'Salesforce test level for validate/deploy (NoTestRun, RunSpecifiedTests, RunLocalTests). Defaults from --apex-unit-tests when omitted.',
+        // }),
+        // 'validate-only': Flags.boolean({
+        //   default: false,
+        //   description: 'When true, write-style actions validate without deploying',
+        // }),
+    };
+    async run() {
+        const { flags } = await this.parse(MetadataExplore);
+        const body = await buildAiMetadataToolRequest(flags);
+        const output = await this.withSpinner('Running AI metadata tool', () => callAiMetadataTool(body));
+        const result = {
+            output,
+            ...(body.credentialId === undefined ? {} : { credentialId: body.credentialId }),
+        };
+        this.display(() => {
+            process.stdout.write(output.endsWith('\n') ? output : `${output}\n`);
+        });
+        return result;
+    }
+}
+//# sourceMappingURL=explore.js.map

package/dist/commands/cicd/metadata/list.js

@@ -46,7 +46,7 @@ export function buildMetadataIndexRequest(flags) {
     return body;
 }
 export default class MetadataSearch extends AgentiaCommand {
-    static description = 'Search the metadata index for an org via the CICD gateway';
+    static description = 'Search the metadata index for an org';
     static examples = [
         '<%= config.bin %> <%= command.id %> --pipeline-id <id> --source-org-id <id> --source-credential-id <id>',
         '<%= config.bin %> <%= command.id %> --source Changed --metadata-types ApexClass --limit 100 --pipeline-id <id> --source-org-id <id> --source-credential-id <id>',
@@ -55,7 +55,7 @@ export default class MetadataSearch extends AgentiaCommand {
     static flags = {
         'avoid-source-tracking': Flags.boolean({
             default: false,
-            description: 'Pass avoidSourceTracking=true to the gateway index route',
+            description: 'Pass avoidSourceTracking=true to the index route',
         }),
         'change-date-from': Flags.string({
             description: 'Optional change-date-from filter (ISO datetime)',
@@ -92,7 +92,7 @@ export default class MetadataSearch extends AgentiaCommand {
         }),
         'platform-experience': Flags.string({
             default: 'salesforce',
-            description: 'Gateway platform experience header',
+            description: 'Platform experience header',
             options: [...PLATFORM_EXPERIENCES],
         }),
         source: Flags.string({

package/dist/commands/cicd/metadata/refresh/deleted.js

@@ -5,7 +5,7 @@ import { CicdGateway } from '../../../../lib/cicd-gateway.js';
 import { MODULE_TYPES } from '../../../../lib/metadata-common.js';
 import { buildRefreshDeletedRequest, formatRefreshDeletedResult, resolveRefreshSourceFromEnv, } from '../../../../lib/metadata-refresh.js';
 export default class MetadataRefreshDeleted extends AgentiaCommand {
-    static description = 'Refresh the deleted metadata index via the CICD gateway';
+    static description = 'Refresh the deleted metadata index';
     static examples = [
         '<%= config.bin %> <%= command.id %> --env <environment-id>',
         '<%= config.bin %> <%= command.id %> --env <environment-id> --module-type vlocity --json',

package/dist/commands/cicd/metadata/refresh/run.js

@@ -5,7 +5,7 @@ import { CicdGateway } from '../../../../lib/cicd-gateway.js';
 import { MODULE_TYPES, PLATFORM_EXPERIENCES, splitCsv, } from '../../../../lib/metadata-common.js';
 import { buildRefreshIndexRequest, formatIndexRefreshResult, resolveRefreshSourceFromEnv, } from '../../../../lib/metadata-refresh.js';
 export default class MetadataRefreshRun extends AgentiaCommand {
-    static description = 'Trigger a metadata index refresh via the CICD gateway';
+    static description = 'Trigger a metadata index refresh';
     static examples = [
         '<%= config.bin %> <%= command.id %> --env <environment-id>',
         '<%= config.bin %> <%= command.id %> --env <environment-id> --all --json',
@@ -30,7 +30,7 @@ export default class MetadataRefreshRun extends AgentiaCommand {
         }),
         'platform-experience': Flags.string({
             default: 'salesforce',
-            description: 'Gateway platform experience header',
+            description: 'Platform experience header',
             options: [...PLATFORM_EXPERIENCES],
         }),
         'refresh-mode': Flags.string({