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

package/dist/lib/work-set-none.js

@@ -1,58 +1,4 @@
-import { clearLastKeysFromUserConfig } from './defaults-store.js';
-import { checkoutPreferredBranch, getCurrentBranch, listPendingChanges, localBranchExists, } from './git-worktree.js';
-export class WorkSetNoneValidationError extends Error {
-    exit;
-    suggestions;
-    constructor(message, options = {}) {
-        super(message);
-        this.name = 'WorkSetNoneValidationError';
-        this.exit = options.exit ?? 2;
-        this.suggestions = options.suggestions;
-    }
-}
-async function resolvePreferredCheckoutTarget(lastBaseBranch) {
-    for (const candidate of [lastBaseBranch, 'main', 'master']) {
-        const branch = candidate?.trim();
-        if (branch === undefined || branch.length === 0) {
-            continue;
-        }
-        if (await localBranchExists(branch)) {
-            return branch;
-        }
-    }
-    return undefined;
-}
-/**
- * Clear every `last*` key from `.agentia/config.user.json`, then check out
- * `lastBaseBranch` when it exists locally, else `main`, else `master`, else stay put.
- */
-export async function performWorkSetNone() {
-    const { clearedKeys, lastBaseBranch } = await clearLastKeysFromUserConfig();
-    const currentBranch = await getCurrentBranch();
-    const preferred = await resolvePreferredCheckoutTarget(lastBaseBranch);
-    if (preferred !== undefined && preferred !== currentBranch) {
-        const pendingFiles = await listPendingChanges();
-        if (pendingFiles.length > 0) {
-            throw new WorkSetNoneValidationError([
-                'Pending tracked changes present. Stash or commit them, then try again:',
-                ...pendingFiles.map((file) => `  ${file}`),
-            ].join('\n'), {
-                exit: 2,
-                suggestions: ['git stash push && agentia cicd work set --none'],
-            });
-        }
-    }
-    const checkout = await checkoutPreferredBranch([lastBaseBranch, 'main', 'master']);
-    const message = `Clearing latest settings and the checked out branch ${checkout.branch}.`;
-    return {
-        clearedKeys,
-        command: 'set',
-        git: {
-            branch: checkout.branch,
-            checkedOut: checkout.checkedOut,
-        },
-        message,
-        ...(lastBaseBranch === undefined ? {} : { previousBaseBranch: lastBaseBranch }),
-    };
-}
-//# sourceMappingURL=work-set-none.js.map
+import {modules} from './runtime.js';
+const WorkSetNoneValidationError = modules["work-set-none.js"]["WorkSetNoneValidationError"]
+const performWorkSetNone = modules["work-set-none.js"]["performWorkSetNone"]
+export {WorkSetNoneValidationError, performWorkSetNone};

package/dist/lib/work-set-selection.js

@@ -1,46 +1,5 @@
-function requireNonEmpty(value, message) {
-    const trimmed = value?.trim();
-    if (trimmed === undefined || trimmed.length === 0) {
-        throw new Error(message);
-    }
-    return trimmed;
-}
-export function isWorkSetWarning(response) {
-    return response.status === 'warning';
-}
-export function toWorkSetWarningResult(response) {
-    return {
-        baseBranch: response.baseBranch?.trim() ?? '',
-        command: response.command,
-        devOrgBranch: response.devOrgBranch?.trim() ?? '',
-        message: response.message,
-        pullRequestBaseUrl: response.pullRequestBaseUrl?.trim() ?? '',
-        status: 'warning',
-        workItem: response.workItem ?? {},
-    };
-}
-/** Validate headless work/set (or get) response fields used to record the active selection. */
-export function parseWorkSetSelection(setResponse, overrideBaseBranch) {
-    const override = overrideBaseBranch?.trim();
-    const baseBranch = requireNonEmpty(override !== undefined && override.length > 0 ? override : setResponse.baseBranch, 'Work set response did not include a base branch.');
-    const userStoryId = requireNonEmpty(setResponse.workItem.id, 'Work set response did not include a user story ID.');
-    const userStoryName = requireNonEmpty(setResponse.workItem.name, 'Work set response did not include a user story name for the feature branch.');
-    const devOrgBranch = requireNonEmpty(setResponse.devOrgBranch, 'Work set response did not include a dev org branch.');
-    const pullRequestBaseUrl = setResponse.pullRequestBaseUrl?.trim();
-    return {
-        baseBranch,
-        devOrgBranch,
-        ...(pullRequestBaseUrl !== undefined && pullRequestBaseUrl.length > 0
-            ? { pullRequestBaseUrl }
-            : {}),
-        userStoryId,
-        userStoryName,
-        userStoryTitle: setResponse.workItem.title?.trim() ?? '',
-        workItem: {
-            ...setResponse.workItem,
-            id: userStoryId,
-            name: userStoryName,
-        },
-    };
-}
-//# sourceMappingURL=work-set-selection.js.map
+import {modules} from './runtime.js';
+const isWorkSetWarning = modules["work-set-selection.js"]["isWorkSetWarning"]
+const parseWorkSetSelection = modules["work-set-selection.js"]["parseWorkSetSelection"]
+const toWorkSetWarningResult = modules["work-set-selection.js"]["toWorkSetWarningResult"]
+export {isWorkSetWarning, parseWorkSetSelection, toWorkSetWarningResult};

