tempo-api-mcp 2.0.0 → 2.0.1

package/dist/tools/projects.js

@@ -1,203 +1,128 @@
-export const toolDefinitions = [
-    {
-        name: 'tempo_get_projects',
+import { z } from 'zod';
+export function register(server, client) {
+    server.registerTool('tempo_get_projects', {
         description: 'Retrieve a paginated list of all Tempo Financial Manager projects.',
         annotations: { readOnlyHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                offset: { type: 'integer', description: 'Pagination offset' },
-                limit: { type: 'integer', description: 'Max results (default 50)' },
-            },
-            required: [],
+            offset: z.number().int().optional().describe('Pagination offset'),
+            limit: z.number().int().optional().describe('Max results (default 50)'),
         },
-    },
-    {
-        name: 'tempo_get_project',
+    }, async ({ offset, limit }) => {
+        const data = await client.request('GET', '/4/projects', undefined, { offset, limit });
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_get_project', {
         description: 'Retrieve a single Tempo Financial Manager project by id.',
         annotations: { readOnlyHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                id: { type: 'string', description: 'Project id' },
-            },
-            required: ['id'],
+            id: z.string().describe('Project id'),
         },
-    },
-    {
-        name: 'tempo_get_timesheet_approval_status',
+    }, async ({ id }) => {
+        const data = await client.request('GET', `/4/projects/${id}`);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_get_timesheet_approval_status', {
         description: 'Retrieve the current timesheet approval status for a user in the given period.',
         annotations: { readOnlyHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                accountId: { type: 'string', description: 'Atlassian account id of the user' },
-                from: { type: 'string', description: 'Period start date (YYYY-MM-DD)' },
-                to: { type: 'string', description: 'Period end date (YYYY-MM-DD)' },
-            },
-            required: ['accountId'],
+            accountId: z.string().describe('Atlassian account id of the user'),
+            from: z.string().optional().describe('Period start date (YYYY-MM-DD)'),
+            to: z.string().optional().describe('Period end date (YYYY-MM-DD)'),
         },
-    },
-    {
-        name: 'tempo_get_timesheet_approvals_waiting',
+    }, async ({ accountId, from, to }) => {
+        const data = await client.request('GET', `/4/timesheet-approvals/user/${accountId}`, undefined, { from, to });
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_get_timesheet_approvals_waiting', {
         description: 'Retrieve all timesheets that are currently waiting for approval.',
         annotations: { readOnlyHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                offset: { type: 'integer', description: 'Pagination offset' },
-                limit: { type: 'integer', description: 'Max results' },
-            },
-            required: [],
+            offset: z.number().int().optional().describe('Pagination offset'),
+            limit: z.number().int().optional().describe('Max results'),
         },
-    },
-    {
-        name: 'tempo_search_timesheet_approval_logs',
+    }, async ({ offset, limit }) => {
+        const data = await client.request('GET', '/4/timesheet-approvals/waiting', undefined, { offset, limit });
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_search_timesheet_approval_logs', {
         description: 'Search timesheet approval audit logs.',
         annotations: { readOnlyHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                accountIds: { type: 'array', items: { type: 'string' }, description: 'Filter by Atlassian account ids' },
-                reviewerIds: { type: 'array', items: { type: 'string' }, description: 'Filter by reviewer account ids' },
-                from: { type: 'string', description: 'Start date (YYYY-MM-DD)' },
-                to: { type: 'string', description: 'End date (YYYY-MM-DD)' },
-                offset: { type: 'integer', description: 'Pagination offset' },
-                limit: { type: 'integer', description: 'Max results' },
-            },
-            required: [],
+            accountIds: z.array(z.string()).optional().describe('Filter by Atlassian account ids'),
+            reviewerIds: z.array(z.string()).optional().describe('Filter by reviewer account ids'),
+            from: z.string().optional().describe('Start date (YYYY-MM-DD)'),
+            to: z.string().optional().describe('End date (YYYY-MM-DD)'),
+            offset: z.number().int().optional().describe('Pagination offset'),
+            limit: z.number().int().optional().describe('Max results'),
         },
