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

package/dist/lib/job-types.js

@@ -1,211 +1,26 @@
-import { cellValue, table } from './format.js';
-import { appendListPaginationQueryParams, paginatedResultFromNestedData, } from './list-pagination.js';
-import { normalizeSalesforceId } from './salesforce-id.js';
-export const JOB_LIST_PAGE_SIZE_MAX = 200;
-export const JOB_LIST_PAGE_SIZE_MIN = 1;
-const JOB_RESULT_FILE_ID_PATTERN = /^[A-Za-z0-9]{15}(?:[A-Za-z0-9]{3})?$/;
-export function jobListEndpoint(filters = {}) {
-    const params = new URLSearchParams();
-    if (filters.id) {
-        params.set('id', normalizeSalesforceId(filters.id));
-    }
-    if (filters.name) {
-        params.set('name', filters.name);
-    }
-    if (filters.type) {
-        params.set('type', filters.type);
-    }
-    if (filters.status) {
-        params.set('status', filters.status);
-    }
-    if (filters.context) {
-        params.set('context', filters.context);
-    }
-    if (filters.parent) {
-        params.set('parent', normalizeSalesforceId(filters.parent));
-    }
-    if (filters.ownerId) {
-        params.set('ownerId', normalizeSalesforceId(filters.ownerId));
-    }
-    appendListPaginationQueryParams(params, filters);
-    const query = params.toString();
-    return query.length > 0 ? `/release/jobs?${query}` : '/release/jobs';
-}
-export function jobEndpoint(jobId) {
-    return `/release/jobs/${normalizeSalesforceId(jobId)}`;
-}
-export function jobRunEndpoint(jobId, restart) {
-    const normalizedJobId = normalizeSalesforceId(jobId);
-    if (restart) {
-        return `/release/jobs/${normalizedJobId}/run?restart=true`;
-    }
-    return `/release/jobs/${normalizedJobId}/run`;
-}
-export function jobResumeEndpoint(jobId) {
-    return `/release/jobs/${normalizeSalesforceId(jobId)}/resume`;
-}
-export function jobKillEndpoint(jobId) {
-    return `/release/jobs/${normalizeSalesforceId(jobId)}/kill`;
-}
-export function jobPauseEndpoint(jobId) {
-    return `/release/jobs/${normalizeSalesforceId(jobId)}/pause`;
-}
-export function jobResultLogEndpoint(resultId) {
-    return `/release/job-monitor/result/${resultId.trim()}/log-file`;
-}
-export function jobResultFilesEndpoint(resultId) {
-    return `/release/job-monitor/result/${validateJobResultFileId(resultId, 'Result')}/files`;
-}
-export function jobResultFileContentEndpoint(resultId, fileId) {
-    return `${jobResultFilesEndpoint(resultId)}/${validateJobResultFileId(fileId, 'File')}`;
-}
-function validateJobResultFileId(value, label) {
-    const trimmed = value.trim();
-    if (!JOB_RESULT_FILE_ID_PATTERN.test(trimmed)) {
-        throw new Error(`${label} Id must be a 15- or 18-character Salesforce Id.`);
-    }
-    return trimmed;
-}
-export function jobStepResultId(step) {
-    const fromStep = step.resultId?.trim();
-    if (fromStep !== undefined && fromStep.length > 0) {
-        return fromStep;
-    }
-    const fromResult = step.result?.id?.trim();
-    if (fromResult !== undefined && fromResult.length > 0) {
-        return fromResult;
-    }
-    return undefined;
-}
-export function resolveJobStepForLog(steps, stepId) {
-    const list = steps ?? [];
-    if (stepId !== undefined && stepId.trim().length > 0) {
-        const normalizedStepId = normalizeSalesforceId(stepId);
-        const step = list.find((candidate) => {
-            if (candidate.id === undefined || candidate.id === null) {
-                return false;
-            }
-            return normalizeSalesforceId(candidate.id) === normalizedStepId;
-        });
-        if (step === undefined) {
-            throw new Error(`Job step not found: ${stepId}`);
-        }
-        const resultId = jobStepResultId(step);
-        if (resultId === undefined) {
-            throw new Error(`Job step "${stepId}" has no result Id.`);
-        }
-        return { resultId, step };
-    }
-    for (const step of list) {
-        const resultId = jobStepResultId(step);
-        if (resultId !== undefined) {
-            return { resultId, step };
-        }
-    }
-    throw new Error('No job step with a result Id was found.');
-}
-export function normalizeJobsListPage(response) {
-    return paginatedResultFromNestedData(response);
-}
-export function normalizeJobs(response) {
-    return normalizeJobsListPage(response).data;
-}
-export function normalizeJob(response) {
-    if ('data' in response && response.data !== undefined && typeof response.data === 'object' && !Array.isArray(response.data)) {
-        return response.data;
-    }
-    return response;
-}
-export function normalizeJobOperation(response) {
-    if ('data' in response && response.data !== undefined && typeof response.data === 'object' && !Array.isArray(response.data)) {
-        return response.data;
-    }
-    return response;
-}
-export function normalizeJobResultFiles(response) {
-    if (Array.isArray(response)) {
-        return response;
-    }
-    if (Array.isArray(response.files)) {
-        return response.files;
-    }
-    if (Array.isArray(response.data)) {
-        return response.data;
-    }
-    if (response.data !== undefined && Array.isArray(response.data.files)) {
-        return response.data.files;
-    }
-    return [];
-}
-export function normalizeJobResultFileContent(response) {
-    if ('data' in response && response.data !== undefined && typeof response.data === 'object') {
-        return response.data;
-    }
-    return response;
-}
-export function decodeJobResultFileBase64(value) {
-    if (value === undefined || value === null) {
-        throw new Error('Result file content is missing base64 data.');
-    }
-    if (!/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value)) {
-        throw new Error('Result file content contains malformed base64 data.');
-    }
-    return Buffer.from(value, 'base64');
-}
-export function formatJobResultFileTable(files) {
-    return table([
-        { alias: 'FILE NAME', value: 'fileName' },
-        { alias: 'TYPE', value: 'fileType' },
-        { alias: 'SIZE', value: 'contentSize' },
-        { alias: 'MODIFIED', value: 'lastModifiedDate' },
-    ], files.map((file) => ({
-        contentSize: cellValue(file.contentSize),
-        fileName: cellValue(file.fileName ?? file.title),
-        fileType: cellValue(file.fileType ?? file.fileExtension),
-        lastModifiedDate: cellValue(file.lastModifiedDate),
-    })));
-}
-export function formatJobTable(jobs) {
-    return table([
-        { alias: 'ID', value: 'id' },
-        { alias: 'NAME', value: 'name' },
-        { alias: 'STATUS', value: 'status' },
-        { alias: 'TEMPLATE', value: 'template' },
-        { alias: 'PARENT ID', value: 'parentId' },
-        { alias: 'CREATED', value: 'createdDate' },
-    ], jobs.map((job) => ({
-        createdDate: cellValue(job.createdDate),
-        id: cellValue(job.id),
-        name: cellValue(job.name),
-        parentId: cellValue(job.parentId),
-        status: cellValue(job.status),
-        template: cellValue(job.template?.name),
-    })));
-}
-export function formatJobDetail(job) {
-    const lines = [
-        `ID: ${cellValue(job.id)}`,
-        `Name: ${cellValue(job.name)}`,
-        `Status: ${cellValue(job.status)}`,
-        `Template ID: ${cellValue(job.template?.id)}`,
-        `Template Name: ${cellValue(job.template?.name)}`,
-        `Parent ID: ${cellValue(job.parentId)}`,
-        `Created: ${cellValue(job.createdDate)}`,
-        `Last Modified: ${cellValue(job.lastModifiedDate)}`,
-        `Error: ${cellValue(job.errorMessage)}`,
-        `Steps: ${cellValue(job.steps?.length ?? 0)}`,
-    ];
-    for (const step of job.steps ?? []) {
-        lines.push(`  Step ${cellValue(step.order)}: ${cellValue(step.name)} [${cellValue(step.status)}] type=${cellValue(step.type)} result=${cellValue(step.result?.status)}`);
-    }
-    return lines.join('\n');
-}
-export function formatJobOperationResult(result) {
-    return [
-        `Job ID: ${cellValue(result.jobId)}`,
-        `Operation: ${cellValue(result.operation)}`,
-        `Status: ${cellValue(result.status)}`,
-        `Message: ${cellValue(result.message)}`,
-    ].join('\n');
-}
-//# sourceMappingURL=job-types.js.map
+import {modules} from './runtime.js';
+const JOB_LIST_PAGE_SIZE_MAX = modules["job-types.js"]["JOB_LIST_PAGE_SIZE_MAX"]
+const JOB_LIST_PAGE_SIZE_MIN = modules["job-types.js"]["JOB_LIST_PAGE_SIZE_MIN"]
+const decodeJobResultFileBase64 = modules["job-types.js"]["decodeJobResultFileBase64"]
+const formatJobDetail = modules["job-types.js"]["formatJobDetail"]
+const formatJobOperationResult = modules["job-types.js"]["formatJobOperationResult"]
+const formatJobResultFileTable = modules["job-types.js"]["formatJobResultFileTable"]
+const formatJobTable = modules["job-types.js"]["formatJobTable"]
+const jobEndpoint = modules["job-types.js"]["jobEndpoint"]
+const jobKillEndpoint = modules["job-types.js"]["jobKillEndpoint"]
+const jobListEndpoint = modules["job-types.js"]["jobListEndpoint"]
+const jobPauseEndpoint = modules["job-types.js"]["jobPauseEndpoint"]
+const jobResultFileContentEndpoint = modules["job-types.js"]["jobResultFileContentEndpoint"]
+const jobResultFilesEndpoint = modules["job-types.js"]["jobResultFilesEndpoint"]
+const jobResultLogEndpoint = modules["job-types.js"]["jobResultLogEndpoint"]
+const jobResumeEndpoint = modules["job-types.js"]["jobResumeEndpoint"]
+const jobRunEndpoint = modules["job-types.js"]["jobRunEndpoint"]
+const jobStepResultId = modules["job-types.js"]["jobStepResultId"]
+const normalizeJob = modules["job-types.js"]["normalizeJob"]
+const normalizeJobOperation = modules["job-types.js"]["normalizeJobOperation"]
+const normalizeJobResultFileContent = modules["job-types.js"]["normalizeJobResultFileContent"]
+const normalizeJobResultFiles = modules["job-types.js"]["normalizeJobResultFiles"]
+const normalizeJobs = modules["job-types.js"]["normalizeJobs"]
+const normalizeJobsListPage = modules["job-types.js"]["normalizeJobsListPage"]
+const resolveJobStepForLog = modules["job-types.js"]["resolveJobStepForLog"]
+export {JOB_LIST_PAGE_SIZE_MAX, JOB_LIST_PAGE_SIZE_MIN, decodeJobResultFileBase64, formatJobDetail, formatJobOperationResult, formatJobResultFileTable, formatJobTable, jobEndpoint, jobKillEndpoint, jobListEndpoint, jobPauseEndpoint, jobResultFileContentEndpoint, jobResultFilesEndpoint, jobResultLogEndpoint, jobResumeEndpoint, jobRunEndpoint, jobStepResultId, normalizeJob, normalizeJobOperation, normalizeJobResultFileContent, normalizeJobResultFiles, normalizeJobs, normalizeJobsListPage, resolveJobStepForLog};