package/dist/lib/work-submit-wait.js

@@ -0,0 +1,11 @@
+import {modules} from './runtime.js';
+const WORK_SUBMIT_COMMIT_WAIT_TIMEOUT_SECONDS = modules["work-submit-wait.js"]["WORK_SUBMIT_COMMIT_WAIT_TIMEOUT_SECONDS"]
+const WorkSubmitCommitWaitTimeoutError = modules["work-submit-wait.js"]["WorkSubmitCommitWaitTimeoutError"]
+const findLastPendingCommitJob = modules["work-submit-wait.js"]["findLastPendingCommitJob"]
+const isCommitTemplateName = modules["work-submit-wait.js"]["isCommitTemplateName"]
+const isPendingJobStatus = modules["work-submit-wait.js"]["isPendingJobStatus"]
+const resetWorkSubmitCommitWaitSleepForTests = modules["work-submit-wait.js"]["resetWorkSubmitCommitWaitSleepForTests"]
+const setWorkSubmitCommitWaitSleepForTests = modules["work-submit-wait.js"]["setWorkSubmitCommitWaitSleepForTests"]
+const waitForPendingCommitJobBeforeSubmit = modules["work-submit-wait.js"]["waitForPendingCommitJobBeforeSubmit"]
+const waitForPendingCommitJobIfNeeded = modules["work-submit-wait.js"]["waitForPendingCommitJobIfNeeded"]
+export {WORK_SUBMIT_COMMIT_WAIT_TIMEOUT_SECONDS, WorkSubmitCommitWaitTimeoutError, findLastPendingCommitJob, isCommitTemplateName, isPendingJobStatus, resetWorkSubmitCommitWaitSleepForTests, setWorkSubmitCommitWaitSleepForTests, waitForPendingCommitJobBeforeSubmit, waitForPendingCommitJobIfNeeded};

package/dist/lib/work-types.js

