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

package/dist/lib/pipeline-types.js

@@ -1,118 +1,18 @@
-import { cellValue, table } from './format.js';
-import { appendListPaginationQueryParams, paginatedResultFromNestedData, } from './list-pagination.js';
-import { preferSalesforceId } from './salesforce-id.js';
-export const PIPELINE_PLATFORMS = [
-    'Salesforce',
-    'SFDX',
-    'Heroku',
-    'Mulesoft',
-    'Marketing',
-    'Other',
-];
-export const PIPELINE_CALCULATE_BASED_ON_VALUES = ['User Story', 'Branch'];
-export const PIPELINE_CONNECTION_SYNC_STATE_NEEDS_RECALCULATING = 'Needs recalculating';
-export function pipelineListEndpoint(filters = {}) {
-    const params = new URLSearchParams();
-    if (filters.name !== undefined) {
-        params.set('name', filters.name);
-    }
-    if (filters.active !== undefined) {
-        params.set('active', String(filters.active));
-    }
-    if (filters.platform !== undefined) {
-        params.set('platform', filters.platform);
-    }
-    appendListPaginationQueryParams(params, filters);
-    const query = params.toString();
-    return query.length > 0 ? `/corpus/pipelines?${query}` : '/corpus/pipelines';
-}
-export function pipelineEndpoint(id) {
-    return `/corpus/pipelines/${encodeURIComponent(preferSalesforceId(id))}`;
-}
-export function pipelineDescribeEndpoint(id) {
-    return `${pipelineEndpoint(id)}/describe`;
-}
-export function pipelineConnectionsEndpoint(pipelineId) {
-    return `${pipelineEndpoint(pipelineId)}/connections`;
-}
-export function normalizePipelinesListPage(response) {
-    return paginatedResultFromNestedData(response);
-}
-export function normalizePipelines(response) {
-    return normalizePipelinesListPage(response).data;
-}
-export function normalizePipeline(response) {
-    if ('data' in response && response.data !== undefined) {
-        return response.data;
-    }
-    return response;
-}
-export function pipelineConnectionsFromPipelines(pipelines) {
-    return pipelines.flatMap((pipeline) => pipeline.pipelineConnections ?? []);
-}
-export function normalizePipelineDescribe(response) {
-    if ('data' in response && response.data !== undefined) {
-        return response.data;
-    }
-    return response;
-}
-export function normalizePipelineConnections(response) {
-    if (Array.isArray(response)) {
-        return response;
-    }
-    if ('data' in response && Array.isArray(response.data)) {
-        return response.data;
-    }
-    return [];
-}
-export function formatPipelineTable(pipelines) {
-    return table([
-        { alias: 'ID', value: 'id' },
-        { alias: 'NAME', value: 'name' },
-        { alias: 'MAIN BRANCH', value: 'mainBranch' },
-        { alias: 'PLATFORM', value: 'platform' },
-        { alias: 'ACTIVE', value: 'active' },
-        { alias: 'CONNECTIONS', value: 'connections' },
-    ], pipelines.map((pipeline) => ({
-        active: cellValue(pipeline.active),
-        connections: cellValue(pipeline.pipelineConnections?.length ?? 0),
-        id: cellValue(pipeline.id),
-        mainBranch: cellValue(pipeline.mainBranch),
-        name: cellValue(pipeline.name),
-        platform: cellValue(pipeline.platform),
-    })));
-}
-export function formatPipelineConnectionTable(connections) {
-    return table([
-        { alias: 'ID', value: 'id' },
-        { alias: 'NAME', value: 'name' },
-        { alias: 'PIPELINE ID', value: 'pipelineId' },
-        { alias: 'FROM ENVIRONMENT', value: 'fromEnvironmentId' },
-        { alias: 'TO ENVIRONMENT', value: 'toEnvironmentId' },
-        { alias: 'BRANCH', value: 'branch' },
-        { alias: 'DESTINATION BRANCH', value: 'destinationBranch' },
-    ], connections.map((connection) => ({
-        branch: cellValue(connection.branch),
-        destinationBranch: cellValue(connection.destinationBranch),
-        fromEnvironmentId: cellValue(connection.sourceEnvironment?.id ?? connection.sourceEnvironmentId),
-        id: cellValue(connection.id),
-        name: cellValue(connection.name),
-        pipelineId: cellValue(connection.pipelineId),
-        toEnvironmentId: cellValue(connection.destinationEnvironment?.id ?? connection.destinationEnvironmentId),
-    })));
-}
-export function formatPipelineDetail(pipeline) {
-    return [
-        `ID: ${cellValue(pipeline.id)}`,
-        `Name: ${cellValue(pipeline.name)}`,
-        `Main Branch: ${cellValue(pipeline.mainBranch)}`,
-        `Platform: ${cellValue(pipeline.platform)}`,
-        `Active: ${cellValue(pipeline.active)}`,
-        `Repository ID: ${cellValue(pipeline.repository?.id ?? pipeline.gitRepositoryId)}`,
-        `Repository Name: ${cellValue(pipeline.repository?.name)}`,
-        `System Properties: ${cellValue(pipeline.systemProperties?.length ?? 0)}`,
-        `Connections: ${cellValue(pipeline.connections?.length ?? 0)}`,
-        `Last Jobs: ${cellValue(pipeline.lastJobs?.length ?? 0)}`,
-    ].join('\n');
-}
-//# sourceMappingURL=pipeline-types.js.map
+import {modules} from './runtime.js';
+const PIPELINE_CALCULATE_BASED_ON_VALUES = modules["pipeline-types.js"]["PIPELINE_CALCULATE_BASED_ON_VALUES"]
+const PIPELINE_CONNECTION_SYNC_STATE_NEEDS_RECALCULATING = modules["pipeline-types.js"]["PIPELINE_CONNECTION_SYNC_STATE_NEEDS_RECALCULATING"]
+const PIPELINE_PLATFORMS = modules["pipeline-types.js"]["PIPELINE_PLATFORMS"]
+const formatPipelineConnectionTable = modules["pipeline-types.js"]["formatPipelineConnectionTable"]
+const formatPipelineDetail = modules["pipeline-types.js"]["formatPipelineDetail"]
+const formatPipelineTable = modules["pipeline-types.js"]["formatPipelineTable"]
+const normalizePipeline = modules["pipeline-types.js"]["normalizePipeline"]
+const normalizePipelineConnections = modules["pipeline-types.js"]["normalizePipelineConnections"]
+const normalizePipelineDescribe = modules["pipeline-types.js"]["normalizePipelineDescribe"]
+const normalizePipelines = modules["pipeline-types.js"]["normalizePipelines"]
+const normalizePipelinesListPage = modules["pipeline-types.js"]["normalizePipelinesListPage"]
+const pipelineConnectionsEndpoint = modules["pipeline-types.js"]["pipelineConnectionsEndpoint"]
+const pipelineConnectionsFromPipelines = modules["pipeline-types.js"]["pipelineConnectionsFromPipelines"]
+const pipelineDescribeEndpoint = modules["pipeline-types.js"]["pipelineDescribeEndpoint"]
+const pipelineEndpoint = modules["pipeline-types.js"]["pipelineEndpoint"]
+const pipelineListEndpoint = modules["pipeline-types.js"]["pipelineListEndpoint"]
+export {PIPELINE_CALCULATE_BASED_ON_VALUES, PIPELINE_CONNECTION_SYNC_STATE_NEEDS_RECALCULATING, PIPELINE_PLATFORMS, formatPipelineConnectionTable, formatPipelineDetail, formatPipelineTable, normalizePipeline, normalizePipelineConnections, normalizePipelineDescribe, normalizePipelines, normalizePipelinesListPage, pipelineConnectionsEndpoint, pipelineConnectionsFromPipelines, pipelineDescribeEndpoint, pipelineEndpoint, pipelineListEndpoint};