package/dist/lib/list-pagination.js

@@ -1,106 +1,16 @@
-import { Flags } from '@oclif/core';
-import { z } from 'zod';
-export const LIST_PAGE_SIZE_MAX = 200;
-export const LIST_PAGE_SIZE_MIN = 1;
-export const listPaginationFlags = {
-    cursor: Flags.string({
-        description: 'Opaque pagination cursor from a previous list response (nextCursor)',
-    }),
-    'page-size': Flags.integer({
-        description: `Number of records per page (${LIST_PAGE_SIZE_MIN}-${LIST_PAGE_SIZE_MAX})`,
-        max: LIST_PAGE_SIZE_MAX,
-        min: LIST_PAGE_SIZE_MIN,
-    }),
-};
-export const listPaginationZodFields = {
-    cursor: z.string().optional().describe('Opaque pagination cursor from a previous list response (nextCursor).'),
-    pageSize: z
-        .number()
-        .int()
-        .min(LIST_PAGE_SIZE_MIN)
-        .max(LIST_PAGE_SIZE_MAX)
-        .optional()
-        .describe(`Number of records per page (${LIST_PAGE_SIZE_MIN}-${LIST_PAGE_SIZE_MAX}).`),
-};
-export function buildListPaginationQuery(flags) {
-    const query = {};
-    if (flags.cursor !== undefined) {
-        query.cursor = flags.cursor;
-    }
-    if (flags['page-size'] !== undefined) {
-        query.pageSize = flags['page-size'];
-    }
-    return query;
-}
-export function appendListPaginationQueryParams(params, pagination = {}) {
-    if (pagination.cursor !== undefined) {
-        params.set('cursor', pagination.cursor);
-    }
-    if (pagination.pageSize !== undefined) {
-        params.set('pageSize', String(pagination.pageSize));
-    }
-}
-export function pickCursorPageMeta(source) {
-    if (source === undefined) {
-        return {};
-    }
-    const meta = {};
-    for (const key of ['currentPage', 'pageSize', 'totalPages', 'totalRecords', 'hasMore', 'nextCursor']) {
-        const value = source[key];
-        if (value !== undefined) {
-            Object.assign(meta, { [key]: value });
-        }
-    }
-    return meta;
-}
-export function buildPaginatedListResult(data, meta = {}) {
-    return { data, ...meta };
-}
-export function paginatedResultFromPage(page) {
-    return buildPaginatedListResult(page?.data ?? [], pickCursorPageMeta(page));
-}
-export function paginatedResultFromNestedData(response) {
-    if (Array.isArray(response)) {
-        return buildPaginatedListResult(response);
-    }
-    if (Array.isArray(response.data)) {
-        return buildPaginatedListResult(response.data, pickCursorPageMeta(response));
-    }
-    if (response.data !== undefined && typeof response.data === 'object' && Array.isArray(response.data.data)) {
-        return paginatedResultFromPage(response.data);
-    }
-    return buildPaginatedListResult([]);
-}
-export function formatListPageFooter(meta) {
-    const { currentPage, pageSize, totalPages, totalRecords } = meta;
-    if (totalRecords === undefined) {
-        return undefined;
-    }
-    const parts = [`Total: ${totalRecords}`];
-    if (currentPage !== undefined && totalPages !== undefined) {
-        parts.push(`Page: ${currentPage}/${totalPages}`);
-    }
-    if (pageSize !== undefined) {
-        parts.push(`Size: ${pageSize}`);
-    }
-    return parts.join(', ');
-}
-export function formatListContinuationHint(nextCursor) {
-    return `More results available. Pass --cursor ${nextCursor} to fetch the next page.`;
-}
-export function displayListPagination(log, meta) {
-    const footer = formatListPageFooter(meta);
-    if (footer !== undefined) {
-        log(footer);
-    }
-    if (meta.hasMore === true && meta.nextCursor !== undefined && meta.nextCursor.length > 0) {
-        log(formatListContinuationHint(meta.nextCursor));
-    }
-}
-export function mcpPaginatedListPayload(itemsKey, page) {
-    return {
-        [itemsKey]: page.data,
-        ...pickCursorPageMeta(page),
-    };
-}
-//# sourceMappingURL=list-pagination.js.map
+import {modules} from './runtime.js';
+const LIST_PAGE_SIZE_MAX = modules["list-pagination.js"]["LIST_PAGE_SIZE_MAX"]
+const LIST_PAGE_SIZE_MIN = modules["list-pagination.js"]["LIST_PAGE_SIZE_MIN"]
+const appendListPaginationQueryParams = modules["list-pagination.js"]["appendListPaginationQueryParams"]
+const buildListPaginationQuery = modules["list-pagination.js"]["buildListPaginationQuery"]
+const buildPaginatedListResult = modules["list-pagination.js"]["buildPaginatedListResult"]
+const displayListPagination = modules["list-pagination.js"]["displayListPagination"]
+const formatListContinuationHint = modules["list-pagination.js"]["formatListContinuationHint"]
+const formatListPageFooter = modules["list-pagination.js"]["formatListPageFooter"]
+const listPaginationFlags = modules["list-pagination.js"]["listPaginationFlags"]
+const listPaginationZodFields = modules["list-pagination.js"]["listPaginationZodFields"]
+const mcpPaginatedListPayload = modules["list-pagination.js"]["mcpPaginatedListPayload"]
+const paginatedResultFromNestedData = modules["list-pagination.js"]["paginatedResultFromNestedData"]
+const paginatedResultFromPage = modules["list-pagination.js"]["paginatedResultFromPage"]
+const pickCursorPageMeta = modules["list-pagination.js"]["pickCursorPageMeta"]
+export {LIST_PAGE_SIZE_MAX, LIST_PAGE_SIZE_MIN, appendListPaginationQueryParams, buildListPaginationQuery, buildPaginatedListResult, displayListPagination, formatListContinuationHint, formatListPageFooter, listPaginationFlags, listPaginationZodFields, mcpPaginatedListPayload, paginatedResultFromNestedData, paginatedResultFromPage, pickCursorPageMeta};