@@ -1,336 +1,28 @@
-import { cellValue, table } from './format.js';
-import { appendListPaginationQueryParams, buildPaginatedListResult, paginatedResultFromPage, } from './list-pagination.js';
-export function applySourceCredentialEnvironmentRule(payload) {
-    const credential = payload.sourceCredential;
-    if (typeof credential !== 'string' || credential.trim().length === 0) {
-        return payload;
-    }
-    return {
-        ...payload,
-        sourceEnvironment: null,
-    };
-}
-export const WORK_LIST_FILTER_KEYS = [
-    'name',
-    'title',
-    'projectName',
-    'projectId',
-    'status',
-    'ownerName',
-    'ownerId',
-    'assigneeName',
-    'assigneeId',
-];
-export function workListEndpoint(filters = {}) {
-    const params = new URLSearchParams();
-    for (const key of WORK_LIST_FILTER_KEYS) {
-        const value = filters[key];
-        if (value !== undefined) {
-            params.set(key, value);
-        }
-    }
-    appendListPaginationQueryParams(params, filters);
-    const query = params.toString();
-    return query.length > 0 ? `/plan/user-stories?${query}` : '/plan/user-stories';
-}
-export function workCreateEndpoint() {
-    return '/plan/user-stories';
-}
-export function workEndpoint(id) {
-    return `/plan/user-stories/${id}`;
-}
-export function workGetEndpoint(workItem) {
-    const params = new URLSearchParams();
-    params.set('work_item', workItem);
-    return `/agentia/headless/work/get?${params.toString()}`;
-}
-export function workSetEndpoint() {
-    return '/agentia/headless/work/set';
-}
-export function workPushLockEndpoint() {
-    return '/agentia/headless/work/push/lock';
-}
-export function workPushReplacementRulesEndpoint(workItemId) {
-    const params = new URLSearchParams();
-    params.set('workItemId', workItemId);
-    return `/agentia/headless/work/configuration?${params.toString()}`;
-}
-export function workPushEndpoint() {
-    return '/agentia/headless/work/push';
-}
-export function workSubmitEndpoint() {
-    return '/agentia/headless/work/submit';
-}
-export function workRunTestsLocalEndpoint() {
-    return '/agentia/headless/work/run_tests/local';
-}
-export function workDoneEndpoint() {
-    return '/agentia/headless/work/done';
-}
-export function workStatusEndpoint(workItem) {
-    const params = new URLSearchParams();
-    params.set('work_item', workItem);
-    return `/agentia/headless/work/status?${params.toString()}`;
-}
-export function featureBranchName(userStoryName) {
-    return `feature/${userStoryName}`;
-}
-/** Builds a GitHub compare URL for opening a new PR: `<repo>/compare/base...feature?expand=1`. */
-export function buildPullRequestCompareUrl(pullRequestBaseUrl, baseBranch, featureBranch) {
-    let base = pullRequestBaseUrl.trim().replaceAll(/\/+$/g, '');
-    if (!base.toLowerCase().endsWith('/compare')) {
-        base = `${base}/compare`;
-    }
-    return `${base}/${baseBranch}...${featureBranch}?expand=1`;
-}
-const FEATURE_US_BRANCH_RE = /^feature\/(US-\d+)/i;
-export function extractUserStoryFromFeatureBranch(branchName) {
-    const match = FEATURE_US_BRANCH_RE.exec(branchName.trim());
-    if (match === null) {
-        return undefined;
-    }
-    return match[1].toUpperCase();
-}
-/** Rewrites gateway messages for user-facing CLI logs (JSON keeps the raw message). */
-export function formatWorkCommandMessage(message) {
-    return message
-        .replace(/^Headless submit started\b/i, 'Submitted')
-        .replace(/^Headless done started\b/i, 'Marked done');
-}
-const STATUS_LINE_RE = /^([A-Z])\d*\t(.+)$/;
-const COMMIT_HASH_RE = /^[0-9a-f]{7,40}$/i;
-function parseCommitHeader(line) {
-    const [id, message, name, email, date] = line.split('\0');
-    if (id === undefined ||
-        message === undefined ||
-        name === undefined ||
-        email === undefined ||
-        date === undefined ||
-        !COMMIT_HASH_RE.test(id)) {
-        return undefined;
-    }
-    return {
-        added: [],
-        committer: { date, email, name },
-        id,
-        message,
-        modified: [],
-        removed: [],
-        workItem: '',
-    };
-}
-function applyStatusLine(commit, status, paths) {
-    const parts = paths.split('\t');
-    switch (status) {
-        case 'A': {
-            commit.added.push(parts[0] ?? paths);
-            break;
-        }
-        case 'C': {
-            commit.added.push(parts.at(-1) ?? paths);
-            break;
-        }
-        case 'D': {
-            commit.removed.push(parts[0] ?? paths);
-            break;
-        }
-        case 'M': {
-            commit.modified.push(parts[0] ?? paths);
-            break;
-        }
-        case 'R': {
-            if (parts.length >= 2) {
-                commit.removed.push(parts[0]);
-                commit.added.push(parts[1]);
-            }
-            else {
-                commit.modified.push(parts[0] ?? paths);
-            }
-            break;
-        }
-        default: {
-            commit.modified.push(parts.at(-1) ?? paths);
-        }
-    }
-}
-export function parseNameStatusLog(stdout, workItem) {
-    const commits = [];
-    let current;
-    for (const rawLine of stdout.split(/\r?\n/)) {
-        const line = rawLine.trimEnd();
-        if (line.length === 0) {
-            continue;
-        }
-        const header = parseCommitHeader(line);
-        if (header !== undefined) {
-            current = { ...header, workItem };
-            commits.push(current);
-            continue;
-        }
-        if (current === undefined) {
-            continue;
-        }
-        const status = STATUS_LINE_RE.exec(line);
-        if (status === null) {
-            continue;
-        }
-        applyStatusLine(current, status[1].toUpperCase(), status[2]);
-    }
-    return commits;
-}
-export function normalizeUserStoriesListPage(response) {
-    if (Array.isArray(response)) {
-        return buildPaginatedListResult(response);
-    }
-    return paginatedResultFromPage(response);
-}
-export function normalizeUserStories(response) {
-    return normalizeUserStoriesListPage(response).data;
-}
-export function formatUserStoryTable(userStories) {
-    return table([
-        { alias: 'ID', value: 'id' },
-        { alias: 'NAME', value: 'name' },
-        { alias: 'TITLE', value: 'title' },
-        { alias: 'STATUS', value: 'status' },
-        { alias: 'PROJECT', value: 'projectName' },
-        { alias: 'ASSIGNEE', value: 'assigneeName' },
-        { alias: 'OWNER', value: 'owner' },
-    ], userStories.map((userStory) => ({
-        assigneeName: cellValue(userStory.assigneeName),
-        id: cellValue(userStory.id),
-        name: cellValue(userStory.name),
-        owner: cellValue(userStory.owner),
-        projectName: cellValue(userStory.projectName),
-        status: cellValue(userStory.status),
-        title: cellValue(userStory.title),
-    })));
-}
-export function formatUserStoryDetail(userStory) {
-    const epic = typeof userStory.epic === 'string' ? { id: userStory.epic } : userStory.epic;
-    const feature = typeof userStory.feature === 'string' ? { id: userStory.feature } : userStory.feature;
-    return [
-        `ID: ${cellValue(userStory.id)}`,
-        `Name: ${cellValue(userStory.name)}`,
-        `External ID: ${cellValue(userStory.externalId)}`,
-        `Title: ${cellValue(userStory.title)}`,
-        `Status: ${cellValue(userStory.status)}`,
-        `Priority: ${cellValue(userStory.priority)}`,
-        `Acceptance Criteria: ${cellValue(userStory.acceptanceCriteria)}`,
-        `Functional Requirements: ${cellValue(userStory.functionalRequirements)}`,
-        `Technical Specifications: ${cellValue(userStory.technicalSpecifications)}`,
-        `As A: ${cellValue(userStory.asA)}`,
-        `Want To: ${cellValue(userStory.wantTo)}`,
-        `So That: ${cellValue(userStory.soThat)}`,
-        `Points: ${cellValue(userStory.points)}`,
-        `Actual Points: ${cellValue(userStory.actualPoints)}`,
-        `Planned Points: ${cellValue(userStory.plannedPoints)}`,
-        `Assignee: ${cellValue(userStory.assigneeName ?? userStory.assignee)}`,
-        `Assignee ID: ${cellValue(userStory.assignee)}`,
-        `Owner: ${cellValue(userStory.owner)}`,
-        `Owner ID: ${cellValue(userStory.ownerId)}`,
-        `Team: ${cellValue(userStory.team)}`,
-        `Project: ${cellValue(userStory.projectName ?? userStory.project)}`,
-        `Project ID: ${cellValue(userStory.project)}`,
-        `Pipeline ID: ${cellValue(userStory.pipelineId)}`,
-        `Pipeline Active: ${cellValue(userStory.pipelineActive)}`,
-        `Pipeline Blocks Commits: ${cellValue(userStory.pipelineBlockCommits)}`,
-        `Platform: ${cellValue(userStory.platform)}`,
-        `Project Pipeline Main Branch: ${cellValue(userStory.projectPipelineMainBranch)}`,
-        `Project Pipeline Pull Request Base URL: ${cellValue(userStory.projectPipelinePullRequestBaseUrl)}`,
-        `Release ID: ${cellValue(userStory.releaseId)}`,
-        `Release: ${cellValue(userStory.releaseName)}`,
-        `Release Base Branch: ${cellValue(userStory.releaseBaseBranch)}`,
-        `Release Project: ${cellValue(userStory.releaseProject)}`,
-        `Release Project Pipeline ID: ${cellValue(userStory.releaseProjectPipelineId)}`,
-        `Release Project Pipeline Main Branch: ${cellValue(userStory.releaseProjectPipelineMainBranch)}`,
-        `Release Project Pipeline Pull Request Base URL: ${cellValue(userStory.releaseProjectPipelinePullRequestBaseUrl)}`,
-        `Source Credential: ${cellValue(userStory.sourceCredential)}`,
-        `Source Credential Name: ${cellValue(userStory.sourceCredentialName)}`,
-        `Source Credential Link: ${cellValue(userStory.sourceCredentialLink)}`,
-        `Source Environment: ${cellValue(userStory.sourceEnvironment)}`,
-        `Source Environment Name: ${cellValue(userStory.sourceEnvironmentName)}`,
-        `Source Environment Link: ${cellValue(userStory.sourceEnvironmentLink)}`,
-        `Source Org ID: ${cellValue(userStory.sourceOrgId)}`,
-        `OAuth Signature: ${userStory.oauthSignature === undefined ? '' : '[REDACTED]'}`,
-        `Last Validation Date: ${cellValue(userStory.lastValidationDate)}`,
-        `Base Branch: ${cellValue(userStory.baseBranch)}`,
-        `Latest Commit Date: ${cellValue(userStory.latestCommitDate)}`,
-        `Excluded From CBM: ${cellValue(userStory.excludedFromCbm)}`,
-        `Sprint ID: ${cellValue(userStory.sprintId)}`,
-        `Sprint: ${cellValue(userStory.sprint)}`,
-        `Sprint Start Date: ${cellValue(userStory.sprintStartDate)}`,
-        `Record Type: ${cellValue(userStory.recordType)}`,
-        `Theme: ${cellValue(userStory.theme)}`,
-        `Close Date: ${cellValue(userStory.closeDate)}`,
-        `Cancellation Reason: ${cellValue(userStory.cancellationReason)}`,
-        `Created By: ${cellValue(userStory.createdBy)}`,
-        `Created Date: ${cellValue(userStory.createdDate)}`,
-        `Last Modified By: ${cellValue(userStory.lastModifiedBy)}`,
-        `Last Modified Date: ${cellValue(userStory.lastModifiedDate)}`,
-        `Epic ID: ${cellValue(epic?.id)}`,
-        `Epic Name: ${cellValue(epic?.name)}`,
-        `Epic Title: ${cellValue(epic?.title)}`,
-        `Epic Details: ${cellValue(epic?.details)}`,
-        `Epic Description: ${cellValue(epic?.description)}`,
-        `Epic Technical Assumptions: ${cellValue(epic?.technicalAssumptions)}`,
-        `Feature ID: ${cellValue(feature?.id)}`,
-        `Feature Title: ${cellValue(feature?.title)}`,
-        `Feature Description: ${cellValue(feature?.description)}`,
-        `Feature Technical Assumptions: ${cellValue(feature?.technicalAssumptions)}`,
-        `Components: ${cellValue(userStory.components === undefined ? undefined : JSON.stringify(userStory.components))}`,
-    ].join('\n');
-}
-export function formatHeadlessJobTable(jobs) {
-    return table([
-        { alias: 'ID', value: 'id' },
-        { alias: 'NAME', value: 'name' },
-        { alias: 'STATUS', value: 'status' },
-        { alias: 'TEMPLATE', value: 'templateName' },
-        { alias: 'SOURCE', value: 'sourceName' },
-        { alias: 'DESTINATION', value: 'destinationName' },
-        { alias: 'CREATED', value: 'createdDate' },
-        { alias: 'ERROR', value: 'errorMessage', wrap: true },
-    ], jobs.map((job) => ({
-        createdDate: cellValue(job.createdDate),
-        destinationName: cellValue(job.destinationName),
-        errorMessage: cellValue(job.errorMessage),
-        id: cellValue(job.id),
-        name: cellValue(job.name),
-        sourceName: cellValue(job.sourceName),
-        status: cellValue(job.status),
-        templateName: cellValue(job.templateName),
-    })));
-}
-export function formatWorkStatus(result) {
-    const sections = [formatUserStoryDetail(result.workItem), '', 'Jobs:'];
-    if (result.jobs.length === 0) {
-        sections.push('No jobs found.');
-    }
-    else {
-        sections.push(formatHeadlessJobTable(result.jobs));
-    }
-    if (result.branchMetadata) {
-        sections.push('', formatWorkBranchMetadata(result.branchMetadata));
-    }
-    return sections.join('\n');
-}
-export function formatWorkBranchMetadata(result) {
-    const sections = [`Branch metadata (base: ${result.baseRef}):`];
-    if (result.metadataList.length === 0) {
-        sections.push('No metadata found.');
-    }
-    else {
-        sections.push(table([
-            { alias: 'TYPE', value: 'type' },
-            { alias: 'NAME', value: 'name' },
-            { alias: 'LOCAL PATHS', value: 'localPaths', wrap: true },
-        ], result.metadataList.map((item) => ({
-            localPaths: item.localPaths.join('\n'),
-            name: item.name,
-            type: item.type,
-        }))));
-    }
-    return sections.join('\n');
-}
-//# sourceMappingURL=work-types.js.map
+import {modules} from './runtime.js';
+const WORK_LIST_FILTER_KEYS = modules["work-types.js"]["WORK_LIST_FILTER_KEYS"]
+const applySourceCredentialEnvironmentRule = modules["work-types.js"]["applySourceCredentialEnvironmentRule"]
+const buildPullRequestCompareUrl = modules["work-types.js"]["buildPullRequestCompareUrl"]
+const extractUserStoryFromFeatureBranch = modules["work-types.js"]["extractUserStoryFromFeatureBranch"]
+const featureBranchName = modules["work-types.js"]["featureBranchName"]
+const formatHeadlessJobTable = modules["work-types.js"]["formatHeadlessJobTable"]
+const formatUserStoryDetail = modules["work-types.js"]["formatUserStoryDetail"]
+const formatUserStoryTable = modules["work-types.js"]["formatUserStoryTable"]
+const formatWorkBranchMetadata = modules["work-types.js"]["formatWorkBranchMetadata"]
+const formatWorkCommandMessage = modules["work-types.js"]["formatWorkCommandMessage"]
+const formatWorkStatus = modules["work-types.js"]["formatWorkStatus"]
+const normalizeUserStories = modules["work-types.js"]["normalizeUserStories"]
+const normalizeUserStoriesListPage = modules["work-types.js"]["normalizeUserStoriesListPage"]
+const parseNameStatusLog = modules["work-types.js"]["parseNameStatusLog"]
+const workCreateEndpoint = modules["work-types.js"]["workCreateEndpoint"]
+const workDoneEndpoint = modules["work-types.js"]["workDoneEndpoint"]
+const workEndpoint = modules["work-types.js"]["workEndpoint"]
+const workGetEndpoint = modules["work-types.js"]["workGetEndpoint"]
+const workListEndpoint = modules["work-types.js"]["workListEndpoint"]
+const workPushEndpoint = modules["work-types.js"]["workPushEndpoint"]
+const workPushLockEndpoint = modules["work-types.js"]["workPushLockEndpoint"]
+const workPushReplacementRulesEndpoint = modules["work-types.js"]["workPushReplacementRulesEndpoint"]
+const workRunTestsLocalEndpoint = modules["work-types.js"]["workRunTestsLocalEndpoint"]
+const workSetEndpoint = modules["work-types.js"]["workSetEndpoint"]
+const workStatusEndpoint = modules["work-types.js"]["workStatusEndpoint"]
+const workSubmitEndpoint = modules["work-types.js"]["workSubmitEndpoint"]
+export {WORK_LIST_FILTER_KEYS, applySourceCredentialEnvironmentRule, buildPullRequestCompareUrl, extractUserStoryFromFeatureBranch, featureBranchName, formatHeadlessJobTable, formatUserStoryDetail, formatUserStoryTable, formatWorkBranchMetadata, formatWorkCommandMessage, formatWorkStatus, normalizeUserStories, normalizeUserStoriesListPage, parseNameStatusLog, workCreateEndpoint, workDoneEndpoint, workEndpoint, workGetEndpoint, workListEndpoint, workPushEndpoint, workPushLockEndpoint, workPushReplacementRulesEndpoint, workRunTestsLocalEndpoint, workSetEndpoint, workStatusEndpoint, workSubmitEndpoint};