package/dist/lib/project-default-flags.js

@@ -1,88 +1,10 @@
-import { Flags } from '@oclif/core';
-import { PROJECT_DEFAULT_FLAG_NAMES, PROJECT_DEFAULT_KEYS } from './project-defaults.js';
-export const projectDefaultStringFlags = {
-    credential: Flags.string({
-        description: 'Default source credential',
-    }),
-    environment: Flags.string({
-        description: 'Default environment',
-    }),
-    epic: Flags.string({
-        description: 'Default epic',
-    }),
-    feature: Flags.string({
-        description: 'Default feature',
-    }),
-    project: Flags.string({
-        description: 'Default project',
-    }),
-    sprint: Flags.string({
-        description: 'Default sprint',
-    }),
-    team: Flags.string({
-        description: 'Default team',
-    }),
-};
-export const projectDefaultBooleanFlags = {
-    'assign-me': Flags.boolean({
-        description: 'Assign work items to the current user by default',
-    }),
-    global: Flags.boolean({
-        description: 'Use machine-wide defaults instead of project-local defaults',
-    }),
-};
-export const projectDefaultSelectorFlags = {
-    'assign-me': Flags.boolean({
-        description: 'Select the assign-me default',
-    }),
-    credential: Flags.boolean({
-        description: 'Select the default source credential',
-    }),
-    environment: Flags.boolean({
-        description: 'Select the default environment',
-    }),
-    epic: Flags.boolean({
-        description: 'Select the default epic',
-    }),
-    feature: Flags.boolean({
-        description: 'Select the default feature',
-    }),
-    global: Flags.boolean({
-        description: 'Use machine-wide defaults instead of project-local defaults',
-    }),
-    project: Flags.boolean({
-        description: 'Select the default project',
-    }),
-    sprint: Flags.boolean({
-        description: 'Select the default sprint',
-    }),
-    team: Flags.boolean({
-        description: 'Select the default team',
-    }),
-};
-function projectDefaultFlagValue(flags, key) {
-    return key === 'assignMe' ? (flags.assignMe ?? flags['assign-me']) : flags[key];
-}
-export function selectProjectDefaultKeys(flags, predicate) {
-    return PROJECT_DEFAULT_KEYS.filter((key) => predicate(projectDefaultFlagValue(flags, key), key));
-}
-export function collectSetUpdates(flags) {
-    return selectProjectDefaultKeys(flags, (value, key) => (key === 'assignMe' ? value === true : value !== undefined));
-}
-export function buildSetValues(flags) {
-    const values = {};
-    for (const key of collectSetUpdates(flags)) {
-        const value = projectDefaultFlagValue(flags, key);
-        if (value !== undefined) {
-            values[key] = value;
-        }
-    }
-    return values;
-}
-export function collectSelectedKeys(flags) {
-    return selectProjectDefaultKeys(flags, (value) => value === true);
-}
-export function formatFlagName(key) {
-    return `--${PROJECT_DEFAULT_FLAG_NAMES[key]}`;
-}
-//# sourceMappingURL=project-default-flags.js.map
+import {modules} from './runtime.js';
+const buildSetValues = modules["project-default-flags.js"]["buildSetValues"]
+const collectSelectedKeys = modules["project-default-flags.js"]["collectSelectedKeys"]
+const collectSetUpdates = modules["project-default-flags.js"]["collectSetUpdates"]
+const formatFlagName = modules["project-default-flags.js"]["formatFlagName"]
+const projectDefaultBooleanFlags = modules["project-default-flags.js"]["projectDefaultBooleanFlags"]
+const projectDefaultSelectorFlags = modules["project-default-flags.js"]["projectDefaultSelectorFlags"]
+const projectDefaultStringFlags = modules["project-default-flags.js"]["projectDefaultStringFlags"]
+const selectProjectDefaultKeys = modules["project-default-flags.js"]["selectProjectDefaultKeys"]
+export {buildSetValues, collectSelectedKeys, collectSetUpdates, formatFlagName, projectDefaultBooleanFlags, projectDefaultSelectorFlags, projectDefaultStringFlags, selectProjectDefaultKeys};