package/dist/lib/local-gateway-config.js

@@ -1,53 +1,8 @@
-import { loadEnvFile } from './env-file.js';
-export const DEFAULT_LOCAL_GATEWAY_URL = 'http://localhost:8000';
-export function normalizeLocalGatewayBaseUrl(value) {
-    let url;
-    try {
-        url = new URL(value);
-    }
-    catch {
-        throw new Error('Local gateway URL must be a valid absolute HTTP or HTTPS URL.');
-    }
-    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
-        throw new Error('Local gateway URL must use HTTP or HTTPS.');
-    }
-    return url.origin;
-}
-export const DEFAULT_LOCAL_SF_ORG_ALIAS = 'test14';
-export const LOCAL_GATEWAY_ENV = {
-    apiKey: 'AGENTIA_LOCAL_API_KEY',
-    orgAlias: 'AGENTIA_LOCAL_SF_ORG_ALIAS',
-    tlsInsecure: 'AGENTIA_LOCAL_GATEWAY_TLS_INSECURE',
-    url: 'AGENTIA_LOCAL_GATEWAY_URL',
-    useLocal: 'AGENTIA_USE_LOCAL_GATEWAY',
-};
-function isTruthyEnv(value) {
-    if (value === undefined) {
-        return false;
-    }
-    const normalized = value.trim().toLowerCase();
-    return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
-}
-export function readLocalGatewayConfig(env = process.env, options = {}) {
-    if (options.loadFile !== false && env === process.env) {
-        loadEnvFile();
-    }
-    const enabled = isTruthyEnv(env[LOCAL_GATEWAY_ENV.useLocal]);
-    const url = env[LOCAL_GATEWAY_ENV.url]?.trim() || DEFAULT_LOCAL_GATEWAY_URL;
-    const orgAlias = env[LOCAL_GATEWAY_ENV.orgAlias]?.trim() || DEFAULT_LOCAL_SF_ORG_ALIAS;
-    const apiKey = env[LOCAL_GATEWAY_ENV.apiKey]?.trim() || undefined;
-    const tlsInsecure = env[LOCAL_GATEWAY_ENV.tlsInsecure] === undefined
-        ? true
-        : isTruthyEnv(env[LOCAL_GATEWAY_ENV.tlsInsecure]);
-    return {
-        apiKey,
-        enabled,
-        orgAlias,
-        tlsInsecure,
-        url,
-    };
-}
-export function isLocalGatewayEnabled(env = process.env) {
-    return readLocalGatewayConfig(env).enabled;
-}
-//# sourceMappingURL=local-gateway-config.js.map
+import {modules} from './runtime.js';
+const DEFAULT_LOCAL_GATEWAY_URL = modules["local-gateway-config.js"]["DEFAULT_LOCAL_GATEWAY_URL"]
+const DEFAULT_LOCAL_SF_ORG_ALIAS = modules["local-gateway-config.js"]["DEFAULT_LOCAL_SF_ORG_ALIAS"]
+const LOCAL_GATEWAY_ENV = modules["local-gateway-config.js"]["LOCAL_GATEWAY_ENV"]
+const isLocalGatewayEnabled = modules["local-gateway-config.js"]["isLocalGatewayEnabled"]
+const normalizeLocalGatewayBaseUrl = modules["local-gateway-config.js"]["normalizeLocalGatewayBaseUrl"]
+const readLocalGatewayConfig = modules["local-gateway-config.js"]["readLocalGatewayConfig"]
+export {DEFAULT_LOCAL_GATEWAY_URL, DEFAULT_LOCAL_SF_ORG_ALIAS, LOCAL_GATEWAY_ENV, isLocalGatewayEnabled, normalizeLocalGatewayBaseUrl, readLocalGatewayConfig};

