@copado/agentia-cli 0.22.0-alpha.0 → 0.24.0-alpha.0

package/dist/lib/mcp/tools.js

@@ -1,3 +1,4 @@
+/* eslint-disable max-lines -- Tool schemas and registrations are intentionally colocated. */
 import { z } from 'zod';
 import { normalizeEnvironments } from '../../commands/environment/list.js';
 import { buildMetadataCompareFileRequests } from '../../commands/metadata/content/compare.js';
@@ -5,23 +6,31 @@ import { buildMetadataContentRequest } from '../../commands/metadata/content/get
 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 { CicdGateway, normalizeCicdBaseUrl } from '../cicd-gateway.js';
+import { CICD_REGIONS } from '../cicd-region.js';
+import { ALL_CREDENTIAL_TYPES, credentialLabel, getCicdBaseUrl, getCredential, maskSecret, setCicdBaseUrl, setCredential, } from '../credential-store.js';
+import { readDefaults, readLastBaseBranch, readLastWorkItem, resolveDefaults, unsetDefaults, writeDefaults, writeLastWorkSelection, } from '../defaults-store.js';
+import { runEnvironmentAuthStatus } from '../environment-auth-status.js';
 import { buildCreatePayload, buildMutationPayload, ENVIRONMENT_STRING_VALIDATION_KEYS, validateNonEmptyStringFields, } from '../environment-flags.js';
 import { DEFAULT_ENVIRONMENT_PLATFORM, DEFAULT_ENVIRONMENT_TYPE, ENVIRONMENT_TYPES, environmentEndpoint, environmentsListEndpoint, } 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 { checkoutFeatureBranch, fetchOriginBranch, getCurrentBranch, hasUnpushedCommits, listPendingChanges, } from '../git-worktree.js';
+import { JOB_LIST_LIMIT_MAX, JOB_LIST_LIMIT_MIN, jobEndpoint, jobKillEndpoint, jobListEndpoint, jobPauseEndpoint, jobResultLogEndpoint, jobResumeEndpoint, jobRunEndpoint, normalizeJob, normalizeJobOperation, normalizeJobs, resolveJobStepForLog, } from '../job-types.js';
+import { normalizeLocalGatewayBaseUrl, readLocalGatewayConfig } from '../local-gateway-config.js';
 import { COMPARISON_MODES, CONTENT_SOURCES, contentResultToCompareSide, createUnifiedDiff, INDEX_SOURCES, MODULE_TYPES, ORDER_DIRECTIONS, PLATFORM_EXPERIENCES, RETRIEVE_MODES, sourceSideLabel, } from '../metadata-common.js';
+import { buildRefreshDeletedRequest, buildRefreshIndexRequest, refreshStatusEndpoint, resolveRefreshSourceFromEnv, } from '../metadata-refresh.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 { normalizeProjects, projectsListEndpoint } from '../project-types.js';
+import { normalizeProject, normalizeProjects, projectEndpoint, projectsListEndpoint, } from '../project-types.js';
+import { buildPromotionConflictResolutionRequest, normalizePromotionConflicts, PROMOTION_CONFLICT_MODES, promotionConflictContentEndpoint, promotionConflictResolveEndpoint, promotionConflictsEndpoint, promotionConflictUndoEndpoint, withPromotionConflictErrorTranslation, } from '../promotion-conflicts.js';
 import { normalizePromotionDetail, normalizePromotions, PROMOTION_LIST_LIMIT_MAX, PROMOTION_LIST_LIMIT_MIN, promotionEndpoint, promotionListEndpoint, } from '../promotion-types.js';
 import { getUserContext } from '../user-context.js';
 import { DEFAULT_USER_ID, resolveUserId, userEndpoint } from '../user-types.js';
 import { resolveWorkItemId } from '../work-active.js';
 import { buildWorkCreatePayload } from '../work-defaults.js';
 import { validateNonEmptyStringFields as validateWorkNonEmptyStringFields, WORK_STRING_VALIDATION_KEYS, } from '../work-flags.js';