-    },
-    {
-        name: 'tempo_get_periods',
+    }, async ({ accountIds, reviewerIds, from, to, offset, limit }) => {
+        const qs = {};
+        if (offset !== undefined)
+            qs.offset = offset;
+        if (limit !== undefined)
+            qs.limit = limit;
+        const body = {};
+        if (accountIds)
+            body.accountIds = accountIds;
+        if (reviewerIds)
+            body.reviewerIds = reviewerIds;
+        if (from)
+            body.from = from;
+        if (to)
+            body.to = to;
+        const data = await client.request('POST', '/4/timesheet-approvals/logs/search', body, qs);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_get_periods', {
         description: 'Retrieve Tempo period definitions (used for timesheet approval cycles).',
         annotations: { readOnlyHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                from: { type: 'string', description: 'Start date (YYYY-MM-DD)' },
-                to: { type: 'string', description: 'End date (YYYY-MM-DD)' },
-            },
-            required: [],
+            from: z.string().optional().describe('Start date (YYYY-MM-DD)'),
+            to: z.string().optional().describe('End date (YYYY-MM-DD)'),
         },
-    },
-    {
-        name: 'tempo_get_user_schedule',
+    }, async ({ from, to }) => {
+        const data = await client.request('GET', '/4/periods', undefined, { from, to });
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_get_user_schedule', {
         description: 'Retrieve the work schedule for a user, including planned working hours per day.',
         annotations: { readOnlyHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                accountId: { type: 'string', description: 'Atlassian account id of the user' },
-                from: { type: 'string', description: 'Start date (YYYY-MM-DD)' },
-                to: { type: 'string', description: 'End date (YYYY-MM-DD)' },
-            },
-            required: ['accountId', 'from', 'to'],
+            accountId: z.string().describe('Atlassian account id of the user'),
+            from: z.string().describe('Start date (YYYY-MM-DD)'),
+            to: z.string().describe('End date (YYYY-MM-DD)'),
         },
-    },
-    {
-        name: 'tempo_get_global_configuration',
+    }, async ({ accountId, from, to }) => {
+        const data = await client.request('GET', `/4/user-schedule`, undefined, { accountId, from, to });
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_get_global_configuration', {
         description: 'Retrieve the global Tempo configuration settings.',
         annotations: { readOnlyHint: true },
-        inputSchema: {
-            type: 'object',
-            properties: {},
-            required: [],
-        },
-    },
-    {
-        name: 'tempo_get_work_attributes',
+    }, async () => {
+        const data = await client.request('GET', '/4/globalconfiguration');
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_get_work_attributes', {
         description: 'Retrieve all Tempo work attributes (custom fields on worklogs).',
         annotations: { readOnlyHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                offset: { type: 'integer', description: 'Pagination offset' },
-                limit: { type: 'integer', description: 'Max results' },
-            },
-            required: [],
+            offset: z.number().int().optional().describe('Pagination offset'),
+            limit: z.number().int().optional().describe('Max results'),
         },
-    },
-    {
-        name: 'tempo_get_roles',
+    }, async ({ offset, limit }) => {
+        const data = await client.request('GET', '/4/work-attributes', undefined, { offset, limit });
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_get_roles', {
         description: 'Retrieve all Tempo roles.',
         annotations: { readOnlyHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                offset: { type: 'integer', description: 'Pagination offset' },
-                limit: { type: 'integer', description: 'Max results' },
-            },
-            required: [],
+            offset: z.number().int().optional().describe('Pagination offset'),
+            limit: z.number().int().optional().describe('Max results'),
         },