package/dist/lib/local-metadata-paths.js

@@ -1,77 +1,3 @@
-import { execFile } from 'node:child_process';
-import { readdir } from 'node:fs/promises';
-import { join, relative } from 'node:path';
-import { promisify } from 'node:util';
-import { resolveChangedPath } from './dependency-from-changes.js';
-const IGNORED_DIRECTORIES = new Set(['.agents', '.git', 'node_modules']);
-const FALLBACK_METADATA_ROOTS = new Set(['force-app', 'force-apps', 'main', 'mdapi', 'src', 'vlocity']);
-const execFileAsync = promisify(execFile);
-function selectionKey(selection) {
-    return `${selection.type}:${selection.name}`;
-}
-async function collectFiles(root, directory = root) {
-    const entries = await readdir(directory, { withFileTypes: true });
-    const files = [];
-    for (const entry of entries) {
-        if (entry.isDirectory()) {
-            if (!IGNORED_DIRECTORIES.has(entry.name)) {
-                // eslint-disable-next-line no-await-in-loop
-                files.push(...(await collectFiles(root, join(directory, entry.name))));
-            }
-            continue;
-        }
-        if (entry.isFile()) {
-            files.push(relative(root, join(directory, entry.name)));
-        }
-    }
-    return files;
-}
-async function collectLocalFiles(root) {
-    try {
-        const { stdout } = await execFileAsync('git', [
-            '-C',
-            root,
-            'ls-files',
-            '--cached',
-            '--others',
-            '--exclude-standard',
-        ]);
-        return stdout
-            .split(/\r?\n/)
-            .map((path) => path.trim())
-            .filter(Boolean);
-    }
-    catch {
-        const entries = await readdir(root, { withFileTypes: true });
-        const metadataRoots = entries
-            .filter((entry) => entry.isDirectory() && FALLBACK_METADATA_ROOTS.has(entry.name))
-            .map((entry) => join(root, entry.name));
-        const files = await Promise.all(metadataRoots.map((directory) => collectFiles(root, directory)));
-        return files.flat();
-    }
-}
-export async function findLocalMetadataPaths(root, targets, moduleType) {
-    const targetKeys = new Set(targets.map((target) => selectionKey(target)));
-    const pathsBySelection = new Map();
-    if (targetKeys.size === 0) {
-        return pathsBySelection;
-    }
-    for (const localPath of await collectLocalFiles(root)) {
-        const normalizedPath = localPath.replaceAll('\\', '/');
-        const selection = resolveChangedPath(normalizedPath, moduleType);
-        if (!selection) {
-            continue;
-        }
-        const key = selectionKey(selection);
-        if (targetKeys.has(key)) {
-            const paths = pathsBySelection.get(key) ?? [];
-            paths.push(normalizedPath);
-            pathsBySelection.set(key, paths);
-        }
-    }
-    for (const [key, paths] of pathsBySelection) {
-        pathsBySelection.set(key, [...new Set(paths)].sort());
-    }
-    return pathsBySelection;
-}
-//# sourceMappingURL=local-metadata-paths.js.map
+import {modules} from './runtime.js';
+const findLocalMetadataPaths = modules["local-metadata-paths.js"]["findLocalMetadataPaths"]
+export {findLocalMetadataPaths};