-import { normalizeUserStories, workCreateEndpoint, workEndpoint, workListEndpoint, } from '../work-types.js';
+import { performWorkPush } from '../work-push.js';
+import { extractUserStoryFromFeatureBranch, featureBranchName, normalizeUserStories, workCreateEndpoint, workDoneEndpoint, workEndpoint, workListEndpoint, workSetEndpoint, workStatusEndpoint, workSubmitEndpoint, } from '../work-types.js';
 import { safelyHandleTool } from './result.js';
 const MAX_LIMIT = 2000;
 const WORK_MUTATION_PAYLOAD_KEYS = [
@@ -185,6 +194,13 @@ async function jobList(args) {
         status: args.status,
         type: args.type,
     };
+    if (args.mine) {
+        const userId = (await getUserContext()).id?.trim();
+        if (userId === undefined || userId.length === 0) {
+            throw new Error('Current user ID is unavailable from the CICD gateway context.');
+        }
+        filters.ownerId = userId;
+    }
     const response = await CicdGateway.call({
         endpoint: jobListEndpoint(filters),
         method: 'GET',
@@ -576,7 +592,244 @@ async function workDelete(args) {
     });
     return { deleted: true, id };
 }
+function authCredentialResult(type) {
+    if (type === 'cicd') {
+        const localConfig = readLocalGatewayConfig();
+        const credential = localConfig.enabled ? localConfig.apiKey || getCredential(type) : getCredential(type);
+        if (credential === null || credential.trim().length === 0) {
+            return {
+                ...(localConfig.enabled ? { baseUrl: normalizeLocalGatewayBaseUrl(localConfig.url), local: true } : {}),
+                label: credentialLabel(type),
+                set: false,
+                type,
+            };
+        }
+        return {
+            baseUrl: localConfig.enabled ? normalizeLocalGatewayBaseUrl(localConfig.url) : getCicdBaseUrl(),
+            label: credentialLabel(type),
+            ...(localConfig.enabled ? { local: true } : {}),
+            masked: maskSecret(credential),
+            set: true,
+            type,
+        };
+    }
+    const credential = getCredential(type);
+    return credential === null
+        ? { label: credentialLabel(type), set: false, type }
+        : { label: credentialLabel(type), masked: maskSecret(credential), set: true, type };
+}
+async function authGet(args = {}) {
+    const types = [];
+    if (args.cicd)
+        types.push('cicd');
+    if (args.crt)
+        types.push('crt');
+    return { credentials: (types.length > 0 ? types : ALL_CREDENTIAL_TYPES).map((type) => authCredentialResult(type)) };
+}
+async function authSet(args) {
+    if (args.cicd === undefined && args.crt === undefined) {
+        throw new Error('Must provide at least one of cicd or crt.');
+    }
+    if ((args.region !== undefined || args.customUrl !== undefined) && args.cicd === undefined) {
+        throw new Error('region and customUrl can only be used together with cicd.');
+    }
+    if ([args.cicd, args.crt].some((value) => value !== undefined && value.trim().length === 0)) {
+        throw new Error('Credential values cannot be empty.');
+    }
+    if (args.customUrl !== undefined)
+        normalizeCicdBaseUrl(args.customUrl);
+    let baseUrl;
+    if (args.cicd !== undefined) {
+        try {
+            baseUrl = await CicdGateway.resolveAndValidateEndpoint(args.cicd, {
+                customUrl: args.customUrl,
+                region: args.region,
+            });
+        }
+        catch {
+            throw new Error('CICD API key could not be validated for the selected endpoint.');
+        }
+        setCicdBaseUrl(baseUrl);
+    }
+    const stored = [];
+    for (const [type, value] of [
+        ['cicd', args.cicd],
+        ['crt', args.crt],
+    ]) {
+        if (value !== undefined) {
+            setCredential(type, value);
+            stored.push({ label: credentialLabel(type), type });
+        }
+    }
+    if (args.cicd !== undefined) {
+        await getUserContext({ forceRefresh: true });
+    }
+    return { ...(baseUrl === undefined ? {} : { baseUrl }), stored };
+}
+async function environmentAuthStatus(args) {
+    return runEnvironmentAuthStatus({
+        credentialId: args.credentialId,
+        environmentId: assertRequired(args.id, 'id'),
+    });
+}
+async function jobLogGet(args) {
+    const jobId = assertRequired(args.id, 'id');
+    const response = await CicdGateway.call({ endpoint: jobEndpoint(jobId), method: 'GET' });
+    const { resultId, step } = resolveJobStepForLog(normalizeJob(response).steps, args.step);
+    const log = await CicdGateway.call({
+        endpoint: jobResultLogEndpoint(resultId),
+        method: 'GET',
+        responseType: 'text',
+    });
+    return { jobId, log, resultId, ...(step.id === undefined || step.id === null ? {} : { stepId: step.id }) };
+}
+async function projectGet(args) {
+    const response = await CicdGateway.call({
+        endpoint: projectEndpoint(assertRequired(args.id, 'id')),
+        method: 'GET',
+    });
+    return { project: normalizeProject(response) };
+}
+async function promotionConflictList(args) {
+    const conflicts = await withPromotionConflictErrorTranslation(() => CicdGateway.call({
+        endpoint: promotionConflictsEndpoint(args.promotionId),
+        method: 'GET',
+    }));
+    return { conflicts: normalizePromotionConflicts(conflicts) };
+}
+async function promotionConflictGet(args) {
+    const content = await withPromotionConflictErrorTranslation(() => CicdGateway.call({
+        endpoint: promotionConflictContentEndpoint(args.promotionId, args.id),
+        method: 'GET',
+        responseType: 'text',
+    }));
+    return { conflictId: args.id, content, promotionId: args.promotionId };
+}
+async function promotionConflictResolve(args) {
+    if (args.mode === 'auto' && args.content !== undefined) {
+        throw new Error('content can only be used when mode is manual.');
+    }
+    return withPromotionConflictErrorTranslation(() => CicdGateway.call({
+        body: buildPromotionConflictResolutionRequest(args.mode, args.content),
+        endpoint: promotionConflictResolveEndpoint(args.promotionId, args.id),
+        headers: { 'Content-Type': 'application/json' },
+        method: 'POST',
+    }));
+}
+async function promotionConflictUnresolve(args) {
+    return withPromotionConflictErrorTranslation(() => CicdGateway.call({
+        endpoint: promotionConflictUndoEndpoint(args.promotionId, args.id),
+        method: 'POST',
+    }));
+}
+async function metadataRefreshRun(args) {
+    const sourceContext = await resolveRefreshSourceFromEnv(args.env, {
+        sourceCredentialId: args.sourceCredentialId,
+        sourceOrgId: args.sourceOrgId,
+    });
+    const result = await CicdGateway.call({
+        body: buildRefreshIndexRequest({ ...sourceContext, ...args }),
+        endpoint: '/release/metadata/index/refresh',
+        headers: { 'Content-Type': 'application/json', 'platform-experience': args.platformExperience ?? 'salesforce' },
+        method: 'POST',
+    });
+    return { result };
+}
+async function metadataRefreshStatus(args) {
+    const result = await CicdGateway.call({
+        endpoint: refreshStatusEndpoint(args.jobId, args.moduleType),
+        headers: { 'platform-experience': args.platformExperience ?? 'salesforce' },
+        method: 'GET',
+    });
+    return { result };
+}
+async function metadataRefreshDeleted(args) {
+    const sourceContext = await resolveRefreshSourceFromEnv(args.env, {
+        sourceCredentialId: args.sourceCredentialId,
+        sourceOrgId: args.sourceOrgId,
+    });
+    const result = await CicdGateway.call({
+        body: buildRefreshDeletedRequest(sourceContext.sourceCredentialId, args.moduleType),
+        endpoint: '/release/metadata/index/refresh-deleted',
+        headers: { 'Content-Type': 'application/json' },
+        method: 'POST',
+    });
+    return { result };
+}
+function assertCleanWorktree(pendingFiles) {
+    if (pendingFiles.length > 0) {
+        throw new Error(`Uncommitted tracked changes present:\n${pendingFiles.map((file) => `  ${file}`).join('\n')}`);
+    }
+}
+const mcpWorkPushHooks = {
+    display: (render) => render(),
+    log() { },
+    withSpinner: async (_message, action) => action(),
+};
+async function workSet(args) {
+    const setResponse = await CicdGateway.call({
+        body: { workItem: assertRequired(args.id, 'id') },
+        endpoint: workSetEndpoint(),
+        headers: { 'Content-Type': 'application/json' },
+        method: 'POST',
+    });
+    const baseBranch = args.baseBranch?.trim() || setResponse.baseBranch?.trim();
+    const userStoryId = setResponse.workItem.id?.trim();
+    const userStoryName = setResponse.workItem.name?.trim();
+    if (!baseBranch || !userStoryId || !userStoryName)
+        throw new Error('Work set response is missing a base branch, user story ID, or name.');
+    assertCleanWorktree(await listPendingChanges());
+    const branch = featureBranchName(userStoryName);
+    await fetchOriginBranch(baseBranch);
+    const checkout = await checkoutFeatureBranch(branch, baseBranch);
+    await writeLastWorkSelection({ lastBaseBranch: baseBranch, lastWorkItem: userStoryName, lastWorkItemId: userStoryId });
+    return { ...setResponse, baseBranch, git: { branch: checkout.branch, branchCreated: checkout.created, fetched: true } };
+}
+async function resolveCurrentWorkBranch() {
+    const branch = await getCurrentBranch();
+    const workItem = extractUserStoryFromFeatureBranch(branch);
+    if (workItem === undefined)
+        throw new Error(`Current branch '${branch}' is not a feature/US-XXXX branch.`);
+    assertCleanWorktree(await listPendingChanges());
+    return { branch, workItem };
+}
+async function workPush() {
+    const { branch, workItem } = await resolveCurrentWorkBranch();
+    const baseBranch = (await readLastBaseBranch())?.trim();
+    if (!baseBranch)
+        throw new Error('No base branch recorded. Run work set first.');
+    return performWorkPush({ baseBranch, branch, hooks: mcpWorkPushHooks, workItem });
+}
+async function workStatus(args = {}) {
+    const workItem = args.id?.trim() || (await readLastWorkItem());
+    if (!workItem)
+        throw new Error('No work item specified and no last work item recorded.');
+    const result = await CicdGateway.call({ endpoint: workStatusEndpoint(workItem), method: 'GET' });
+    return { result };
+}
+async function workSubmitOrDone(kind) {
+    const { branch, workItem } = await resolveCurrentWorkBranch();
+    const pushed = await hasUnpushedCommits(branch);
+    const push = pushed ? await workPush() : undefined;
+    const endpoint = kind === 'submit' ? workSubmitEndpoint() : workDoneEndpoint();
+    const result = await CicdGateway.call({
+        body: { workItem },
+        endpoint,
+        headers: { 'Content-Type': 'application/json' },
+        method: 'POST',
+    });
+    return { branch, [kind]: result, ...(push === undefined ? {} : { push }), pushed, workItem };
+}
+async function workSubmit() {
+    return workSubmitOrDone('submit');
+}
+async function workDone() {
+    return workSubmitOrDone('done');
+}
 export const agentiaMcpToolHandlers = {
+    authGet,
+    authSet,
+    environmentAuthStatus,
     environmentCreate,
     environmentGet,
     environmentList,
@@ -584,6 +837,7 @@ export const agentiaMcpToolHandlers = {
     jobGet,
     jobKill,
     jobList,
+    jobLogGet,
     jobPause,
     jobResume,
     jobRun,
@@ -592,20 +846,33 @@ export const agentiaMcpToolHandlers = {
     metadataDependencyList,
     metadataIndexCompare,
     metadataList,
+    metadataRefreshDeleted,
+    metadataRefreshRun,
+    metadataRefreshStatus,
     pipelineConnectionList,
     pipelineGet,
     pipelineList,
     projectDefaultGet,
     projectDefaultSet,
     projectDefaultUnset,
+    projectGet,
     projectList,
+    promotionConflictGet,
+    promotionConflictList,
+    promotionConflictResolve,
+    promotionConflictUnresolve,
     promotionGet,
     promotionList,
     userGet,
     workCreate,
     workDelete,
+    workDone,
     workGet,
     workList,
+    workPush,
+    workSet,
+    workStatus,
+    workSubmit,
     workUpdate,
 };
 const environmentMutationSchema = {
@@ -753,6 +1020,7 @@ export function registerAgentiaMcpTools(server) {
                 .max(JOB_LIST_LIMIT_MAX)
                 .optional()
                 .describe(`Maximum number of jobs to return (${JOB_LIST_LIMIT_MIN}-${JOB_LIST_LIMIT_MAX}).`),
+            mine: z.boolean().optional().describe('List only jobs owned by the current user.'),
             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.'),
@@ -974,5 +1242,140 @@ export function registerAgentiaMcpTools(server) {
         },
         title: 'Agentia Metadata Dependency List',
     }, (args) => safelyHandleTool(() => metadataDependencyList(args)));
+    server.registerTool('agentia_auth_get', {
+        description: 'Show masked Agentia credential status from the system keychain.',
+        inputSchema: {
+            cicd: z.boolean().optional().describe('Include the CICD credential.'),
+            crt: z.boolean().optional().describe('Include the CRT credential.'),
+        },
+        title: 'Agentia Auth Get',
+    }, (args) => safelyHandleTool(() => authGet(args || {})));
+    server.registerTool('agentia_auth_set', {
+        description: 'Store CICD and/or CRT credentials in the system keychain. Credential input is sensitive.',
+        inputSchema: {
+            cicd: z.string().optional().describe('CICD API key to store.'),
+            crt: z.string().optional().describe('CRT personal access token to store.'),
+            customUrl: z.string().optional().describe('CICD gateway URL to validate with the CICD API key.'),
+            region: z.enum(CICD_REGIONS).optional().describe('CICD region to validate with the CICD API key.'),
+        },
+        title: 'Agentia Auth Set',
+    }, (args) => safelyHandleTool(() => authSet(args)));
+    server.registerTool('agentia_environment_auth_status', {
+        description: 'Validate an environment credential through the CICD gateway.',
+        inputSchema: {
+            credentialId: z.string().optional().describe('Credential ID when selection is ambiguous.'),
+            id: z.string().describe('Copado environment ID.'),
+        },
+        title: 'Agentia Environment Auth Status',
+    }, (args) => safelyHandleTool(() => environmentAuthStatus(args)));
+    server.registerTool('agentia_job_log_get', {
+        description: 'Get raw log output for a Copado job execution step.',
+        inputSchema: {
+            id: z.string().describe('JobExecution ID.'),
+            step: z.string().optional().describe('Job step ID. Defaults to the first step with a result ID.'),
+        },
+        title: 'Agentia Job Log Get',
+    }, (args) => safelyHandleTool(() => jobLogGet(args)));
+    server.registerTool('agentia_project_get', {
+        description: 'Get a Copado project by ID via the CICD gateway.',
+        inputSchema: { id: z.string().describe('Copado project ID.') },
+        title: 'Agentia Project Get',
+    }, (args) => safelyHandleTool(() => projectGet(args)));
+    server.registerTool('agentia_promotion_conflict_list', {
+        description: 'List merge conflicts for a Copado promotion.',
+        inputSchema: { promotionId: z.string().describe('Copado promotion ID.') },
+        title: 'Agentia Promotion Conflict List',
+    }, (args) => safelyHandleTool(() => promotionConflictList(args)));
+    server.registerTool('agentia_promotion_conflict_get', {
+        description: 'Get raw merge-conflict content for a Copado promotion file.',
+        inputSchema: {
+            id: z.string().describe('Conflict attachment ID.'),
+            promotionId: z.string().describe('Copado promotion ID.'),
+        },
+        title: 'Agentia Promotion Conflict Get',
+    }, (args) => safelyHandleTool(() => promotionConflictGet(args)));
+    server.registerTool('agentia_promotion_conflict_resolve', {
+        description: 'Resolve a promotion merge conflict automatically or with manual content.',
+        inputSchema: {
+            content: z.string().optional().describe('Manual resolved content. Required when mode is manual.'),
+            id: z.string().describe('Conflict attachment ID.'),
+            mode: z.enum(PROMOTION_CONFLICT_MODES).describe('Conflict resolution mode.'),
+            promotionId: z.string().describe('Copado promotion ID.'),
+        },
+        title: 'Agentia Promotion Conflict Resolve',
+    }, (args) => safelyHandleTool(() => promotionConflictResolve(args)));
+    server.registerTool('agentia_promotion_conflict_unresolve', {
+        description: 'Undo a promotion conflict resolution.',
+        inputSchema: {
+            id: z.string().describe('Conflict attachment ID.'),
+            promotionId: z.string().describe('Copado promotion ID.'),
+        },
+        title: 'Agentia Promotion Conflict Unresolve',
+    }, (args) => safelyHandleTool(() => promotionConflictUnresolve(args)));
+    server.registerTool('agentia_metadata_refresh_run', {
+        description: 'Trigger a metadata index refresh via the CICD gateway.',
+        inputSchema: {
+            all: z.boolean().optional().describe('Replace the metadata index instead of merging it.'),
+            env: z.string().describe('Environment ID used to resolve source configuration.'),
+            gitFiles: z.array(z.string()).optional().describe('Git file paths to refresh.'),
+            moduleType: z.enum(MODULE_TYPES).optional().describe('Optional addon module type.'),
+            pipelineId: z.string().optional().describe('Optional pipeline ID.'),
+            platformExperience: z.enum(PLATFORM_EXPERIENCES).optional().describe('Gateway platform experience header.'),
+            refreshMode: z.string().optional().describe('Optional refresh mode.'),
+            selectedName: z.string().optional().describe('Selected metadata API name.'),
+            selectedType: z.string().optional().describe('Selected metadata type.'),
+            sourceCredentialId: z.string().optional().describe('Override the source credential ID.'),
+            sourceOrgId: z.string().optional().describe('Override the source org ID.'),
+            targetOrgId: z.string().optional().describe('Optional target org ID.'),
+        },
+        title: 'Agentia Metadata Refresh Run',
+    }, (args) => safelyHandleTool(() => metadataRefreshRun(args)));
+    server.registerTool('agentia_metadata_refresh_status', {
+        description: 'Get metadata index refresh status via the CICD gateway.',
+        inputSchema: {
+            jobId: z.string().describe('Metadata refresh event ID.'),
+            moduleType: z.enum(MODULE_TYPES).optional().describe('Addon module type used by the refresh.'),
+            platformExperience: z.enum(PLATFORM_EXPERIENCES).optional().describe('Gateway platform experience header.'),
+        },
+        title: 'Agentia Metadata Refresh Status',
+    }, (args) => safelyHandleTool(() => metadataRefreshStatus(args)));
+    server.registerTool('agentia_metadata_refresh_deleted', {
+        description: 'Refresh deleted metadata index entries via the CICD gateway.',
+        inputSchema: {
+            env: z.string().describe('Environment ID used to resolve the source credential.'),
+            moduleType: z.enum(MODULE_TYPES).optional().describe('Optional addon module type.'),
+            sourceCredentialId: z.string().optional().describe('Override the source credential ID.'),
+            sourceOrgId: z.string().optional().describe('Override the source org ID for environment validation.'),
+        },
+        title: 'Agentia Metadata Refresh Deleted',
+    }, (args) => safelyHandleTool(() => metadataRefreshDeleted(args)));
+    server.registerTool('agentia_work_set', {
+        description: 'Set the active work item, then fetch and check out its feature branch in the MCP server current Git repository. Changes the current branch.',
+        inputSchema: {
+            baseBranch: z.string().optional().describe('Override the base branch returned by Copado.'),
+            id: z.string().describe('User story ID or name.'),
+        },
+        title: 'Agentia Work Set',
+    }, (args) => safelyHandleTool(() => workSet(args)));
+    server.registerTool('agentia_work_status', {
+        description: 'Get work status and related jobs. Defaults to the active work item from work set.',
+        inputSchema: { id: z.string().optional().describe('User story ID or name.') },
+        title: 'Agentia Work Status',
+    }, (args) => safelyHandleTool(() => workStatus(args || {})));
+    server.registerTool('agentia_work_push', {
+        description: 'Push and register commits for the current feature branch in the MCP server current Git repository. Pushes to origin.',
+        inputSchema: {},
+        title: 'Agentia Work Push',
+    }, () => safelyHandleTool(() => workPush()));
+    server.registerTool('agentia_work_submit', {
+        description: 'Submit the current feature-branch work item. Pushes and registers unpushed commits in the MCP server current Git repository first.',
+        inputSchema: {},
+        title: 'Agentia Work Submit',
+    }, () => safelyHandleTool(() => workSubmit()));
+    server.registerTool('agentia_work_done', {
+        description: 'Mark the current feature-branch work item done. Pushes and registers unpushed commits in the MCP server current Git repository first.',
+        inputSchema: {},
+        title: 'Agentia Work Done',
+    }, () => safelyHandleTool(() => workDone()));
 }
 //# sourceMappingURL=tools.js.map