package/dist/lib/yaml-replacement.js

@@ -1,132 +1,13 @@
-import { spawn } from 'node:child_process';
-import { access, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { CicdGateway, getGatewayClientOrigin } from './cicd-gateway.js';
-import { logVerboseDebug } from './debug.js';
-import { workPushReplacementRulesEndpoint, } from './work-types.js';
-const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../..');
-export const YAML_REPLACE_COMMAND_JAR_NAME = 'yaml-replace-command.jar';
-function defaultRunProcess(command, args, options) {
-    return new Promise((resolvePromise, reject) => {
-        const child = spawn(command, args, {
-            cwd: options.cwd,
-            env: process.env,
-        });
-        let stdout = '';
-        let stderr = '';
-        child.stdout.on('data', (chunk) => {
-            stdout += String(chunk);
-        });
-        child.stderr.on('data', (chunk) => {
-            stderr += String(chunk);
-        });
-        child.on('error', (error) => {
-            reject(error);
-        });
-        child.on('close', (code) => {
-            resolvePromise({ exitCode: code, stderr, stdout });
-        });
-    });
-}
-export function resolveYamlReplaceCommandJar() {
-    const override = process.env.AGENTIA_YAML_REPLACE_COMMAND_JAR?.trim();
-    if (override !== undefined && override.length > 0) {
-        return override;
-    }
-    return join(packageRoot, 'vendor/java', YAML_REPLACE_COMMAND_JAR_NAME);
-}
-export function resolveYamlReplacementJavaCommand() {
-    const override = process.env.AGENTIA_JAVA?.trim();
-    return override !== undefined && override.length > 0 ? override : 'java';
-}
-/** JSON path list consumed by yaml-replace-command `-c` / `--include`. */
-export function buildFilesInScopeJson(changedFiles) {
-    return `${JSON.stringify(changedFiles, null, 0)}\n`;
-}
-export function formatYamlReplacementCommand(command, args) {
-    return [command, ...args].join(' ');
-}
-function logYamlReplacementVerboseInput(options) {
-    logVerboseDebug('Yaml replacement command', formatYamlReplacementCommand(options.command, options.args));
-    logVerboseDebug('Yaml replacement rules', options.replacementRulesYml);
-    logVerboseDebug('Yaml replacement files in scope', options.changedFiles.length > 0 ? options.changedFiles.join('\n') : '(empty)');
-}
-/** Emit yaml-replace-command process streams for normal CLI output. */
-export function emitYamlReplacementProcessOutput(result) {
-    for (const stream of [result.stdout, result.stderr]) {
-        const trimmed = stream.trimEnd();
-        if (trimmed.length > 0) {
-            process.stderr.write(`${trimmed}\n`);
-        }
-    }
-}
-export async function fetchWorkPushReplacementRules(workItemId) {
-    return CicdGateway.call({
-        endpoint: workPushReplacementRulesEndpoint(workItemId),
-        method: 'GET',
-    });
-}
-export async function runYamlReplacement(options) {
-    const jarPath = resolveYamlReplaceCommandJar();
-    try {
-        await access(jarPath);
-    }
-    catch {
-        throw new Error(`Yaml replacement JAR not found at ${jarPath}. Run \`npm run build-java-dependencies\` or set AGENTIA_YAML_REPLACE_COMMAND_JAR.`);
-    }
-    const tempDir = await mkdtemp(join(tmpdir(), 'agentia-yaml-replace-'));
-    const yamlPath = join(tempDir, 'copado.yml');
-    const includePath = join(tempDir, 'files-in-scope.json');
-    try {
-        await writeFile(yamlPath, options.replacementRulesYml, 'utf8');
-        await writeFile(includePath, buildFilesInScopeJson(options.changedFiles), 'utf8');
-        const javaCommand = resolveYamlReplacementJavaCommand();
-        // `-b` is matched against yaml `branches` / `exclusionBranches`. Copado Commit passes the feature branch.
-        const args = [
-            '-jar',
-            jarPath,
-            yamlPath,
-            options.targetFolder,
-            '-b',
-            options.branchName,
-            '-c',
-            includePath,
-        ];
-        logYamlReplacementVerboseInput({
-            args,
-            changedFiles: options.changedFiles,
-            command: javaCommand,
-            replacementRulesYml: options.replacementRulesYml,
-        });
-        const runProcess = options.runProcess ?? yamlReplacementProcessForTests() ?? defaultRunProcess;
-        const result = await runProcess(javaCommand, args, { cwd: options.cwd });
-        if (getGatewayClientOrigin() !== 'mcp') {
-            emitYamlReplacementProcessOutput(result);
-        }
-        return {
-            args,
-            command: javaCommand,
-            exitCode: result.exitCode,
-            stderr: result.stderr,
-            stdout: result.stdout,
-        };
-    }
-    finally {
-        await rm(tempDir, { force: true, recursive: true });
-    }
-}
-let runProcessForTests;
-/** Test-only hook */
-export function setYamlReplacementProcessForTests(runner) {
-    runProcessForTests = runner;
-}
-/** Test-only hook */
-export function resetYamlReplacementProcessForTests() {
-    runProcessForTests = undefined;
-}
-export function yamlReplacementProcessForTests() {
-    return runProcessForTests;
-}
-//# sourceMappingURL=yaml-replacement.js.map
+import {modules} from './runtime.js';
+const YAML_REPLACE_COMMAND_JAR_NAME = modules["yaml-replacement.js"]["YAML_REPLACE_COMMAND_JAR_NAME"]
+const buildFilesInScopeJson = modules["yaml-replacement.js"]["buildFilesInScopeJson"]
+const emitYamlReplacementProcessOutput = modules["yaml-replacement.js"]["emitYamlReplacementProcessOutput"]
+const fetchWorkPushReplacementRules = modules["yaml-replacement.js"]["fetchWorkPushReplacementRules"]
+const formatYamlReplacementCommand = modules["yaml-replacement.js"]["formatYamlReplacementCommand"]
+const resetYamlReplacementProcessForTests = modules["yaml-replacement.js"]["resetYamlReplacementProcessForTests"]
+const resolveYamlReplaceCommandJar = modules["yaml-replacement.js"]["resolveYamlReplaceCommandJar"]
+const resolveYamlReplacementJavaCommand = modules["yaml-replacement.js"]["resolveYamlReplacementJavaCommand"]
+const runYamlReplacement = modules["yaml-replacement.js"]["runYamlReplacement"]
+const setYamlReplacementProcessForTests = modules["yaml-replacement.js"]["setYamlReplacementProcessForTests"]
+const yamlReplacementProcessForTests = modules["yaml-replacement.js"]["yamlReplacementProcessForTests"]
+export {YAML_REPLACE_COMMAND_JAR_NAME, buildFilesInScopeJson, emitYamlReplacementProcessOutput, fetchWorkPushReplacementRules, formatYamlReplacementCommand, resetYamlReplacementProcessForTests, resolveYamlReplaceCommandJar, resolveYamlReplacementJavaCommand, runYamlReplacement, setYamlReplacementProcessForTests, yamlReplacementProcessForTests};