package/dist/lib/project-default-id.js

@@ -1,29 +1,4 @@
-import { readDefaults, resolveDefaults } from './defaults-store.js';
-export class ProjectDefaultResolutionError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'ProjectDefaultResolutionError';
-    }
-}
-const DEFAULT_LABELS = {
-    environment: 'environment',
-    project: 'project',
-};
-const DEFAULT_COMMANDS = {
-    environment: 'agentia cicd project default set --environment <environment-id>',
-    project: 'agentia cicd project default set --project <project-id>',
-};
-export async function resolveProjectDefaultId(key, explicitId) {
-    const trimmed = explicitId?.trim();
-    if (trimmed !== undefined && trimmed.length > 0) {
-        return trimmed;
-    }
-    const [localDefaults, globalDefaults] = await Promise.all([readDefaults('local'), readDefaults('global')]);
-    const resolved = resolveDefaults(localDefaults, globalDefaults, [key]);
-    const value = resolved[0]?.value;
-    if (typeof value === 'string' && value.trim().length > 0) {
-        return value.trim();
-    }
-    throw new ProjectDefaultResolutionError(`No default ${DEFAULT_LABELS[key]} configured. Run \`${DEFAULT_COMMANDS[key]}\` or pass an ID.`);
-}
-//# sourceMappingURL=project-default-id.js.map
+import {modules} from './runtime.js';
+const ProjectDefaultResolutionError = modules["project-default-id.js"]["ProjectDefaultResolutionError"]
+const resolveProjectDefaultId = modules["project-default-id.js"]["resolveProjectDefaultId"]
+export {ProjectDefaultResolutionError, resolveProjectDefaultId};

