@copado/agentia-cli 1.0.0 → 1.1.0

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

@@ -90,7 +90,10 @@ async function commitInputFromFlags(flags) {
         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.');
+        throw new WorkCommitValidationError('Requires simple metadata flags such as --metadata-name, --metadata-type, and --metadata-category, or JSON input with --file/--stdin.');
+    }
+    if (flags['metadata-category'] === undefined || flags['metadata-category'].trim().length === 0) {
+        throw new WorkCommitValidationError('--metadata-category is required.');
     }
     return simpleInputFromFlags(flags);
 }
@@ -105,7 +108,9 @@ export default class CloudCommit extends AgentiaCommand {
         '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(' ');
+        '',
+        'NOTE: Do not use this command along with local development (git operations, cicd work push/submit).',
+    ].join('\n');
     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',

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

@@ -0,0 +1,53 @@
+import { Flags } from '@oclif/core';
+import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { createExtension } from '../../../lib/extension/create.js';
+export default class ExtensionCreate extends AgentiaCommand {
+    static description = 'Create or refresh a Copado extension manifest at copado/extension_manifest.json (scans copado/functions and copado/templates)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --name my-extension --version 1.0.0',
+        '<%= config.bin %> <%= command.id %> --name my-extension --overwrite --json',
+    ];
+    static experimental = true;
+    static flags = {
+        name: Flags.string({
+            char: 'n',
+            description: 'Extension name (alphanumeric, underscore, hyphen)',
+            required: true,
+        }),
+        overwrite: Flags.boolean({
+            description: 'Overwrite an existing extension_manifest.json',
+            default: false,
+        }),
+        version: Flags.string({
+            description: 'Initial semver version written to the manifest (X.Y.Z)',
+            required: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ExtensionCreate);
+        let result;
+        try {
+            result = await createExtension({
+                name: flags.name,
+                overwrite: flags.overwrite,
+                version: flags.version,
+            });
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error), { exit: 2 });
+        }
+        this.display(() => {
+            this.log(`Created extension manifest at ${result.manifestPath}`);
+            this.log(`Name: ${result.manifest.name}`);
+            if (result.manifest.version !== undefined)
+                this.log(`Version: ${result.manifest.version}`);
+            this.log(`Functions: ${(result.manifest.functions ?? []).join(', ') || '(none)'}`);
+            this.log(`Templates: ${(result.manifest.templates ?? []).join(', ') || '(none)'}`);
+            if (result.createdDirs.length > 0) {
+                this.log(`Created directories: ${result.createdDirs.join(', ')}`);
+            }
+        });
+        return { manifest: result.manifest, manifestPath: result.manifestPath };
+    }
+}
+//# sourceMappingURL=create.js.map

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/work/get.js

@@ -1,7 +1,8 @@
 import { Args, Flags } from '@oclif/core';
 import { AgentiaCommand } from '../../../lib/agentia-command.js';
 import { WorkActiveResolutionError } from '../../../lib/work-active.js';