-    },
-];
-export async function handleTool(name, args, client) {
-    switch (name) {
-        case 'tempo_get_projects': {
-            const { offset, limit } = args;
-            const data = await client.request('GET', '/4/projects', undefined, { offset, limit });
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_get_project': {
-            const { id } = args;
-            const data = await client.request('GET', `/4/projects/${id}`);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_get_timesheet_approval_status': {
-            const { accountId, from, to } = args;
-            const data = await client.request('GET', `/4/timesheet-approvals/user/${accountId}`, undefined, { from, to });
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_get_timesheet_approvals_waiting': {
-            const { offset, limit } = args;
-            const data = await client.request('GET', '/4/timesheet-approvals/waiting', undefined, { offset, limit });
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_search_timesheet_approval_logs': {
-            const { accountIds, reviewerIds, from, to, offset, limit } = args;
-            const qs = {};
-            if (offset !== undefined)
-                qs.offset = offset;
-            if (limit !== undefined)
-                qs.limit = limit;
-            const body = {};
-            if (accountIds)
-                body.accountIds = accountIds;
-            if (reviewerIds)
-                body.reviewerIds = reviewerIds;
-            if (from)
-                body.from = from;
-            if (to)
-                body.to = to;
-            const data = await client.request('POST', '/4/timesheet-approvals/logs/search', body, qs);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_get_periods': {
-            const { from, to } = args;
-            const data = await client.request('GET', '/4/periods', undefined, { from, to });
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_get_user_schedule': {
-            const { accountId, from, to } = args;
-            const data = await client.request('GET', `/4/user-schedule`, undefined, { accountId, from, to });
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_get_global_configuration': {
-            const data = await client.request('GET', '/4/globalconfiguration');
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_get_work_attributes': {
-            const { offset, limit } = args;
-            const data = await client.request('GET', '/4/work-attributes', undefined, { offset, limit });
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_get_roles': {
-            const { offset, limit } = args;
-            const data = await client.request('GET', '/4/roles', undefined, { offset, limit });
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        default:
-            throw new Error(`Unknown tool: ${name}`);
-    }
+    }, async ({ offset, limit }) => {
+        const data = await client.request('GET', '/4/roles', undefined, { offset, limit });
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
 }

package/dist/tools/teams.js

@@ -1,176 +1,123 @@
-export const toolDefinitions = [
-    {
-        name: 'tempo_get_teams',
+import { z } from 'zod';
+function buildTeamBody(args) {
+    const body = { name: args.name };
+    if (args.summary !== undefined)
+        body.summary = args.summary;
+    if (args.leadAccountId !== undefined)
+        body.leadAccountId = args.leadAccountId;
+    if (args.programId !== undefined)
+        body.programId = args.programId;
+    return body;
+}
+export function register(server, client) {
+    server.registerTool('tempo_get_teams', {
         description: 'Retrieve a list of Tempo teams. Can filter by name, member account ids, or specific team ids.',
         annotations: { readOnlyHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                name: { type: 'string', description: 'Filter by team name' },
-                teamIds: { type: 'array', items: { type: 'integer' }, description: 'Filter by specific team ids' },
-                teamMembers: { type: 'array', items: { type: 'string' }, description: 'Filter by member Atlassian account ids' },
-                includeMemberships: { type: 'boolean', description: 'Include team member memberships in response' },
-                offset: { type: 'integer', description: 'Pagination offset' },
-                limit: { type: 'integer', description: 'Max results (default 50)' },
-            },
-            required: [],
+            name: z.string().optional().describe('Filter by team name'),
+            teamIds: z.array(z.number().int()).optional().describe('Filter by specific team ids'),
+            teamMembers: z.array(z.string()).optional().describe('Filter by member Atlassian account ids'),
+            includeMemberships: z.boolean().optional().describe('Include team member memberships in response'),
+            offset: z.number().int().optional().describe('Pagination offset'),
+            limit: z.number().int().optional().describe('Max results (default 50)'),
         },
-    },
-    {
-        name: 'tempo_get_team',
+    }, async ({ name: teamName, teamIds, teamMembers, includeMemberships, offset, limit }) => {
+        const data = await client.request('GET', '/4/teams', undefined, {
+            name: teamName, teamIds, teamMembers, includeMemberships, offset, limit,
+        });
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_get_team', {
         description: 'Retrieve a single Tempo team by id.',
         annotations: { readOnlyHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                id: { type: 'integer', description: 'Team id' },
-            },
-            required: ['id'],
+            id: z.number().int().describe('Team id'),
         },
-    },
-    {
-        name: 'tempo_create_team',
+    }, async ({ id }) => {
+        const data = await client.request('GET', `/4/teams/${id}`);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_create_team', {
         description: 'Create a new Tempo team.',
         annotations: { readOnlyHint: false },
         inputSchema: {
-            type: 'object',
-            properties: {
-                name: { type: 'string', description: 'Team name' },
-                summary: { type: 'string', description: 'Short description of the team' },
-                leadAccountId: { type: 'string', description: 'Atlassian account id of the team lead' },
-                programId: { type: 'integer', description: 'Id of the program this team belongs to' },
-            },
-            required: ['name'],
+            name: z.string().describe('Team name'),
+            summary: z.string().optional().describe('Short description of the team'),
+            leadAccountId: z.string().optional().describe('Atlassian account id of the team lead'),
+            programId: z.number().int().optional().describe('Id of the program this team belongs to'),
         },
-    },
-    {
-        name: 'tempo_update_team',
+    }, async (args) => {
+        const body = buildTeamBody(args);
+        const data = await client.request('POST', '/4/teams', body);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_update_team', {
         description: 'Update an existing Tempo team by id.',
         annotations: { readOnlyHint: false },
         inputSchema: {
-            type: 'object',
-            properties: {
-                id: { type: 'integer', description: 'Team id' },
-                name: { type: 'string', description: 'Team name' },
-                summary: { type: 'string', description: 'Short description of the team' },
-                leadAccountId: { type: 'string', description: 'Atlassian account id of the team lead' },
-                programId: { type: 'integer', description: 'Id of the program this team belongs to' },
-            },
-            required: ['id', 'name'],
+            id: z.number().int().describe('Team id'),
+            name: z.string().describe('Team name'),
+            summary: z.string().optional().describe('Short description of the team'),
+            leadAccountId: z.string().optional().describe('Atlassian account id of the team lead'),
+            programId: z.number().int().optional().describe('Id of the program this team belongs to'),
         },
-    },
-    {
-        name: 'tempo_delete_team',
+    }, async ({ id, ...rest }) => {
+        const body = buildTeamBody(rest);
+        const data = await client.request('PUT', `/4/teams/${id}`, body);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_delete_team', {
         description: 'Delete a Tempo team by id.',
         annotations: { readOnlyHint: false },
         inputSchema: {
-            type: 'object',
-            properties: {
-                id: { type: 'integer', description: 'Team id' },
-            },
-            required: ['id'],
+            id: z.number().int().describe('Team id'),
         },
-    },
-    {
-        name: 'tempo_get_team_memberships',
+    }, async ({ id }) => {
+        await client.request('DELETE', `/4/teams/${id}`);
+        return { content: [{ type: 'text', text: `Team ${id} deleted successfully` }] };
+    });
+    server.registerTool('tempo_get_team_memberships', {
         description: 'Retrieve team memberships, optionally filtered by account id or team id.',
         annotations: { readOnlyHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                accountIds: { type: 'array', items: { type: 'string' }, description: 'Filter by Atlassian account ids' },
-                teamIds: { type: 'array', items: { type: 'integer' }, description: 'Filter by team ids' },
-                offset: { type: 'integer', description: 'Pagination offset' },
-                limit: { type: 'integer', description: 'Max results (default 50)' },
-            },
-            required: [],
+            accountIds: z.array(z.string()).optional().describe('Filter by Atlassian account ids'),
+            teamIds: z.array(z.number().int()).optional().describe('Filter by team ids'),
+            offset: z.number().int().optional().describe('Pagination offset'),
+            limit: z.number().int().optional().describe('Max results (default 50)'),
         },
-    },
-    {
-        name: 'tempo_search_team_memberships',
+    }, async ({ accountIds, teamIds, offset, limit }) => {
+        const data = await client.request('GET', '/4/team-memberships', undefined, {
+            accountIds, teamIds, offset, limit,
+        });
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_search_team_memberships', {
         description: 'Search Tempo team memberships with advanced filters via POST.',
         annotations: { readOnlyHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                teamIds: { type: 'array', items: { type: 'integer' }, description: 'Filter by team ids' },
-                accountIds: { type: 'array', items: { type: 'string' }, description: 'Filter by Atlassian account ids' },
-                from: { type: 'string', description: 'Membership active from date (YYYY-MM-DD)' },
-                to: { type: 'string', description: 'Membership active to date (YYYY-MM-DD)' },
-                offset: { type: 'integer', description: 'Pagination offset' },
-                limit: { type: 'integer', description: 'Max results' },
-            },
-            required: [],
+            teamIds: z.array(z.number().int()).optional().describe('Filter by team ids'),
+            accountIds: z.array(z.string()).optional().describe('Filter by Atlassian account ids'),
+            from: z.string().optional().describe('Membership active from date (YYYY-MM-DD)'),
+            to: z.string().optional().describe('Membership active to date (YYYY-MM-DD)'),
+            offset: z.number().int().optional().describe('Pagination offset'),
+            limit: z.number().int().optional().describe('Max results'),
         },
-    },
-];
-function buildTeamBody(args) {
-    const body = { name: args.name };
-    if (args.summary !== undefined)
-        body.summary = args.summary;
-    if (args.leadAccountId !== undefined)
-        body.leadAccountId = args.leadAccountId;
-    if (args.programId !== undefined)
-        body.programId = args.programId;
-    return body;
-}
-export async function handleTool(name, args, client) {
-    switch (name) {
-        case 'tempo_get_teams': {
-            const { name: teamName, teamIds, teamMembers, includeMemberships, offset, limit } = args;
-            const data = await client.request('GET', '/4/teams', undefined, {
-                name: teamName, teamIds, teamMembers, includeMemberships, offset, limit,
-            });
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_get_team': {
-            const { id } = args;
-            const data = await client.request('GET', `/4/teams/${id}`);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_create_team': {
-            const body = buildTeamBody(args);
-            const data = await client.request('POST', '/4/teams', body);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_update_team': {
-            const { id, ...rest } = args;
-            const body = buildTeamBody(rest);
-            const data = await client.request('PUT', `/4/teams/${id}`, body);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_delete_team': {
-            const { id } = args;
-            await client.request('DELETE', `/4/teams/${id}`);
-            return { content: [{ type: 'text', text: `Team ${id} deleted successfully` }] };
-        }
-        case 'tempo_get_team_memberships': {
-            const { accountIds, teamIds, offset, limit } = args;
-            const data = await client.request('GET', '/4/team-memberships', undefined, {
-                accountIds, teamIds, offset, limit,
-            });
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_search_team_memberships': {
-            const { teamIds, accountIds, from, to, offset, limit } = args;
-            const query = {};
-            if (offset !== undefined)
-                query.offset = offset;
-            if (limit !== undefined)
-                query.limit = limit;
-            const body = {};
-            if (teamIds)
-                body.teamIds = teamIds;
-            if (accountIds)
-                body.accountIds = accountIds;
-            if (from)
-                body.from = from;
-            if (to)
-                body.to = to;
-            const data = await client.request('POST', '/4/team-memberships/search', body, query);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        default:
-            throw new Error(`Unknown tool: ${name}`);
-    }
+    }, async ({ teamIds, accountIds, from, to, offset, limit }) => {
+        const query = {};
+        if (offset !== undefined)
+            query.offset = offset;
+        if (limit !== undefined)
+            query.limit = limit;
+        const body = {};
+        if (teamIds)
+            body.teamIds = teamIds;
+        if (accountIds)
+            body.accountIds = accountIds;
+        if (from)
+            body.from = from;
+        if (to)
+            body.to = to;
+        const data = await client.request('POST', '/4/team-memberships/search', body, query);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
 }