package/dist/lib/project-default-validation.js

@@ -0,0 +1,7 @@
+import {modules} from './runtime.js';
+const ProjectDefaultValidationError = modules["project-default-validation.js"]["ProjectDefaultValidationError"]
+const validateProjectDefaultCredential = modules["project-default-validation.js"]["validateProjectDefaultCredential"]
+const validateProjectDefaultEnvironment = modules["project-default-validation.js"]["validateProjectDefaultEnvironment"]
+const validateProjectDefaultIdentifiers = modules["project-default-validation.js"]["validateProjectDefaultIdentifiers"]
+const validateProjectDefaultProject = modules["project-default-validation.js"]["validateProjectDefaultProject"]
+export {ProjectDefaultValidationError, validateProjectDefaultCredential, validateProjectDefaultEnvironment, validateProjectDefaultIdentifiers, validateProjectDefaultProject};

package/dist/lib/project-defaults.js

@@ -1,54 +1,8 @@
-export const PROJECT_DEFAULT_KEYS = [
-    'project',
-    'team',
-    'environment',
-    'credential',
-    'sprint',
-    'epic',
-    'feature',
-    'assignMe',
-];
-export const PROJECT_DEFAULT_LABELS = {
-    assignMe: 'Assign me',
-    credential: 'Credential',
-    environment: 'Environment',
-    epic: 'Epic',
-    feature: 'Feature',
-    project: 'Project',
-    sprint: 'Sprint',
-    team: 'Team',
-};
-export const PROJECT_DEFAULT_FLAG_NAMES = {
-    assignMe: 'assign-me',
-    credential: 'credential',
-    environment: 'environment',
-    epic: 'epic',
-    feature: 'feature',
-    project: 'project',
-    sprint: 'sprint',
-    team: 'team',
-};
-export function isProjectDefaultKey(value) {
-    return PROJECT_DEFAULT_KEYS.includes(value);
-}
-export function formatProjectDefaultValue(value) {
-    if (value === undefined) {
-        return 'not set';
-    }
-    if (typeof value === 'boolean') {
-        return value ? 'true' : 'false';
-    }
-    return value;
-}
-export function formatProjectDefaultLine(resolved) {
-    const label = PROJECT_DEFAULT_LABELS[resolved.key];
-    const value = formatProjectDefaultValue(resolved.value);
-    if (resolved.value === undefined) {
-        return `${label}: not set`;
-    }
-    if (resolved.source === undefined) {
-        return `${label}: ${value}`;
-    }
-    return `${label}: ${value} (${resolved.source})`;
-}
-//# sourceMappingURL=project-defaults.js.map
+import {modules} from './runtime.js';
+const PROJECT_DEFAULT_FLAG_NAMES = modules["project-defaults.js"]["PROJECT_DEFAULT_FLAG_NAMES"]
+const PROJECT_DEFAULT_KEYS = modules["project-defaults.js"]["PROJECT_DEFAULT_KEYS"]
+const PROJECT_DEFAULT_LABELS = modules["project-defaults.js"]["PROJECT_DEFAULT_LABELS"]
+const formatProjectDefaultLine = modules["project-defaults.js"]["formatProjectDefaultLine"]
+const formatProjectDefaultValue = modules["project-defaults.js"]["formatProjectDefaultValue"]
+const isProjectDefaultKey = modules["project-defaults.js"]["isProjectDefaultKey"]
+export {PROJECT_DEFAULT_FLAG_NAMES, PROJECT_DEFAULT_KEYS, PROJECT_DEFAULT_LABELS, formatProjectDefaultLine, formatProjectDefaultValue, isProjectDefaultKey};

package/dist/lib/project-flags.js