package/dist/lib/local-quality-gates.js

@@ -1,133 +1,13 @@
-import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { platform as osPlatform } from 'node:os';
-import path from 'node:path';
-import { getMcpRequestSignal } from './mcp/request-context.js';
-export const QUALITY_GATES_SCRIPT_UNIX = '.agentia_quality_gates.sh';
-export const QUALITY_GATES_SCRIPT_WINDOWS = '.agentia_quality_gates.cmd';
-export const AGENTIA_APEX_TEST_CLASSES_ENV = 'AGENTIA_APEX_TEST_CLASSES';
-export class LocalQualityGatesError extends Error {
-    exitCode;
-    output;
-    scriptPath;
-    constructor(message, options) {
-        super(message);
-        this.name = 'LocalQualityGatesError';
-        this.exitCode = options.exitCode;
-        this.output = options.output;
-        this.scriptPath = options.scriptPath;
-    }
-}
-let spawnFn = spawn;
-let existsSyncFn = existsSync;
-// Test-only hook
-export function setLocalQualityGatesSpawnForTests(nextSpawn) {
-    spawnFn = nextSpawn ?? spawn;
-}
-// Test-only hook
-export function setLocalQualityGatesExistsSyncForTests(nextExists) {
-    existsSyncFn = nextExists ?? existsSync;
-}
-// Test-only hook
-export function resetLocalQualityGatesForTests() {
-    spawnFn = spawn;
-    existsSyncFn = existsSync;
-}
-export function qualityGatesScriptName(currentPlatform = osPlatform()) {
-    return currentPlatform === 'win32' ? QUALITY_GATES_SCRIPT_WINDOWS : QUALITY_GATES_SCRIPT_UNIX;
-}
-export function resolveLocalQualityGatesScript(deps = {}) {
-    const cwd = deps.cwd ?? process.cwd();
-    const currentPlatform = deps.platform ?? osPlatform();
-    const exists = deps.existsSync ?? existsSyncFn;
-    const scriptPath = path.join(cwd, qualityGatesScriptName(currentPlatform));
-    return exists(scriptPath) ? scriptPath : undefined;
-}
-export function buildQualityGatesCommand(scriptPath, currentPlatform = osPlatform()) {
-    if (currentPlatform === 'win32') {
-        return { args: ['/c', scriptPath], command: 'cmd.exe' };
-    }
-    return { args: [scriptPath], command: 'bash' };
-}
-export async function runLocalQualityGates(options = {}) {
-    const scriptPath = options.scriptPath ?? resolveLocalQualityGatesScript(options);
-    if (scriptPath === undefined) {
-        return { ran: false, skipped: false };
-    }
-    if (options.skip) {
-        return { ran: false, scriptPath, skipped: true };
-    }
-    const cwd = options.cwd ?? process.cwd();
-    const currentPlatform = options.platform ?? osPlatform();
-    const runSpawn = options.spawn ?? spawnFn;
-    const signal = options.signal ?? getMcpRequestSignal();
-    const onOutput = options.onOutput ??
-        ((chunk) => {
-            process.stderr.write(chunk);
-        });
-    const { args, command } = buildQualityGatesCommand(scriptPath, currentPlatform);
-    const env = { ...process.env };
-    if (options.apexTestClasses !== undefined && options.apexTestClasses.length > 0) {
-        env[AGENTIA_APEX_TEST_CLASSES_ENV] = options.apexTestClasses;
-    }
-    return new Promise((resolve, reject) => {
-        const child = runSpawn(command, args, {
-            cwd,
-            env,
-            stdio: ['ignore', 'pipe', 'pipe'],
-            windowsHide: true,
-        });
-        let output = '';
-        let settled = false;
-        const finish = (action) => {
-            if (settled)
-                return;
-            settled = true;
-            signal?.removeEventListener('abort', abort);
-            action();
-        };
-        const abort = () => {
-            child.kill('SIGTERM');
-            finish(() => reject(new LocalQualityGatesError(`Local quality gates cancelled while running '${path.basename(scriptPath)}'.`, {
-                exitCode: 1,
-                output,
-                scriptPath,
-            })));
-        };
-        // Append stdout and stderr to one buffer in chunk arrival order (mixed as they came).
-        const append = (chunk) => {
-            const text = chunk.toString();
-            output += text;
-            onOutput(text);
-        };
-        child.stdout?.on('data', append);
-        child.stderr?.on('data', append);
-        child.once('error', (error) => {
-            finish(() => reject(new LocalQualityGatesError(`Failed to start local quality gates script '${path.basename(scriptPath)}': ${error.message}`, { exitCode: 1, output, scriptPath })));
-        });
-        child.once('close', (code, signal) => {
-            const exitCode = code === null ? (signal === null ? 0 : 1) : code;
-            if (exitCode !== 0) {
-                finish(() => reject(new LocalQualityGatesError([
-                    `Local quality gates failed (exit ${exitCode}) when running '${path.basename(scriptPath)}'.`,
-                    'Re-run with --skip-local-tests to bypass local gates.',
-                ].join(' '), { exitCode, output, scriptPath })));
-                return;
-            }
-            finish(() => resolve({
-                exitCode,
-                output,
-                ran: true,
-                scriptPath,
-                skipped: false,
-            }));
-        });
-        if (signal?.aborted) {
-            abort();
-        }
-        else {
-            signal?.addEventListener('abort', abort, { once: true });
-        }
-    });
-}
-//# sourceMappingURL=local-quality-gates.js.map
+import {modules} from './runtime.js';
+const AGENTIA_APEX_TEST_CLASSES_ENV = modules["local-quality-gates.js"]["AGENTIA_APEX_TEST_CLASSES_ENV"]
+const LocalQualityGatesError = modules["local-quality-gates.js"]["LocalQualityGatesError"]
+const QUALITY_GATES_SCRIPT_UNIX = modules["local-quality-gates.js"]["QUALITY_GATES_SCRIPT_UNIX"]
+const QUALITY_GATES_SCRIPT_WINDOWS = modules["local-quality-gates.js"]["QUALITY_GATES_SCRIPT_WINDOWS"]
+const buildQualityGatesCommand = modules["local-quality-gates.js"]["buildQualityGatesCommand"]
+const qualityGatesScriptName = modules["local-quality-gates.js"]["qualityGatesScriptName"]
+const resetLocalQualityGatesForTests = modules["local-quality-gates.js"]["resetLocalQualityGatesForTests"]
+const resolveLocalQualityGatesScript = modules["local-quality-gates.js"]["resolveLocalQualityGatesScript"]
+const runLocalQualityGates = modules["local-quality-gates.js"]["runLocalQualityGates"]
+const setLocalQualityGatesExistsSyncForTests = modules["local-quality-gates.js"]["setLocalQualityGatesExistsSyncForTests"]
+const setLocalQualityGatesSpawnForTests = modules["local-quality-gates.js"]["setLocalQualityGatesSpawnForTests"]
+export {AGENTIA_APEX_TEST_CLASSES_ENV, LocalQualityGatesError, QUALITY_GATES_SCRIPT_UNIX, QUALITY_GATES_SCRIPT_WINDOWS, buildQualityGatesCommand, qualityGatesScriptName, resetLocalQualityGatesForTests, resolveLocalQualityGatesScript, runLocalQualityGates, setLocalQualityGatesExistsSyncForTests, setLocalQualityGatesSpawnForTests};