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

package/dist/lib/project-setup.js

@@ -1,406 +1,13 @@
-import { existsSync } from 'node:fs';
-import { chmod, readFile, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { getCurrentBranch, getGitRepoRoot, getRemoteUrl, isInsideGitWorkTree } from './git-worktree.js';
-import { QUALITY_GATES_SCRIPT_UNIX, QUALITY_GATES_SCRIPT_WINDOWS } from './local-quality-gates.js';
-import { AGENTIA_AGENTS_END_MARKER, AGENTIA_AGENTS_START_MARKER, AGENTIA_DIR_GITIGNORE_ENTRIES, AGENTIA_GITIGNORE_ENTRIES, AGENTIA_GITIGNORE_ENTRY, AGENTIA_IDEX_GITIGNORE_ENTRY, qualityGatesExplanation, SAMPLE_QUALITY_GATES_UNIX, SAMPLE_QUALITY_GATES_WINDOWS, } from './setup-templates.js';
-let testDeps;
-export function setProjectSetupDepsForTests(deps) {
-    testDeps = deps;
-}
-export function resetProjectSetupDepsForTests() {
-    testDeps = undefined;
-}
-function resolveDeps(overrides = {}) {
-    const merged = { ...testDeps, ...overrides };
-    return {
-        chmod: merged.chmod ?? ((filePath, mode) => chmod(filePath, mode)),
-        existsSync: merged.existsSync ?? existsSync,
-        getCurrentBranch: merged.getCurrentBranch ?? getCurrentBranch,
-        getGitRepoRoot: merged.getGitRepoRoot ?? getGitRepoRoot,
-        getRemoteUrl: merged.getRemoteUrl ?? getRemoteUrl,
-        isInsideGitWorkTree: merged.isInsideGitWorkTree ?? isInsideGitWorkTree,
-        prompts: merged.prompts,
-        readAgentsTemplate: merged.readAgentsTemplate ??
-            (() => readFile(path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../templates/AGENTS.md'), 'utf8')),
-        readFile: merged.readFile ?? ((filePath, encoding) => readFile(filePath, encoding)),
-        runSetupSkills: merged.runSetupSkills,
-        writeFile: merged.writeFile ?? ((filePath, contents, encoding) => writeFile(filePath, contents, encoding)),
-    };
-}
-function isAgentiaUserConfigGitignoreLine(trimmed) {
-    return trimmed === AGENTIA_GITIGNORE_ENTRY || trimmed === `/${AGENTIA_GITIGNORE_ENTRY}`;
-}
-function gitignoreEntryForLine(trimmed) {
-    if (isAgentiaUserConfigGitignoreLine(trimmed))
-        return AGENTIA_GITIGNORE_ENTRY;
-    if (trimmed === AGENTIA_IDEX_GITIGNORE_ENTRY ||
-        trimmed === `/${AGENTIA_IDEX_GITIGNORE_ENTRY}` ||
-        trimmed === `${AGENTIA_IDEX_GITIGNORE_ENTRY}/` ||
-        trimmed === `/${AGENTIA_IDEX_GITIGNORE_ENTRY}/`) {
-        return AGENTIA_IDEX_GITIGNORE_ENTRY;
-    }
-    return undefined;
-}
-function isAgentiaDirGitignoreLine(trimmed) {
-    return AGENTIA_DIR_GITIGNORE_ENTRIES.includes(trimmed);
-}
-export function gitignoreHasAgentiaEntry(contents) {
-    const entries = new Set(contents
-        .split(/\r?\n/)
-        .map((line) => gitignoreEntryForLine(line.trim()))
-        .filter((entry) => entry !== undefined));
-    return AGENTIA_GITIGNORE_ENTRIES.every((entry) => entries.has(entry));
-}
-function migrateAgentiaGitignoreContents(contents) {
-    const lines = contents.split(/\r?\n/);
-    const seen = new Set();
-    let changed = false;
-    const nextLines = [];
-    for (const line of lines) {
-        const trimmed = line.trim();
-        const canonicalEntry = gitignoreEntryForLine(trimmed);
-        if (canonicalEntry !== undefined) {
-            if (seen.has(canonicalEntry)) {
-                changed = true;
-                continue;
-            }
-            seen.add(canonicalEntry);
-            if (trimmed !== canonicalEntry) {
-                nextLines.push(canonicalEntry);
-                changed = true;
-                continue;
-            }
-            nextLines.push(line);
-            continue;
-        }
-        if (isAgentiaDirGitignoreLine(trimmed)) {
-            for (const entry of AGENTIA_GITIGNORE_ENTRIES) {
-                if (!seen.has(entry)) {
-                    nextLines.push(entry);
-                    seen.add(entry);
-                }
-            }
-            changed = true;
-            continue;
-        }
-        nextLines.push(line);
-    }
-    for (const entry of AGENTIA_GITIGNORE_ENTRIES) {
-        if (!seen.has(entry)) {
-            if (nextLines.length > 0 && nextLines.at(-1) === '') {
-                nextLines[nextLines.length - 1] = entry;
-                nextLines.push('');
-            }
-            else {
-                nextLines.push(entry);
-            }
-            changed = true;
-        }
-    }
-    let next = nextLines.join('\n');
-    if (!next.endsWith('\n')) {
-        next = `${next}\n`;
-    }
-    return { changed, next };
-}
-export async function ensureAgentiaGitignore(repoRoot, deps = {}) {
-    const resolved = resolveDeps(deps);
-    const gitignorePath = path.join(repoRoot, '.gitignore');
-    const exists = resolved.existsSync(gitignorePath);
-    if (!exists) {
-        await resolved.writeFile(gitignorePath, `${AGENTIA_GITIGNORE_ENTRIES.join('\n')}\n`, 'utf8');
-        return { path: gitignorePath, status: 'created' };
-    }
-    const current = await resolved.readFile(gitignorePath, 'utf8');
-    const { changed, next } = migrateAgentiaGitignoreContents(current);
-    if (!changed) {
-        return { path: gitignorePath, status: 'unchanged' };
-    }
-    await resolved.writeFile(gitignorePath, next, 'utf8');
-    return { path: gitignorePath, status: 'updated' };
-}
-export function findLocalQualityGateScripts(repoRoot, deps = {}) {
-    const resolved = resolveDeps(deps);
-    const candidates = [path.join(repoRoot, QUALITY_GATES_SCRIPT_UNIX), path.join(repoRoot, QUALITY_GATES_SCRIPT_WINDOWS)];
-    const existingPaths = candidates.filter((filePath) => resolved.existsSync(filePath));
-    return {
-        existingPaths,
-        present: existingPaths.length > 0,
-    };
-}
-export async function createLocalQualityGateScripts(repoRoot, deps = {}, overwrite = false) {
-    const resolved = resolveDeps(deps);
-    const unixPath = path.join(repoRoot, QUALITY_GATES_SCRIPT_UNIX);
-    const windowsPath = path.join(repoRoot, QUALITY_GATES_SCRIPT_WINDOWS);
-    const unixExists = resolved.existsSync(unixPath);
-    const windowsExists = resolved.existsSync(windowsPath);
-    if (unixExists && windowsExists && !overwrite) {
-        return { paths: [unixPath, windowsPath], status: 'unchanged' };
-    }
-    if (!unixExists || overwrite) {
-        await resolved.writeFile(unixPath, SAMPLE_QUALITY_GATES_UNIX, 'utf8');
-        try {
-            await resolved.chmod(unixPath, 0o755);
-        }
-        catch {
-            // Best-effort executable bit; Windows and some FS may reject chmod.
-        }
-    }
-    if (!windowsExists || overwrite) {
-        await resolved.writeFile(windowsPath, SAMPLE_QUALITY_GATES_WINDOWS, 'utf8');
-    }
-    return {
-        paths: [unixPath, windowsPath],
-        status: unixExists || windowsExists ? 'updated' : 'created',
-    };
-}
-export async function resolveAgentsMdContent(deps = {}) {
-    const resolved = resolveDeps(deps);
-    const content = await resolved.readAgentsTemplate();
-    if (content.trim().length === 0 ||
-        !content.includes(AGENTIA_AGENTS_START_MARKER) ||
-        !content.includes(AGENTIA_AGENTS_END_MARKER)) {
-        throw new Error('Packaged AGENTS.md template is empty or missing Agentia managed markers.');
-    }
-    return content;
-}
-export function findAgentsMd(repoRoot, deps = {}) {
-    const resolved = resolveDeps(deps);
-    const agentsPath = path.join(repoRoot, 'AGENTS.md');
-    return {
-        path: agentsPath,
-        present: resolved.existsSync(agentsPath),
-    };
-}
-export async function writeAgentsMd(repoRoot, deps = {}) {
-    const resolved = resolveDeps(deps);
-    const agentsPath = path.join(repoRoot, 'AGENTS.md');
-    const existed = resolved.existsSync(agentsPath);
-    const content = await resolveAgentsMdContent(deps);
-    const generated = content.endsWith('\n') ? content : `${content}\n`;
-    let output = generated;
-    let status = existed ? 'updated' : 'created';
-    if (existed) {
-        const current = await resolved.readFile(agentsPath, 'utf8');
-        const start = current.indexOf(AGENTIA_AGENTS_START_MARKER);
-        const end = current.indexOf(AGENTIA_AGENTS_END_MARKER);
-        const hasStart = start !== -1;
-        const hasEnd = end !== -1;
-        const startCount = current.split(AGENTIA_AGENTS_START_MARKER).length - 1;
-        const endCount = current.split(AGENTIA_AGENTS_END_MARKER).length - 1;
-        if (hasStart !== hasEnd || (hasStart && (startCount !== 1 || endCount !== 1)) || (hasStart && end < start)) {
-            throw new Error('AGENTS.md contains malformed or duplicate Agentia managed markers; repair them before running setup.');
-        }
-        if (hasStart) {
-            const endExclusive = end + AGENTIA_AGENTS_END_MARKER.length;
-            output = `${current.slice(0, start)}${generated.trimEnd()}${current.slice(endExclusive)}`;
-            if (output === current)
-                status = 'unchanged';
-        }
-        else {
-            output = `${current.replace(/\s*$/, '')}\n\n${generated}`;
-        }
-    }
-    if (status !== 'unchanged')
-        await resolved.writeFile(agentsPath, output, 'utf8');
-    return {
-        path: agentsPath,
-        status,
-    };
-}
-function logGitignoreResult(log, cwd, gitignore) {
-    const relative = path.relative(cwd, gitignore.path) || '.gitignore';
-    if (gitignore.status === 'created') {
-        log(`Created ${relative} with ${AGENTIA_GITIGNORE_ENTRIES.join(' and ')}`);
-        return;
-    }
-    if (gitignore.status === 'updated') {
-        log(`Added ${AGENTIA_GITIGNORE_ENTRIES.join(' and ')} to ${relative}`);
-        return;
-    }
-    log(`.gitignore already ignores ${AGENTIA_GITIGNORE_ENTRIES.join(' and ')}`);
-}
-function toRelativePaths(cwd, absolutePaths) {
-    return absolutePaths.map((filePath) => path.relative(cwd, filePath) || path.basename(filePath));
-}
-async function maybeCreateQualityGates(params) {
-    const { bin, cwd, deps, log, noPrompt, requested, resolved, root } = params;
-    const existing = findLocalQualityGateScripts(root, deps);
-    const existingRelative = toRelativePaths(cwd, existing.existingPaths);
-    if (existing.present) {
-        log(`Local quality gates already set at project root (${existingRelative.join(', ')}).`);
-    }
-    if (existing.present && !requested && noPrompt) {
-        return {
-            existingPaths: existingRelative,
-            paths: existingRelative,
-            status: 'unchanged',
-        };
-    }
-    const shouldCreate = requested ||
-        (!noPrompt &&
-            resolved.prompts !== undefined &&
-            (await resolved.prompts.confirm({
-                default: false,
-                message: existing.present
-                    ? 'Regenerate sample local quality gates (.agentia_quality_gates.sh / .cmd)?'
-                    : 'Create sample local quality gates (.agentia_quality_gates.sh / .cmd)?',
-            })));
-    if (!shouldCreate) {
-        log(noPrompt
-            ? 'Skipped local quality gates (pass --create-local-quality-gates to add them).'
-            : 'Skipped local quality gates.');
-        return {
-            existingPaths: existingRelative,
-            paths: existing.present ? existingRelative : undefined,
-            status: existing.present ? 'unchanged' : 'skipped',
-        };
-    }
-    const created = await createLocalQualityGateScripts(root, deps, existing.present);
-    const relativePaths = toRelativePaths(cwd, created.paths);
-    if (created.status === 'unchanged') {
-        log(`Local quality gates already present (${relativePaths.join(', ')}).`);
-        log(qualityGatesExplanation(bin));
-        return {
-            existingPaths: existingRelative,
-            paths: relativePaths,
-            status: 'unchanged',
-        };
-    }
-    log(`Local quality gates ${created.status} (${relativePaths.join(', ')}).`);
-    log(qualityGatesExplanation(bin));
-    return {
-        existingPaths: existingRelative,
-        paths: relativePaths,
-        status: created.status,
-    };
-}
-async function maybeSetupAgentiaWorkflow(params) {
-    const { cwd, deps, forceSkills, log, noPrompt, requested, resolved, root, skillsTargets } = params;
-    const existing = findAgentsMd(root, deps);
-    const relativePath = path.relative(cwd, existing.path) || 'AGENTS.md';
-    log('Agentia workflow');
-    const shouldSetup = requested ||
-        (!noPrompt &&
-            resolved.prompts !== undefined &&
-            (await resolved.prompts.confirm({
-                default: false,
-                message: 'Install or update Agentia skills and AGENTS.md workflow guidance?',
-            })));
-    if (!shouldSetup) {
-        log(noPrompt
-            ? 'Skipped Agentia workflow guidance (pass --setup-skills to add it).'
-            : 'Skipped Agentia workflow guidance.');
-        return {
-            agentsMd: {
-                path: existing.present ? relativePath : undefined,
-                present: existing.present,
-                status: existing.present ? 'unchanged' : 'skipped',
-            },
-        };
-    }
-    if (resolved.runSetupSkills === undefined) {
-        throw new Error('Agentia skills setup is unavailable.');
-    }
-    const setupSkills = await resolved.runSetupSkills({
-        cwd,
-        force: forceSkills,
-        log,
-        mode: 'update',
-        noPrompt,
-        targets: skillsTargets,
-    }, deps);
-    const written = await writeAgentsMd(root, deps);
-    const writtenRelative = path.relative(cwd, written.path) || 'AGENTS.md';
-    log(`AGENTS.md ${written.status} from the packaged template.`);
-    return {
-        agentsMd: {
-            path: writtenRelative,
-            present: existing.present,
-            status: written.status,
-        },
-        setupSkills,
-    };
-}
-export async function resolveProjectContext(cwd, deps = {}) {
-    const resolved = resolveDeps(deps);
-    const insideGit = await resolved.isInsideGitWorkTree();
-    if (!insideGit) {
-        return { cwd, insideGit, projectRoot: cwd };
-    }
-    const root = await resolved.getGitRepoRoot();
-    return {
-        cwd,
-        git: {
-            branch: await resolved.getCurrentBranch(),
-            remoteUrl: await resolved.getRemoteUrl('origin'),
-            root,
-        },
-        insideGit,
-        projectRoot: root,
-    };
-}
-export async function runProjectSetup(options = {}, deps = {}) {
-    const resolved = resolveDeps(deps);
-    const bin = options.bin ?? 'agentia';
-    const log = options.log ??
-        (() => {
-            /* no human output */
-        });
-    const noPrompt = options.noPrompt ?? false;
-    const cwd = options.cwd ?? process.cwd();
-    const context = await resolveProjectContext(cwd, deps);
-    const { insideGit, projectRoot } = context;
-    const { git } = context;
-    let gitignore;
-    if (insideGit && git !== undefined) {
-        log(`Directory: ${cwd}`);
-        log(`Git root:  ${git.root}`);
-        log(`Branch:    ${git.branch}`);
-        log(`Remote:    ${git.remoteUrl ?? '(no origin remote)'}`);
-        const ensured = await ensureAgentiaGitignore(git.root, deps);
-        logGitignoreResult(log, cwd, ensured);
-        gitignore = {
-            path: path.relative(cwd, ensured.path) || '.gitignore',
-            status: ensured.status,
-        };
-    }
-    else {
-        log(`Directory: ${cwd}`);
-        log('Not a git repository; skipped .gitignore updates.');
-        gitignore = { status: 'skipped' };
-    }
-    const qualityGates = await maybeCreateQualityGates({
-        bin,
-        cwd,
-        deps,
-        log,
-        noPrompt,
-        requested: options.createLocalQualityGates === true,
-        resolved,
-        root: projectRoot,
-    });
-    const workflow = await maybeSetupAgentiaWorkflow({
-        cwd,
-        deps,
-        forceSkills: options.forceSkills === true,
-        log,
-        noPrompt,
-        requested: options.createAgentsMd === true || options.setupSkills === true,
-        resolved,
-        root: projectRoot,
-        skillsTargets: options.skillsTargets,
-    });
-    return {
-        agentsMd: workflow.agentsMd,
-        cwd,
-        git,
-        gitignore,
-        projectRoot,
-        qualityGates,
-        setupSkills: workflow.setupSkills,
-    };
-}
-//# sourceMappingURL=project-setup.js.map
+import {modules} from './runtime.js';
+const createLocalQualityGateScripts = modules["project-setup.js"]["createLocalQualityGateScripts"]
+const ensureAgentiaGitignore = modules["project-setup.js"]["ensureAgentiaGitignore"]
+const findAgentsMd = modules["project-setup.js"]["findAgentsMd"]
+const findLocalQualityGateScripts = modules["project-setup.js"]["findLocalQualityGateScripts"]
+const gitignoreHasAgentiaEntry = modules["project-setup.js"]["gitignoreHasAgentiaEntry"]
+const resetProjectSetupDepsForTests = modules["project-setup.js"]["resetProjectSetupDepsForTests"]
+const resolveAgentsMdContent = modules["project-setup.js"]["resolveAgentsMdContent"]
+const resolveProjectContext = modules["project-setup.js"]["resolveProjectContext"]
+const runProjectSetup = modules["project-setup.js"]["runProjectSetup"]
+const setProjectSetupDepsForTests = modules["project-setup.js"]["setProjectSetupDepsForTests"]
+const writeAgentsMd = modules["project-setup.js"]["writeAgentsMd"]
+export {createLocalQualityGateScripts, ensureAgentiaGitignore, findAgentsMd, findLocalQualityGateScripts, gitignoreHasAgentiaEntry, resetProjectSetupDepsForTests, resolveAgentsMdContent, resolveProjectContext, runProjectSetup, setProjectSetupDepsForTests, writeAgentsMd};

package/dist/lib/project-types.js

@@ -1,54 +1,9 @@
-import { cellValue, table } from './format.js';
-import { appendListPaginationQueryParams, paginatedResultFromNestedData, } from './list-pagination.js';
-import { normalizeSalesforceId } from './salesforce-id.js';
-export function projectsListEndpoint(filters = {}) {
-    const params = new URLSearchParams();
-    if (filters.mine) {
-        params.set('mine', 'true');
-    }
-    if (filters.name !== undefined) {
-        params.set('name', filters.name);
-    }
-    appendListPaginationQueryParams(params, filters);
-    const query = params.toString();
-    return query.length > 0 ? `/plan/projects?${query}` : '/plan/projects';
-}
-export function projectEndpoint(id) {
-    return `/plan/projects/${normalizeSalesforceId(id)}`;
-}
-export function normalizeProjectsListPage(response) {
-    return paginatedResultFromNestedData(response);
-}
-export function normalizeProjects(response) {
-    return normalizeProjectsListPage(response).data;
-}
-export function normalizeProject(response) {
-    if ('data' in response && response.data !== undefined && typeof response.data === 'object' && !Array.isArray(response.data)) {
-        return response.data;
-    }
-    return response;
-}
-export function formatProjectTable(projects) {
-    return table([
-        { alias: 'ID', value: 'id' },
-        { alias: 'NAME', value: 'name' },
-        { alias: 'OWNER', value: 'ownerFullName' },
-        { alias: 'ACTIVITY', value: 'activityDate' },
-    ], projects.map((project) => ({
-        activityDate: cellValue(project.activityDate),
-        id: cellValue(project.id),
-        name: cellValue(project.name),
-        ownerFullName: cellValue(project.ownerFullName),
-    })));
-}
-export function formatProjectDetail(project) {
-    const lines = [
-        `ID: ${cellValue(project.id)}`,
-        `Name: ${cellValue(project.name)}`,
-        `Owner ID: ${cellValue(project.ownerId)}`,
-        `Owner: ${cellValue(project.ownerFullName)}`,
-        `Created Date: ${cellValue(project.createdDate)}`,
-    ];
-    return lines.join('\n');
-}
-//# sourceMappingURL=project-types.js.map
+import {modules} from './runtime.js';
+const formatProjectDetail = modules["project-types.js"]["formatProjectDetail"]
+const formatProjectTable = modules["project-types.js"]["formatProjectTable"]
+const normalizeProject = modules["project-types.js"]["normalizeProject"]
+const normalizeProjects = modules["project-types.js"]["normalizeProjects"]
+const normalizeProjectsListPage = modules["project-types.js"]["normalizeProjectsListPage"]
+const projectEndpoint = modules["project-types.js"]["projectEndpoint"]
+const projectsListEndpoint = modules["project-types.js"]["projectsListEndpoint"]
+export {formatProjectDetail, formatProjectTable, normalizeProject, normalizeProjects, normalizeProjectsListPage, projectEndpoint, projectsListEndpoint};

package/dist/lib/promotion-conflicts.js

@@ -1,83 +1,12 @@
-import { CicdGatewayError } from './cicd-gateway.js';
-import { cellValue, table } from './format.js';
-export const PROMOTION_CONFLICT_MODES = ['auto', 'manual'];
-const PROMOTION_CONFLICT_ERROR_MESSAGES = {
-    'PRO-003': 'You do not have permission to manage conflicts for this promotion.',
-    'PRO-004': 'Promotion or Conflict ID not found. Please verify your IDs.',
-    'PRO-005': 'Invalid resolution request. Ensure your manual content does not contain unresolved Git markers unless forceSaveWithMarkers is used.',
-    'PRO-016': 'Promotion or Conflict ID not found. Please verify your IDs.',
-    'PRO-025': 'Invalid resolution request. Ensure your manual content does not contain unresolved Git markers unless forceSaveWithMarkers is used.',
-    'PRO-026': 'Invalid resolution request. Ensure your manual content does not contain unresolved Git markers unless forceSaveWithMarkers is used.',
-};
-function endpointSegment(value, label) {
-    const trimmed = value.trim();
-    if (trimmed.length === 0) {
-        throw new Error(`${label} cannot be empty.`);
-    }
-    return encodeURIComponent(trimmed);
-}
-export function promotionConflictsEndpoint(promotionId) {
-    return `/release/promotion/${endpointSegment(promotionId, 'Promotion ID')}/conflicts`;
-}
-export function promotionConflictContentEndpoint(promotionId, conflictId) {
-    return `${promotionConflictsEndpoint(promotionId)}/${endpointSegment(conflictId, 'Conflict ID')}/content`;
-}
-export function promotionConflictResolveEndpoint(promotionId, conflictId) {
-    return `${promotionConflictsEndpoint(promotionId)}/${endpointSegment(conflictId, 'Conflict ID')}/resolve`;
-}
-export function promotionConflictUndoEndpoint(promotionId, conflictId) {
-    return `${promotionConflictsEndpoint(promotionId)}/${endpointSegment(conflictId, 'Conflict ID')}/undo-resolution`;
-}
-export function normalizePromotionConflicts(response) {
-    if (Array.isArray(response)) {
-        return response;
-    }
-    return Array.isArray(response.data) ? response.data : [];
-}
-export function buildPromotionConflictResolutionRequest(mode, content) {
-    if (mode === 'auto') {
-        return { mode };
-    }
-    if (content === undefined) {
-        throw new Error('--file is required when --mode manual is used.');
-    }
-    return {
-        content,
-        forceSaveWithMarkers: false,
-        mode,
-    };
-}
-export function formatPromotionConflictTable(conflicts) {
-    return table([
-        { alias: 'CONFLICT ID', value: 'attachmentId' },
-        { alias: 'USER STORY', value: 'userStory' },
-        { alias: 'TYPE', value: 'metadataType' },
-        { alias: 'NAME', value: 'metadataName' },
-        { alias: 'STATUS', value: 'resolutionStrategy' },
-    ], conflicts.map((conflict) => ({
-        attachmentId: cellValue(conflict.attachmentId),
-        metadataName: cellValue(conflict.metadataName),
-        metadataType: cellValue(conflict.metadataType),
-        resolutionStrategy: cellValue(conflict.resolutionStrategy),
-        userStory: cellValue(conflict.userStory),
-    })));
-}
-export function translatePromotionConflictError(error) {
-    if (error instanceof CicdGatewayError) {
-        const identifiers = [error.code, ...error.categories];
-        const identifier = identifiers.find((value) => value !== undefined && value in PROMOTION_CONFLICT_ERROR_MESSAGES);
-        if (identifier !== undefined) {
-            return new Error(PROMOTION_CONFLICT_ERROR_MESSAGES[identifier]);
-        }
-    }
-    return error instanceof Error ? error : new Error(String(error));
-}
-export async function withPromotionConflictErrorTranslation(action) {
-    try {
-        return await action();
-    }
-    catch (error) {
-        throw translatePromotionConflictError(error);
-    }
-}
-//# sourceMappingURL=promotion-conflicts.js.map
+import {modules} from './runtime.js';
+const PROMOTION_CONFLICT_MODES = modules["promotion-conflicts.js"]["PROMOTION_CONFLICT_MODES"]
+const buildPromotionConflictResolutionRequest = modules["promotion-conflicts.js"]["buildPromotionConflictResolutionRequest"]
+const formatPromotionConflictTable = modules["promotion-conflicts.js"]["formatPromotionConflictTable"]
+const normalizePromotionConflicts = modules["promotion-conflicts.js"]["normalizePromotionConflicts"]
+const promotionConflictContentEndpoint = modules["promotion-conflicts.js"]["promotionConflictContentEndpoint"]
+const promotionConflictResolveEndpoint = modules["promotion-conflicts.js"]["promotionConflictResolveEndpoint"]
+const promotionConflictUndoEndpoint = modules["promotion-conflicts.js"]["promotionConflictUndoEndpoint"]
+const promotionConflictsEndpoint = modules["promotion-conflicts.js"]["promotionConflictsEndpoint"]
+const translatePromotionConflictError = modules["promotion-conflicts.js"]["translatePromotionConflictError"]
+const withPromotionConflictErrorTranslation = modules["promotion-conflicts.js"]["withPromotionConflictErrorTranslation"]
+export {PROMOTION_CONFLICT_MODES, buildPromotionConflictResolutionRequest, formatPromotionConflictTable, normalizePromotionConflicts, promotionConflictContentEndpoint, promotionConflictResolveEndpoint, promotionConflictUndoEndpoint, promotionConflictsEndpoint, translatePromotionConflictError, withPromotionConflictErrorTranslation};

package/dist/lib/promotion-flags.js

@@ -1,76 +1,4 @@
-import { Flags } from '@oclif/core';
-import { buildListPaginationQuery, listPaginationFlags } from './list-pagination.js';
-export const promotionListFilterFlags = {
-    ...listPaginationFlags,
-    'created-by-id': Flags.string({
-        description: 'Filter by creator ID',
-    }),
-    'created-by-name': Flags.string({
-        description: 'Filter by creator name',
-    }),
-    'destination-environment-id': Flags.string({
-        description: 'Filter by destination environment ID',
-    }),
-    'destination-environment-name': Flags.string({
-        description: 'Filter by destination environment name',
-    }),
-    'is-back-promotion': Flags.boolean({
-        allowNo: true,
-        description: 'Filter by back promotion',
-    }),
-    name: Flags.string({
-        description: 'Filter by name',
-    }),
-    'pipeline-id': Flags.string({
-        description: 'Filter by pipeline ID',
-    }),
-    'pipeline-name': Flags.string({
-        description: 'Filter by pipeline name',
-    }),
-    'project-id': Flags.string({
-        description: 'Filter by project ID',
-    }),
-    'project-name': Flags.string({
-        description: 'Filter by project name',
-    }),
-    'source-environment-id': Flags.string({
-        description: 'Filter by source environment ID',
-    }),
-    'source-environment-name': Flags.string({
-        description: 'Filter by source environment name',
-    }),
-    status: Flags.string({
-        description: 'Filter by status',
-    }),
-    'work-id': Flags.string({
-        description: 'Filter by user story ID',
-    }),
-};
-const PROMOTION_LIST_FILTER_FLAG_TO_KEY = {
-    'created-by-id': 'createdById',
-    'created-by-name': 'createdByName',
-    'destination-environment-id': 'destinationEnvironmentId',
-    'destination-environment-name': 'destinationEnvironmentName',
-    'is-back-promotion': 'isBackPromotion',
-    name: 'name',
-    'pipeline-id': 'pipelineId',
-    'pipeline-name': 'pipelineName',
-    'project-id': 'projectId',
-    'project-name': 'projectName',
-    'source-environment-id': 'sourceEnvironmentId',
-    'source-environment-name': 'sourceEnvironmentName',
-    status: 'status',
-    'work-id': 'userStoryId',
-};
-export function buildPromotionListFilters(flags) {
-    const filters = {};
-    for (const flagKey of Object.keys(PROMOTION_LIST_FILTER_FLAG_TO_KEY)) {
-        const value = flags[flagKey];
-        if (value !== undefined) {
-            const filterKey = PROMOTION_LIST_FILTER_FLAG_TO_KEY[flagKey];
-            Object.assign(filters, { [filterKey]: value });
-        }
-    }
-    return { ...filters, ...buildListPaginationQuery(flags) };
-}
-//# sourceMappingURL=promotion-flags.js.map
+import {modules} from './runtime.js';
+const buildPromotionListFilters = modules["promotion-flags.js"]["buildPromotionListFilters"]
+const promotionListFilterFlags = modules["promotion-flags.js"]["promotionListFilterFlags"]
+export {buildPromotionListFilters, promotionListFilterFlags};

package/dist/lib/promotion-job-steps.js

@@ -0,0 +1,5 @@
+import {modules} from './runtime.js';
+const PROMOTION_MANUAL_TASK_STATUSES = modules["promotion-job-steps.js"]["PROMOTION_MANUAL_TASK_STATUSES"]
+const buildPromotionManualTaskUpdatePayload = modules["promotion-job-steps.js"]["buildPromotionManualTaskUpdatePayload"]
+const promotionManualTaskEndpoint = modules["promotion-job-steps.js"]["promotionManualTaskEndpoint"]
+export {PROMOTION_MANUAL_TASK_STATUSES, buildPromotionManualTaskUpdatePayload, promotionManualTaskEndpoint};