-import { fetchWorkItem } from '../../../lib/work-get.js';
+import { formatCommittedMetadataSection, } from '../../../lib/work-committed-metadata.js';
+import { fetchWorkItemWithOptions } from '../../../lib/work-get.js';
 import { formatUserStoriesAheadBehindLines, reportUserStoriesAheadBehindForStory, } from '../../../lib/work-submit-ahead-behind.js';
 import { formatUserStoryDetail, } from '../../../lib/work-types.js';
 export default class WorkGet extends AgentiaCommand {
@@ -16,10 +17,16 @@ 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 --committed-metadata',
+        '<%= config.bin %> <%= command.id %> a0SKC000000CmZ2AU --committed-metadata --json',
         '<%= config.bin %> <%= command.id %> a0SKC000000CmZ2AU --user-stories-ahead-behind',
         '<%= config.bin %> <%= command.id %> a0SKC000000CmZ2AU --user-stories-ahead-behind --json',
     ];
     static flags = {
+        'committed-metadata': Flags.boolean({
+            default: false,
+            description: 'Also include the Story committed metadata list in output',
+        }),
         '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',
@@ -28,8 +35,13 @@ export default class WorkGet extends AgentiaCommand {
     async run() {
         const { args, flags } = await this.parse(WorkGet);
         let userStory;
+        let committedMetadata;
         try {
-            userStory = await this.withSpinner('Fetching user story', () => fetchWorkItem(args.id));
+            const fetched = await this.withSpinner('Fetching user story', () => fetchWorkItemWithOptions(args.id, {
+                committedMetadata: flags['committed-metadata'],
+            }));
+            userStory = fetched.userStory;
+            committedMetadata = fetched.committedMetadata;
         }
         catch (error) {
             if (error instanceof WorkActiveResolutionError) {
@@ -48,12 +60,16 @@ export default class WorkGet extends AgentiaCommand {
         }
         this.display(() => {
             this.log(formatUserStoryDetail(userStory));
+            if (committedMetadata !== undefined) {
+                this.log(formatCommittedMetadataSection(committedMetadata));
+            }
             if (userStoriesAheadBehind !== undefined) {
                 this.log(formatUserStoriesAheadBehindLines(userStoriesAheadBehind));
             }
         });
         return {
             ...userStory,
+            ...(committedMetadata === undefined ? {} : { committedMetadata }),
             ...(userStoriesAheadBehind === undefined ? {} : { userStoriesAheadBehind }),
         };
     }

package/dist/commands/setup/skills/create.js

@@ -23,7 +23,7 @@ export default class SetupSkillsCreate extends AgentiaCommand {
         }),
         force: Flags.boolean({
             default: false,
-            description: 'Replace conflicting unmanaged Agentia skill files',
+            description: 'Replace conflicting unmanaged Agentia skill or rules files',
         }),
         'no-prompt': Flags.boolean({
             char: 'n',

package/dist/commands/setup/skills/update.js

@@ -23,7 +23,7 @@ export default class SetupSkillsUpdate extends AgentiaCommand {
         }),
         force: Flags.boolean({
             default: false,
-            description: 'Replace conflicting unmanaged Agentia skill files',
+            description: 'Replace conflicting unmanaged Agentia skill or rules files',
         }),
         'no-prompt': Flags.boolean({
             char: 'n',

package/dist/commands/setup.js

@@ -6,7 +6,7 @@ import { runSetupWizard } from '../lib/setup-wizard.js';
 export default class Setup extends AgentiaCommand {
     static description = [
         'Prepare this machine and the current project for Agentia.',
-        'Guides CICD, AI, and CRT authentication, Cursor MCP, local quality gates, and AGENTS.md.',
+        'Guides CICD, AI, and CRT authentication, Cursor MCP, local quality gates, Agent Skills, agent rules, and removal of a legacy AGENTS.md section.',
         'Use --skip-auth to skip authentication and continue with Cursor MCP and project setup.',
         'Git is optional: .gitignore is updated only inside a repository, and generated files are not committed.',
     ].join(' ');

package/dist/lib/extension/assets.js

@@ -0,0 +1,4 @@
+import {modules} from '../runtime.js';
+const loadFunctionUpsertPayload = modules["extension/assets.js"]["loadFunctionUpsertPayload"]
+const loadTemplateUpsertPayload = modules["extension/assets.js"]["loadTemplateUpsertPayload"]
+export {loadFunctionUpsertPayload, loadTemplateUpsertPayload};

package/dist/lib/extension/create.js

@@ -0,0 +1,3 @@
+import {modules} from '../runtime.js';
+const createExtension = modules["extension/create.js"]["createExtension"]
+export {createExtension};

package/dist/lib/extension/git.js

@@ -0,0 +1,17 @@
+import {modules} from '../runtime.js';
+const assertSafeGitRemote = modules["extension/git.js"]["assertSafeGitRemote"]
+const cloneExtensionRepo = modules["extension/git.js"]["cloneExtensionRepo"]
+const createAnnotatedTag = modules["extension/git.js"]["createAnnotatedTag"]
+const deleteLocalTag = modules["extension/git.js"]["deleteLocalTag"]
+const extensionGit = modules["extension/git.js"]["extensionGit"]
+const formatGitError = modules["extension/git.js"]["formatGitError"]
+const getCurrentBranchName = modules["extension/git.js"]["getCurrentBranchName"]
+const getHeadSha = modules["extension/git.js"]["getHeadSha"]
+const isWorkingTreeClean = modules["extension/git.js"]["isWorkingTreeClean"]
+const localTagExists = modules["extension/git.js"]["localTagExists"]
+const pushBranchAndTag = modules["extension/git.js"]["pushBranchAndTag"]
+const remoteTagExists = modules["extension/git.js"]["remoteTagExists"]
+const resetExtensionGitExecForTests = modules["extension/git.js"]["resetExtensionGitExecForTests"]
+const resolveLatestSemverTag = modules["extension/git.js"]["resolveLatestSemverTag"]
+const setExtensionGitExecForTests = modules["extension/git.js"]["setExtensionGitExecForTests"]
+export {assertSafeGitRemote, cloneExtensionRepo, createAnnotatedTag, deleteLocalTag, extensionGit, formatGitError, getCurrentBranchName, getHeadSha, isWorkingTreeClean, localTagExists, pushBranchAndTag, remoteTagExists, resetExtensionGitExecForTests, resolveLatestSemverTag, setExtensionGitExecForTests};

package/dist/lib/extension/index.js

@@ -0,0 +1,27 @@
+import {modules} from '../runtime.js';
+const EXTENSION_MANIFEST_RELATIVE_PATH = modules["extension/index.js"]["EXTENSION_MANIFEST_RELATIVE_PATH"]
+const assertSafeGitUrl = modules["extension/index.js"]["assertSafeGitUrl"]
+const assertValidExtensionName = modules["extension/index.js"]["assertValidExtensionName"]
+const assertValidSemver = modules["extension/index.js"]["assertValidSemver"]
+const cloneExtensionRepo = modules["extension/index.js"]["cloneExtensionRepo"]
+const createExtension = modules["extension/index.js"]["createExtension"]
+const deployExtensionSalesforceSource = modules["extension/index.js"]["deployExtensionSalesforceSource"]
+const extensionGit = modules["extension/index.js"]["extensionGit"]
+const installExtension = modules["extension/index.js"]["installExtension"]
+const loadFunctionUpsertPayload = modules["extension/index.js"]["loadFunctionUpsertPayload"]
+const loadTemplateUpsertPayload = modules["extension/index.js"]["loadTemplateUpsertPayload"]
+const materializeExtensionSource = modules["extension/index.js"]["materializeExtensionSource"]
+const packageExtension = modules["extension/index.js"]["packageExtension"]
+const parseExtensionManifest = modules["extension/index.js"]["parseExtensionManifest"]
+const publishExtension = modules["extension/index.js"]["publishExtension"]
+const readExtensionManifest = modules["extension/index.js"]["readExtensionManifest"]
+const resetExtensionGitExecForTests = modules["extension/index.js"]["resetExtensionGitExecForTests"]
+const resetExtensionSfDeployExecForTests = modules["extension/index.js"]["resetExtensionSfDeployExecForTests"]
+const resolveLocalExtensionPath = modules["extension/index.js"]["resolveLocalExtensionPath"]
+const setExtensionGitExecForTests = modules["extension/index.js"]["setExtensionGitExecForTests"]
+const setExtensionSfDeployExecForTests = modules["extension/index.js"]["setExtensionSfDeployExecForTests"]
+const uninstallExtension = modules["extension/index.js"]["uninstallExtension"]
+const validateExtension = modules["extension/index.js"]["validateExtension"]
+const versionTagName = modules["extension/index.js"]["versionTagName"]
+const writeExtensionManifest = modules["extension/index.js"]["writeExtensionManifest"]
+export {EXTENSION_MANIFEST_RELATIVE_PATH, assertSafeGitUrl, assertValidExtensionName, assertValidSemver, cloneExtensionRepo, createExtension, deployExtensionSalesforceSource, extensionGit, installExtension, loadFunctionUpsertPayload, loadTemplateUpsertPayload, materializeExtensionSource, packageExtension, parseExtensionManifest, publishExtension, readExtensionManifest, resetExtensionGitExecForTests, resetExtensionSfDeployExecForTests, resolveLocalExtensionPath, setExtensionGitExecForTests, setExtensionSfDeployExecForTests, uninstallExtension, validateExtension, versionTagName, writeExtensionManifest};

package/dist/lib/extension/install.js

@@ -0,0 +1,4 @@
+import {modules} from '../runtime.js';
+const assertSafeGitUrl = modules["extension/install.js"]["assertSafeGitUrl"]
+const installExtension = modules["extension/install.js"]["installExtension"]
+export {assertSafeGitUrl, installExtension};

package/dist/lib/extension/manifest.js

@@ -0,0 +1,21 @@
+import {modules} from '../runtime.js';
+const DEFAULT_SALESFORCE_SOURCE_DIR = modules["extension/manifest.js"]["DEFAULT_SALESFORCE_SOURCE_DIR"]
+const EXTENSION_FUNCTIONS_DIR = modules["extension/manifest.js"]["EXTENSION_FUNCTIONS_DIR"]
+const EXTENSION_MANIFEST_RELATIVE_PATH = modules["extension/manifest.js"]["EXTENSION_MANIFEST_RELATIVE_PATH"]
+const EXTENSION_NAME_REGEX = modules["extension/manifest.js"]["EXTENSION_NAME_REGEX"]
+const EXTENSION_TEMPLATES_DIR = modules["extension/manifest.js"]["EXTENSION_TEMPLATES_DIR"]
+const SEMVER_REGEX = modules["extension/manifest.js"]["SEMVER_REGEX"]
+const assertValidExtensionName = modules["extension/manifest.js"]["assertValidExtensionName"]
+const assertValidSemver = modules["extension/manifest.js"]["assertValidSemver"]
+const extensionManifestPath = modules["extension/manifest.js"]["extensionManifestPath"]
+const metadataJsonPath = modules["extension/manifest.js"]["metadataJsonPath"]
+const parseExtensionManifest = modules["extension/manifest.js"]["parseExtensionManifest"]
+const parseVersionFromRef = modules["extension/manifest.js"]["parseVersionFromRef"]
+const pathExists = modules["extension/manifest.js"]["pathExists"]
+const readExtensionManifest = modules["extension/manifest.js"]["readExtensionManifest"]
+const resolveSalesforceSourceDir = modules["extension/manifest.js"]["resolveSalesforceSourceDir"]
+const scanExtensionAssets = modules["extension/manifest.js"]["scanExtensionAssets"]
+const validateExtension = modules["extension/manifest.js"]["validateExtension"]
+const versionTagName = modules["extension/manifest.js"]["versionTagName"]
+const writeExtensionManifest = modules["extension/manifest.js"]["writeExtensionManifest"]
+export {DEFAULT_SALESFORCE_SOURCE_DIR, EXTENSION_FUNCTIONS_DIR, EXTENSION_MANIFEST_RELATIVE_PATH, EXTENSION_NAME_REGEX, EXTENSION_TEMPLATES_DIR, SEMVER_REGEX, assertValidExtensionName, assertValidSemver, extensionManifestPath, metadataJsonPath, parseExtensionManifest, parseVersionFromRef, pathExists, readExtensionManifest, resolveSalesforceSourceDir, scanExtensionAssets, validateExtension, versionTagName, writeExtensionManifest};

package/dist/lib/extension/package.js

@@ -0,0 +1,3 @@
+import {modules} from '../runtime.js';
+const packageExtension = modules["extension/package.js"]["packageExtension"]
+export {packageExtension};

package/dist/lib/extension/paths.js

@@ -0,0 +1,5 @@
+import {modules} from '../runtime.js';
+const assertPathInsideRoot = modules["extension/paths.js"]["assertPathInsideRoot"]
+const assertSafeExtensionFile = modules["extension/paths.js"]["assertSafeExtensionFile"]
+const assertSafeExtensionTree = modules["extension/paths.js"]["assertSafeExtensionTree"]
+export {assertPathInsideRoot, assertSafeExtensionFile, assertSafeExtensionTree};

package/dist/lib/extension/publish.js

@@ -0,0 +1,3 @@
+import {modules} from '../runtime.js';
+const publishExtension = modules["extension/publish.js"]["publishExtension"]
+export {publishExtension};