@@ -1,22 +1,10 @@
-import { Flags } from '@oclif/core';
-import { buildListPaginationQuery, listPaginationFlags } from './list-pagination.js';
-export const projectListFlags = {
-    ...listPaginationFlags,
-    mine: Flags.boolean({
-        description: 'List only projects owned by or related to the current user',
-    }),
-    name: Flags.string({
-        description: 'Filter by name (partial match)',
-    }),
-};
-export function buildProjectListFilters(flags) {
-    const filters = {};
-    if (flags.mine) {
-        filters.mine = true;
-    }
-    if (typeof flags.name === 'string') {
-        filters.name = flags.name;
-    }
-    return { ...filters, ...buildListPaginationQuery(flags) };
-}
-//# sourceMappingURL=project-flags.js.map
+import {modules} from './runtime.js';
+const buildProjectListFilters = modules["project-flags.js"]["buildProjectListFilters"]
+const buildProjectMutationPayload = modules["project-flags.js"]["buildProjectMutationPayload"]
+const projectCreateFlags = modules["project-flags.js"]["projectCreateFlags"]
+const projectListFlags = modules["project-flags.js"]["projectListFlags"]
+const projectUpdateFlags = modules["project-flags.js"]["projectUpdateFlags"]
+const validateProjectDates = modules["project-flags.js"]["validateProjectDates"]
+const validateProjectListFilters = modules["project-flags.js"]["validateProjectListFilters"]
+const validateProjectMutationPayload = modules["project-flags.js"]["validateProjectMutationPayload"]
+export {buildProjectListFilters, buildProjectMutationPayload, projectCreateFlags, projectListFlags, projectUpdateFlags, validateProjectDates, validateProjectListFilters, validateProjectMutationPayload};

package/dist/lib/project-root.js

@@ -1,65 +1,7 @@
-import { existsSync, statSync } from 'node:fs';
-import path from 'node:path';
-import { setDefaultsStoreProjectRoot } from './defaults-store.js';
-import { loadEnvFile } from './env-file.js';
-export const AGENTIA_PROJECT_ROOT_ENV = 'AGENTIA_PROJECT_ROOT';
-const PROJECT_MARKERS = ['.agentia', '.git'];
-let testDeps;
-export function setProjectRootDepsForTests(deps) {
-    testDeps = deps;
-}
-export function resetProjectRootDepsForTests() {
-    testDeps = undefined;
-}
-function isDirectory(filePath, deps) {
-    if (!(deps.existsSync ?? existsSync)(filePath))
-        return false;
-    try {
-        return (deps.statSync ?? statSync)(filePath).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-function hasProjectMarker(root, deps) {
-    return PROJECT_MARKERS.some((marker) => {
-        const markerPath = path.join(root, marker);
-        return marker === '.agentia' ? isDirectory(markerPath, deps) : (deps.existsSync ?? existsSync)(markerPath);
-    });
-}
-function walkUpForProjectRoot(start, deps) {
-    let current = path.resolve(start);
-    while (true) {
-        if (isDirectory(current, deps) && hasProjectMarker(current, deps))
-            return current;
-        const parent = path.dirname(current);
-        if (parent === current)
-            return undefined;
-        current = parent;
-    }
-}
-export function resolveProjectRoot(start = process.cwd()) {
-    const deps = testDeps ?? {};
-    const configured = process.env[AGENTIA_PROJECT_ROOT_ENV];
-    if (configured !== undefined) {
-        if (!path.isAbsolute(configured)) {
-            throw new Error(`${AGENTIA_PROJECT_ROOT_ENV} must be an absolute directory path.`);
-        }
-        const root = path.resolve(configured);
-        if (!isDirectory(root, deps)) {
-            throw new Error(`${AGENTIA_PROJECT_ROOT_ENV} must point to an existing directory.`);
-        }
-        return root;
-    }
-    return walkUpForProjectRoot(start, deps) ?? path.resolve(start);
-}
-/** Apply the project context before loading configuration or registering MCP tools. */
-export function applyProjectRoot(start = process.cwd()) {
-    const root = resolveProjectRoot(start);
-    setDefaultsStoreProjectRoot(root);
-    loadEnvFile(path.join(root, '.env'));
-    if (process.cwd() !== root)
-        process.chdir(root);
-    return root;
-}
-//# sourceMappingURL=project-root.js.map
+import {modules} from './runtime.js';
+const AGENTIA_PROJECT_ROOT_ENV = modules["project-root.js"]["AGENTIA_PROJECT_ROOT_ENV"]
+const applyProjectRoot = modules["project-root.js"]["applyProjectRoot"]
+const resetProjectRootDepsForTests = modules["project-root.js"]["resetProjectRootDepsForTests"]
+const resolveProjectRoot = modules["project-root.js"]["resolveProjectRoot"]
+const setProjectRootDepsForTests = modules["project-root.js"]["setProjectRootDepsForTests"]
+export {AGENTIA_PROJECT_ROOT_ENV, applyProjectRoot, resetProjectRootDepsForTests, resolveProjectRoot, setProjectRootDepsForTests};