@copado/agentia-cli 0.5.0-alpha.0 → 0.7.0-alpha.0

package/dist/lib/mcp/tools.js

@@ -0,0 +1,683 @@
+import { z } from 'zod';
+import { normalizeEnvironments } from '../../commands/environment/list.js';
+import { buildMetadataCompareFileRequests } from '../../commands/metadata/content/compare.js';
+import { buildMetadataContentRequest } from '../../commands/metadata/content/get.js';
+import { buildMetadataCompareRequest } from '../../commands/metadata/index/compare.js';
+import { buildMetadataIndexRequest } from '../../commands/metadata/list.js';
+import { assertRequired } from '../assert.js';
+import { CicdGateway } from '../cicd-gateway.js';
+import { readDefaults, resolveDefaults, unsetDefaults, writeDefaults } from '../defaults-store.js';
+import { buildCreatePayload, buildMutationPayload, ENVIRONMENT_STRING_VALIDATION_KEYS, validateNonEmptyStringFields, } from '../environment-flags.js';
+import { DEFAULT_ENVIRONMENT_PLATFORM, DEFAULT_ENVIRONMENT_TYPE, ENVIRONMENT_TYPES, environmentEndpoint, } from '../environment-types.js';
+import { JOB_LIST_LIMIT_MAX, JOB_LIST_LIMIT_MIN, jobEndpoint, jobKillEndpoint, jobListEndpoint, jobPauseEndpoint, jobResumeEndpoint, jobRunEndpoint, normalizeJob, normalizeJobOperation, normalizeJobs, } from '../job-types.js';
+import { COMPARISON_MODES, CONTENT_SOURCES, contentResultToCompareSide, createUnifiedDiff, INDEX_SOURCES, MODULE_TYPES, ORDER_DIRECTIONS, PLATFORM_EXPERIENCES, RETRIEVE_MODES, sourceSideLabel, } from '../metadata-common.js';
+import { pipelineHeaders } from '../pipeline-flags.js';
+import { normalizePipelineDescribe, normalizePipelines, pipelineConnectionsFromPipelines, pipelineDescribeEndpoint, pipelineListEndpoint, } from '../pipeline-types.js';
+import { buildSetValues, collectSelectedKeys } from '../project-default-flags.js';
+import { PROJECT_DEFAULT_KEYS } from '../project-defaults.js';
+import { safelyHandleTool } from './result.js';
+const MAX_LIMIT = 2000;
+async function environmentList(args = {}) {
+    const response = await CicdGateway.call({
+        endpoint: '/corpus/environments',
+        method: 'GET',
+    });
+    const environments = normalizeEnvironments(response);
+    const limit = args.limit === undefined ? environments.length : Math.min(Math.max(args.limit, 1), MAX_LIMIT);
+    return { environments: environments.slice(0, limit) };
+}
+async function environmentGet(args) {
+    const environment = await CicdGateway.call({
+        endpoint: environmentEndpoint(assertRequired(args.id, 'id')),
+        method: 'GET',
+    });
+    return { environment };
+}
+async function environmentCreate(args) {
+    const payload = buildCreatePayload(args.name, {
+        'apex-test-level': args.apexTestLevel,
+        'enable-rollback': args.enableRollback,
+        'index-back-promotion-metadata': args.indexBackPromotionMetadata,
+        name: args.name,
+        namespace: args.namespace,
+        platform: args.platform ?? DEFAULT_ENVIRONMENT_PLATFORM,
+        'promotion-default-credential': args.promotionDefaultCredential,
+        'run-local-tests': args.runLocalTests,
+        'run-specified-tests': args.runSpecifiedTests,
+        type: args.type ?? DEFAULT_ENVIRONMENT_TYPE,
+        'validation-promotion-default-credential': args.validationPromotionDefaultCredential,
+    });
+    const validationError = validateNonEmptyStringFields(payload, ENVIRONMENT_STRING_VALIDATION_KEYS);
+    if (validationError !== undefined) {
+        throw new Error(validationError);
+    }
+    const environment = await CicdGateway.call({
+        body: payload,
+        endpoint: '/corpus/environments',
+        headers: { 'Content-Type': 'application/json' },
+        method: 'POST',
+    });
+    return { environment };
+}
+async function environmentUpdate(args) {
+    const flags = {
+        'apex-test-level': args.apexTestLevel,
+        'enable-rollback': args.enableRollback,
+        'index-back-promotion-metadata': args.indexBackPromotionMetadata,
+        name: args.name,
+        namespace: args.namespace,
+        platform: args.platform,
+        'promotion-default-credential': args.promotionDefaultCredential,
+        'run-local-tests': args.runLocalTests,
+        'run-specified-tests': args.runSpecifiedTests,
+        type: args.type,
+        'validation-promotion-default-credential': args.validationPromotionDefaultCredential,
+    };
+    let payload = buildMutationPayload(flags);
+    if (Object.keys(payload).length === 0) {
+        throw new Error('Must provide at least one field to update.');
+    }
+    const validationError = validateNonEmptyStringFields(payload, ENVIRONMENT_STRING_VALIDATION_KEYS);
+    if (validationError !== undefined) {
+        throw new Error(validationError);
+    }
+    if (payload.name === undefined || payload.platform === undefined) {
+        const currentEnvironment = await CicdGateway.call({
+            endpoint: environmentEndpoint(assertRequired(args.id, 'id')),
+            method: 'GET',
+        });
+        payload = {
+            ...payload,
+            name: payload.name ?? currentEnvironment.name ?? undefined,
+            platform: payload.platform ?? currentEnvironment.platform ?? undefined,
+        };
+    }
+    if (payload.name === undefined || payload.platform === undefined) {
+        throw new Error('Environment name and platform are required to update an environment.');
+    }
+    const environment = await CicdGateway.call({
+        body: payload,
+        endpoint: environmentEndpoint(args.id),
+        headers: { 'Content-Type': 'application/json' },
+        method: 'PATCH',
+    });
+    return { environment };
+}
+function toPipelineHeaderFlags(args) {
+    return {
+        'organization-id': assertRequired(args.organizationId, 'organizationId'),
+        'user-id': assertRequired(args.userId, 'userId'),
+    };
+}
+async function jobList(args) {
+    const filters = {
+        context: args.context,
+        id: args.id,
+        limit: args.limit,
+        name: args.name,
+        parent: args.parent,
+        status: args.status,
+        type: args.type,
+    };
+    const response = await CicdGateway.call({
+        endpoint: jobListEndpoint(filters),
+        headers: pipelineHeaders(toPipelineHeaderFlags(args)),
+        method: 'GET',
+    });
+    return { jobs: normalizeJobs(response) };
+}
+async function jobGet(args) {
+    const response = await CicdGateway.call({
+        endpoint: jobEndpoint(assertRequired(args.id, 'id')),
+        headers: pipelineHeaders(toPipelineHeaderFlags(args)),
+        method: 'GET',
+    });
+    return { job: normalizeJob(response) };
+}
+async function jobRun(args) {
+    const result = await CicdGateway.call({
+        endpoint: jobRunEndpoint(assertRequired(args.id, 'id'), args.restart),
+        headers: pipelineHeaders(toPipelineHeaderFlags(args)),
+        method: 'POST',
+    });
+    return { result: normalizeJobOperation(result) };
+}
+async function jobResume(args) {
+    const result = await CicdGateway.call({
+        endpoint: jobResumeEndpoint(assertRequired(args.id, 'id')),
+        headers: pipelineHeaders(toPipelineHeaderFlags(args)),
+        method: 'POST',
+    });
+    return { result: normalizeJobOperation(result) };
+}
+async function jobKill(args) {
+    const result = await CicdGateway.call({
+        endpoint: jobKillEndpoint(assertRequired(args.id, 'id')),
+        headers: pipelineHeaders(toPipelineHeaderFlags(args)),
+        method: 'POST',
+    });
+    return { result: normalizeJobOperation(result) };
+}
+async function jobPause(args) {
+    const result = await CicdGateway.call({
+        endpoint: jobPauseEndpoint(assertRequired(args.id, 'id')),
+        headers: pipelineHeaders(toPipelineHeaderFlags(args)),
+        method: 'POST',
+    });
+    return { result: normalizeJobOperation(result) };
+}
+async function pipelineList(args) {
+    const response = await CicdGateway.call({
+        endpoint: pipelineListEndpoint(),
+        headers: pipelineHeaders(toPipelineHeaderFlags(args)),
+        method: 'GET',
+    });
+    return { pipelines: normalizePipelines(response) };
+}
+async function pipelineGet(args) {
+    const response = await CicdGateway.call({
+        endpoint: pipelineDescribeEndpoint(assertRequired(args.id, 'id')),
+        headers: pipelineHeaders(toPipelineHeaderFlags(args)),
+        method: 'GET',
+    });
+    return { pipeline: normalizePipelineDescribe(response) };
+}
+async function pipelineConnectionList(args) {
+    const headers = pipelineHeaders(toPipelineHeaderFlags(args));
+    let connections;
+    if (args.pipelineId) {
+        const response = await CicdGateway.call({
+            endpoint: pipelineDescribeEndpoint(args.pipelineId),
+            headers,
+            method: 'GET',
+        });
+        const pipeline = normalizePipelineDescribe(response);
+        connections = pipeline.connections ?? [];
+    }
+    else {
+        const response = await CicdGateway.call({
+            endpoint: pipelineListEndpoint(),
+            headers,
+            method: 'GET',
+        });
+        connections = pipelineConnectionsFromPipelines(normalizePipelines(response));
+    }
+    return { connections };
+}
+async function projectDefaultGet(args = {}) {
+    const keys = collectSelectedKeys(args);
+    const selected = keys.length > 0 ? keys : [...PROJECT_DEFAULT_KEYS];
+    const scope = args.global ? 'global' : 'effective';
+    if (args.global) {
+        const globalDefaults = await readDefaults('global');
+        return {
+            defaults: selected.map((key) => ({
+                key,
+                source: globalDefaults[key] === undefined ? undefined : 'global',
+                value: globalDefaults[key],
+            })),
+            scope,
+        };
+    }
+    const [localDefaults, globalDefaults] = await Promise.all([readDefaults('local'), readDefaults('global')]);
+    return {
+        defaults: resolveDefaults(localDefaults, globalDefaults, selected),
+        scope,
+    };
+}
+async function projectDefaultSet(args) {
+    const values = buildSetValues(args);
+    const selectedKeys = Object.keys(values);
+    if (selectedKeys.length === 0) {
+        throw new Error('Must provide at least one default field to set.');
+    }
+    for (const key of selectedKeys) {
+        if (key === 'assignMe') {
+            continue;
+        }
+        const value = values[key];
+        if (typeof value === 'string' && value.trim().length === 0) {
+            throw new Error(`${key} value cannot be empty`);
+        }
+    }
+    const scope = args.global ? 'global' : 'local';
+    const stored = await writeDefaults(scope, values);
+    return {
+        defaults: selectedKeys.map((key) => ({
+            key,
+            source: scope,
+            value: stored[key],
+        })),
+        scope,
+    };
+}
+async function projectDefaultUnset(args) {
+    const selectedKeys = collectSelectedKeys(args);
+    if (selectedKeys.length === 0) {
+        throw new Error('Must provide at least one default field to unset.');
+    }
+    const scope = args.global ? 'global' : 'local';
+    const previousDefaults = await readDefaults(scope);
+    const removed = selectedKeys.filter((key) => previousDefaults[key] !== undefined);
+    await unsetDefaults(scope, selectedKeys);
+    return { removed, scope };
+}
+async function metadataList(args) {
+    const platformExperience = args.platformExperience ?? 'salesforce';
+    const body = buildMetadataIndexRequest({
+        'avoid-source-tracking': Boolean(args.avoidSourceTracking),
+        'filter-type': args.filterType,
+        'find-managed-packages': Boolean(args.findManagedPackages),
+        limit: args.limit,
+        'metadata-types': args.metadataTypes?.join(','),
+        'modified-by': args.modifiedBy,
+        'module-type': args.moduleType,
+        'order-direction': args.orderDirection,
+        'pipeline-id': args.pipelineId,
+        'platform-experience': platformExperience,
+        source: args.source,
+        'source-credential-id': args.sourceCredentialId,
+        'source-org-id': args.sourceOrgId,
+        'target-org-id': args.targetOrgId,
+    });
+    const endpoint = args.avoidSourceTracking
+        ? '/release/metadata/index?avoidSourceTracking=true'
+        : '/release/metadata/index';
+    const result = await CicdGateway.call({
+        body,
+        endpoint,
+        headers: {
+            'Content-Type': 'application/json',
+            'platform-experience': platformExperience,
+        },
+        method: 'POST',
+    });
+    return { result };
+}
+async function metadataContentGet(args) {
+    const body = [
+        buildMetadataContentRequest({
+            'api-name': args.apiName,
+            branch: args.branch,
+            'file-name': args.fileName,
+            'metadata-type': args.metadataType,
+            'pipeline-id': args.pipelineId,
+            'result-id': args.resultId,
+            show: false,
+            source: args.source,
+            'source-credential-id': args.sourceCredentialId,
+            'source-org-id': args.sourceOrgId,
+        }),
+    ];
+    const records = await CicdGateway.call({
+        body,
+        endpoint: '/release/metadata/content',
+        headers: { 'Content-Type': 'application/json' },
+        method: 'POST',
+    });
+    return { records };
+}
+async function metadataIndexCompare(args) {
+    const body = buildMetadataCompareRequest({
+        'comparison-mode': args.comparisonMode,
+        'filter-type': args.filterType,
+        'pipeline-id': args.pipelineId,
+        'source-credential-id': args.sourceCredentialId,
+        'source-org-id': args.sourceOrgId,
+        'target-org-id': args.targetOrgId,
+    });
+    const result = await CicdGateway.call({
+        body,
+        endpoint: '/release/metadata/compare-org',
+        headers: { 'Content-Type': 'application/json' },
+        method: 'POST',
+    });
+    return { result };
+}
+async function metadataContentCompare(args) {
+    const { sourceRequest, targetRequest } = buildMetadataCompareFileRequests({
+        'api-name': args.apiName,
+        'file-name': args.fileName,
+        'metadata-type': args.metadataType,
+        'pipeline-id': args.pipelineId,
+        source: args.source ?? 'ENVIRONMENT',
+        'source-branch': args.sourceBranch ?? '',
+        'source-credential-id': args.sourceCredentialId,
+        'source-org-id': args.sourceOrgId,
+        'target-branch': args.targetBranch ?? '',
+        'target-credential-id': args.targetCredentialId,
+        'target-org-id': args.targetOrgId,
+        'target-source': args.targetSource ?? 'ENVIRONMENT',
+    });
+    const rows = await CicdGateway.call({
+        body: [sourceRequest, targetRequest],
+        endpoint: '/release/metadata/content',
+        headers: { 'Content-Type': 'application/json' },
+        method: 'POST',
+    });
+    const sourceSide = contentResultToCompareSide(rows[0], sourceRequest);
+    const targetSide = contentResultToCompareSide(rows[1] ?? rows[0], targetRequest);
+    const diff = createUnifiedDiff(sourceSideLabel(sourceSide, 'source'), sourceSideLabel(targetSide, 'target'), sourceSide.content, targetSide.content);
+    return {
+        apiName: args.apiName,
+        diff,
+        identical: diff === '',
+        metadataType: args.metadataType,
+        source: sourceSide,
+        target: targetSide,
+    };
+}
+async function metadataDependencyList(args) {
+    const selection = {
+        name: assertRequired(args.metadataName, 'metadataName'),
+        type: assertRequired(args.metadataType, 'metadataType'),
+    };
+    if (args.metadataCategory) {
+        selection.category = args.metadataCategory;
+    }
+    const body = {
+        compareOptions: {
+            sourceCredentialId: assertRequired(args.sourceCredentialId, 'sourceCredentialId'),
+            sourceOrgId: assertRequired(args.sourceOrgId, 'sourceOrgId'),
+        },
+        metadataSelections: [selection],
+        pipelineId: assertRequired(args.pipelineId, 'pipelineId'),
+    };
+    if (args.targetOrgId) {
+        body.compareOptions.targetOrgId = args.targetOrgId;
+    }
+    if (args.retrieveMode) {
+        body.compareOptions.retrieveMode = args.retrieveMode;
+    }
+    if (args.moduleType) {
+        body.moduleType = args.moduleType;
+    }
+    if (args.resultId) {
+        body.resultId = args.resultId;
+    }
+    const platformExperience = args.platformExperience ?? 'salesforce';
+    const result = await CicdGateway.call({
+        body,
+        endpoint: '/release/metadata/dependencies',
+        headers: {
+            'Content-Type': 'application/json',
+            'platform-experience': platformExperience,
+        },
+        method: 'POST',
+    });
+    return { result };
+}
+export const agentiaMcpToolHandlers = {
+    environmentCreate,
+    environmentGet,
+    environmentList,
+    environmentUpdate,
+    jobGet,
+    jobKill,
+    jobList,
+    jobPause,
+    jobResume,
+    jobRun,
+    metadataContentCompare,
+    metadataContentGet,
+    metadataDependencyList,
+    metadataIndexCompare,
+    metadataList,
+    pipelineConnectionList,
+    pipelineGet,
+    pipelineList,
+    projectDefaultGet,
+    projectDefaultSet,
+    projectDefaultUnset,
+};
+const environmentMutationSchema = {
+    apexTestLevel: z.string().optional().describe('Apex test level.'),
+    enableRollback: z.boolean().optional().describe('Enable rollback.'),
+    indexBackPromotionMetadata: z.boolean().optional().describe('Index back promotion metadata.'),
+    namespace: z.string().optional().describe('Environment namespace.'),
+    platform: z.string().optional().describe('Environment platform.'),
+    promotionDefaultCredential: z.string().optional().describe('Default credential for promotions.'),
+    runLocalTests: z.boolean().optional().describe('Run local tests.'),
+    runSpecifiedTests: z.string().optional().describe('Specified tests to run.'),
+    type: z.enum(ENVIRONMENT_TYPES).optional().describe('Environment type.'),
+    validationPromotionDefaultCredential: z
+        .string()
+        .optional()
+        .describe('Default credential for validation promotions.'),
+};
+const pipelineHeaderSchema = {
+    organizationId: z.string().describe('Organization Id for the x-organization-id gateway header.'),
+    userId: z.string().describe('User Id for the x-user-id gateway header.'),
+};
+const projectSelectorSchema = {
+    assignMe: z.boolean().optional().describe('Select or set the assign-me default.'),
+    environment: z.boolean().optional().describe('Select the environment default.'),
+    epic: z.boolean().optional().describe('Select the epic default.'),
+    feature: z.boolean().optional().describe('Select the feature default.'),
+    global: z.boolean().optional().describe('Use machine-wide defaults instead of project-local defaults.'),
+    project: z.boolean().optional().describe('Select the project default.'),
+    sprint: z.boolean().optional().describe('Select the sprint default.'),
+    team: z.boolean().optional().describe('Select the team default.'),
+};
+export function registerAgentiaMcpTools(server) {
+    server.registerTool('agentia_environment_list', {
+        description: 'List Copado environments via the CICD gateway.',
+        inputSchema: {
+            limit: z.number().int().min(1).max(MAX_LIMIT).optional().describe('Maximum number of environments to return.'),
+        },
+        title: 'Agentia Environment List',
+    }, (args) => safelyHandleTool(() => environmentList(args || {})));
+    server.registerTool('agentia_environment_get', {
+        description: 'Get a Copado environment by Id via the CICD gateway.',
+        inputSchema: {
+            id: z.string().describe('Copado environment Id.'),
+        },
+        title: 'Agentia Environment Get',
+    }, (args) => safelyHandleTool(() => environmentGet(args)));
+    server.registerTool('agentia_environment_create', {
+        description: 'Create a Copado environment via the CICD gateway.',
+        inputSchema: {
+            ...environmentMutationSchema,
+            name: z.string().describe('Name of the environment to create.'),
+        },
+        title: 'Agentia Environment Create',
+    }, (args) => safelyHandleTool(() => environmentCreate(args)));
+    server.registerTool('agentia_environment_update', {
+        description: 'Update a Copado environment by Id via the CICD gateway.',
+        inputSchema: {
+            ...environmentMutationSchema,
+            id: z.string().describe('Copado environment Id.'),
+            name: z.string().optional().describe('Environment name.'),
+        },
+        title: 'Agentia Environment Update',
+    }, (args) => safelyHandleTool(() => environmentUpdate(args)));
+    server.registerTool('agentia_job_list', {
+        description: 'List Copado job executions via the CICD gateway.',
+        inputSchema: {
+            ...pipelineHeaderSchema,
+            context: z.string().optional().describe('Contains match on JobExecution context.'),
+            id: z.string().optional().describe('Exact JobExecution Id.'),
+            limit: z
+                .number()
+                .int()
+                .min(JOB_LIST_LIMIT_MIN)
+                .max(JOB_LIST_LIMIT_MAX)
+                .optional()
+                .describe(`Maximum number of jobs to return (${JOB_LIST_LIMIT_MIN}-${JOB_LIST_LIMIT_MAX}).`),
+            name: z.string().optional().describe('Contains match on JobExecution name.'),
+            parent: z.string().optional().describe('Exact parent record Id.'),
+            status: z.string().optional().describe('Exact Copado job status.'),
+            type: z.string().optional().describe('Contains match on Job Template name.'),
+        },
+        title: 'Agentia Job List',
+    }, (args) => safelyHandleTool(() => jobList(args)));
+    server.registerTool('agentia_job_get', {
+        description: 'Get a Copado job execution with ordered steps via the CICD gateway.',
+        inputSchema: {
+            ...pipelineHeaderSchema,
+            id: z.string().describe('JobExecution Id.'),
+        },
+        title: 'Agentia Job Get',
+    }, (args) => safelyHandleTool(() => jobGet(args)));
+    server.registerTool('agentia_job_run', {
+        description: 'Run all steps for a Copado job execution via the CICD gateway.',
+        inputSchema: {
+            ...pipelineHeaderSchema,
+            id: z.string().describe('JobExecution Id.'),
+            restart: z.boolean().optional().describe('Restart the job run (gateway compatibility flag).'),
+        },
+        title: 'Agentia Job Run',
+    }, (args) => safelyHandleTool(() => jobRun(args)));
+    server.registerTool('agentia_job_resume', {
+        description: 'Resume outstanding steps for a Copado job execution via the CICD gateway.',
+        inputSchema: {
+            ...pipelineHeaderSchema,
+            id: z.string().describe('JobExecution Id.'),
+        },
+        title: 'Agentia Job Resume',
+    }, (args) => safelyHandleTool(() => jobResume(args)));
+    server.registerTool('agentia_job_kill', {
+        description: 'Cancel a Copado job execution via the CICD gateway.',
+        inputSchema: {
+            ...pipelineHeaderSchema,
+            id: z.string().describe('JobExecution Id.'),
+        },
+        title: 'Agentia Job Kill',
+    }, (args) => safelyHandleTool(() => jobKill(args)));
+    server.registerTool('agentia_job_pause', {
+        description: 'Pause a Copado job execution via the CICD gateway (resumable cancel alias).',
+        inputSchema: {
+            ...pipelineHeaderSchema,
+            id: z.string().describe('JobExecution Id.'),
+        },
+        title: 'Agentia Job Pause',
+    }, (args) => safelyHandleTool(() => jobPause(args)));
+    server.registerTool('agentia_pipeline_list', {
+        description: 'List Copado pipelines via the CICD gateway.',
+        inputSchema: pipelineHeaderSchema,
+        title: 'Agentia Pipeline List',
+    }, (args) => safelyHandleTool(() => pipelineList(args)));
+    server.registerTool('agentia_pipeline_get', {
+        description: 'Describe a Copado pipeline via the CICD gateway.',
+        inputSchema: {
+            ...pipelineHeaderSchema,
+            id: z.string().describe('Pipeline Id.'),
+        },
+        title: 'Agentia Pipeline Get',
+    }, (args) => safelyHandleTool(() => pipelineGet(args)));
+    server.registerTool('agentia_pipeline_connection_list', {
+        description: 'List Copado pipeline connections via list or describe endpoints.',
+        inputSchema: {
+            ...pipelineHeaderSchema,
+            pipelineId: z.string().optional().describe('Optional pipeline Id. When set, uses the describe endpoint.'),
+        },
+        title: 'Agentia Pipeline Connection List',
+    }, (args) => safelyHandleTool(() => pipelineConnectionList(args)));
+    server.registerTool('agentia_project_default_get', {
+        description: 'Show Agentia project default values for the current project or globally.',
+        inputSchema: projectSelectorSchema,
+        title: 'Agentia Project Default Get',
+    }, (args) => safelyHandleTool(() => projectDefaultGet(args || {})));
+    server.registerTool('agentia_project_default_set', {
+        description: 'Set Agentia project default values for the current project or globally.',
+        inputSchema: {
+            assignMe: z.boolean().optional().describe('Assign work items to the current user by default.'),
+            environment: z.string().optional().describe('Default environment.'),
+            epic: z.string().optional().describe('Default epic.'),
+            feature: z.string().optional().describe('Default feature.'),
+            global: z.boolean().optional().describe('Use machine-wide defaults instead of project-local defaults.'),
+            project: z.string().optional().describe('Default project.'),
+            sprint: z.string().optional().describe('Default sprint.'),
+            team: z.string().optional().describe('Default team.'),
+        },
+        title: 'Agentia Project Default Set',
+    }, (args) => safelyHandleTool(() => projectDefaultSet(args || {})));
+    server.registerTool('agentia_project_default_unset', {
+        description: 'Remove Agentia project default values from the current project or globally.',
+        inputSchema: projectSelectorSchema,
+        title: 'Agentia Project Default Unset',
+    }, (args) => safelyHandleTool(() => projectDefaultUnset(args || {})));
+    server.registerTool('agentia_metadata_list', {
+        description: 'Search the Copado metadata index via the CICD gateway.',
+        inputSchema: {
+            avoidSourceTracking: z.boolean().optional().describe('Pass avoidSourceTracking=true to the gateway index route.'),
+            filterType: z.string().optional().describe('Optional metadata type name filter, for example ApexClass.'),
+            findManagedPackages: z.boolean().optional().describe('Include managed package metadata in the search.'),
+            limit: z.number().int().min(1).max(MAX_LIMIT).optional().describe('Maximum number of records to return.'),
+            metadataTypes: z.array(z.string()).optional().describe('Optional metadata types to include.'),
+            modifiedBy: z.string().optional().describe('Filter by last modified user.'),
+            moduleType: z.enum(MODULE_TYPES).optional().describe('Optional addon module type.'),
+            orderDirection: z.enum(ORDER_DIRECTIONS).optional().describe('Sort direction for last modified date.'),
+            pipelineId: z.string().describe('Pipeline Id.'),
+            platformExperience: z.enum(PLATFORM_EXPERIENCES).optional().describe('Gateway platform experience header.'),
+            source: z.enum(INDEX_SOURCES).optional().describe('Index source filter.'),
+            sourceCredentialId: z.string().describe('Source org credential Id.'),
+            sourceOrgId: z.string().describe('Source org Id.'),
+            targetOrgId: z.string().optional().describe('Optional target org Id.'),
+        },
+        title: 'Agentia Metadata List',
+    }, (args) => safelyHandleTool(() => metadataList(args)));
+    server.registerTool('agentia_metadata_content_get', {
+        description: 'Retrieve metadata file content via the CICD gateway.',
+        inputSchema: {
+            apiName: z.string().describe('Metadata API name.'),
+            branch: z.string().optional().describe('Git branch when source is REPOSITORY or GIT_MIRROR.'),
+            fileName: z.string().optional().describe('Optional metadata file name.'),
+            metadataType: z.string().describe('Metadata type, for example ApexClass.'),
+            pipelineId: z.string().describe('Pipeline Id.'),
+            resultId: z.string().optional().describe('Optional result Id from a prior metadata operation.'),
+            source: z.enum(CONTENT_SOURCES).describe('Content source.'),
+            sourceCredentialId: z.string().optional().describe('Optional source org credential Id.'),
+            sourceOrgId: z.string().describe('Source org Id.'),
+        },
+        title: 'Agentia Metadata Content Get',
+    }, (args) => safelyHandleTool(() => metadataContentGet(args)));
+    server.registerTool('agentia_metadata_index_compare', {
+        description: 'Compare metadata between orgs or Git branches via the CICD gateway.',
+        inputSchema: {
+            comparisonMode: z.enum(COMPARISON_MODES).describe('Comparison mode.'),
+            filterType: z.string().optional().describe('Optional metadata type filter, for example ApexClass.'),
+            pipelineId: z.string().describe('Pipeline Id.'),
+            sourceCredentialId: z.string().describe('Source org credential Id.'),
+            sourceOrgId: z.string().describe('Source org Id.'),
+            targetOrgId: z.string().describe('Target org Id.'),
+        },
+        title: 'Agentia Metadata Index Compare',
+    }, (args) => safelyHandleTool(() => metadataIndexCompare(args)));
+    server.registerTool('agentia_metadata_content_compare', {
+        description: 'Compare one metadata component between two orgs or Git branches and return a unified diff.',
+        inputSchema: {
+            apiName: z.string().describe('Metadata API name.'),
+            fileName: z.string().optional().describe('Optional metadata file name.'),
+            metadataType: z.string().describe('Metadata type, for example ApexClass.'),
+            pipelineId: z.string().describe('Pipeline Id.'),
+            source: z.enum(CONTENT_SOURCES).optional().describe('Content source for the source side.'),
+            sourceBranch: z.string().optional().describe('Git branch for the source side.'),
+            sourceCredentialId: z.string().describe('Source org credential Id.'),
+            sourceOrgId: z.string().describe('Source org Id.'),
+            targetBranch: z.string().optional().describe('Git branch for the target side.'),
+            targetCredentialId: z.string().optional().describe('Target org credential Id.'),
+            targetOrgId: z.string().describe('Target org Id.'),
+            targetSource: z.enum(CONTENT_SOURCES).optional().describe('Content source for the target side.'),
+        },
+        title: 'Agentia Metadata Content Compare',
+    }, (args) => safelyHandleTool(() => metadataContentCompare(args)));
+    server.registerTool('agentia_metadata_dependency_list', {
+        description: 'Retrieve metadata dependencies via the CICD gateway.',
+        inputSchema: {
+            metadataCategory: z.string().optional().describe('Optional metadata category.'),
+            metadataName: z.string().describe('Metadata API name.'),
+            metadataType: z.string().describe('Metadata type, for example ApexClass.'),
+            moduleType: z.enum(MODULE_TYPES).optional().describe('Optional addon module type.'),
+            pipelineId: z.string().describe('Pipeline Id.'),
+            platformExperience: z.enum(PLATFORM_EXPERIENCES).optional().describe('Gateway platform experience header.'),
+            resultId: z.string().optional().describe('Optional result Id from a prior metadata operation.'),
+            retrieveMode: z.enum(RETRIEVE_MODES).optional().describe('Dependency retrieve mode.'),
+            sourceCredentialId: z.string().describe('Source org credential Id.'),
+            sourceOrgId: z.string().describe('Source org Id.'),
+            targetOrgId: z.string().optional().describe('Optional target org Id.'),
+        },
+        title: 'Agentia Metadata Dependency List',
+    }, (args) => safelyHandleTool(() => metadataDependencyList(args)));
+}
+//# sourceMappingURL=tools.js.map