@mmtr-tech/yandex-tracker-mcp 0.1.0

package/dist/tools/issue-extras.js

@@ -0,0 +1,256 @@
+import { z } from 'zod';
+import { registerTool } from './index.js';
+const createLinkSchema = z.object({
+    issueId: z.string().min(1).describe('Source issue key or id'),
+    relationship: z.string().min(1)
+        .describe('relates | depends on | is dependent by | is subtask for | is parent task for | duplicates | is duplicated by | is epic of | has epic'),
+    linkedIssueId: z.string().min(1).describe('Target issue key or id'),
+});
+const deleteLinkSchema = z.object({
+    issueId: z.string().min(1).describe('Issue key or id'),
+    linkId: z.union([z.string().min(1), z.coerce.number()]).describe('Link id from get_issue_links'),
+});
+const followersSchema = z.object({
+    issueId: z.string().min(1).describe('Issue key or id'),
+    users: z.array(z.string().min(1)).min(1).describe('Logins or uids'),
+    version: z.coerce.number().int().positive().optional(),
+});
+const worklogListSchema = z.object({
+    issueId: z.string().min(1),
+    perPage: z.coerce.number().int().positive().max(100).optional(),
+    afterId: z.coerce.number().int().positive().optional(),
+});
+const addWorklogSchema = z.object({
+    issueId: z.string().min(1),
+    duration: z.string().min(1).describe('ISO 8601 duration, e.g. PT1H, PT30M, P1D'),
+    start: z.string().optional().describe('Start datetime YYYY-MM-DDThh:mm:ss.sss±hhmm'),
+    comment: z.string().optional(),
+});
+const countIssuesSchema = z
+    .object({
+    query: z.string().min(1).optional(),
+    filter: z.record(z.unknown()).optional(),
+})
+    .superRefine((val, ctx) => {
+    const modes = [val.query, val.filter].filter((v) => v !== undefined);
+    if (modes.length !== 1) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'Provide exactly one of: query or filter',
+        });
+    }
+});
+const checklistItemSchema = z
+    .object({
+    issueId: z.string().min(1),
+    itemId: z.string().min(1),
+    checked: z.boolean().optional(),
+    text: z.string().min(1).optional(),
+})
+    .superRefine((val, ctx) => {
+    if (val.checked === undefined && val.text === undefined) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'Provide checked and/or text',
+        });
+    }
+});
+const uploadSchema = z.object({
+    issueId: z.string().min(1),
+    filePath: z.string().min(1).describe('Absolute path to a local file to upload'),
+    filename: z.string().min(1).optional().describe('Override filename stored in Tracker'),
+});
+const issueIdSchema = z.object({
+    issueId: z.string().min(1),
+});
+export function registerIssueExtraTools() {
+    registerTool({
+        zodSchema: createLinkSchema,
+        schema: {
+            name: 'create_issue_link',
+            description: 'CREATE a link between two issues (POST /issues/{issueId}/links). Side effect. relationship e.g. relates, depends on, is subtask for.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    issueId: { type: 'string', description: 'Source issue key or id' },
+                    relationship: {
+                        type: 'string',
+                        description: 'Link type: relates, depends on, is dependent by, …',
+                    },
+                    linkedIssueId: { type: 'string', description: 'Target issue key or id' },
+                },
+                required: ['issueId', 'relationship', 'linkedIssueId'],
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().createIssueLink(args);
+        },
+    });
+    registerTool({
+        zodSchema: deleteLinkSchema,
+        schema: {
+            name: 'delete_issue_link',
+            description: 'DELETE an issue link (DELETE /issues/{issueId}/links/{linkId}). Side effect. Take linkId from get_issue_links.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    issueId: { type: 'string' },
+                    linkId: { description: 'Link id', oneOf: [{ type: 'string' }, { type: 'number' }] },
+                },
+                required: ['issueId', 'linkId'],
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().deleteIssueLink(args);
+        },
+    });
+    registerTool({
+        zodSchema: followersSchema,
+        schema: {
+            name: 'add_issue_followers',
+            description: 'ADD watchers/followers to an issue (PATCH followers.add). Side effect.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    issueId: { type: 'string' },
+                    users: { type: 'array', items: { type: 'string' }, description: 'Logins or uids' },
+                    version: { type: 'number' },
+                },
+                required: ['issueId', 'users'],
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().addIssueFollowers(args);
+        },
+    });
+    registerTool({
+        zodSchema: followersSchema,
+        schema: {
+            name: 'remove_issue_followers',
+            description: 'REMOVE watchers/followers from an issue (PATCH followers.remove). Side effect.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    issueId: { type: 'string' },
+                    users: { type: 'array', items: { type: 'string' }, description: 'Logins or uids' },
+                    version: { type: 'number' },
+                },
+                required: ['issueId', 'users'],
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().removeIssueFollowers(args);
+        },
+    });
+    registerTool({
+        zodSchema: worklogListSchema,
+        schema: {
+            name: 'get_issue_worklog',
+            description: 'List worklog entries for an issue (GET /issues/{issueId}/worklog).',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    issueId: { type: 'string' },
+                    perPage: { type: 'number' },
+                    afterId: { type: 'number', description: 'Pagination cursor (worklog id)' },
+                },
+                required: ['issueId'],
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().getIssueWorklog(args);
+        },
+    });
+    registerTool({
+        zodSchema: addWorklogSchema,
+        schema: {
+            name: 'add_issue_worklog',
+            description: 'ADD a worklog entry (POST /issues/{issueId}/worklog). Side effect. duration is ISO 8601 (PT1H, PT30M).',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    issueId: { type: 'string' },
+                    duration: { type: 'string', description: 'ISO 8601 duration, e.g. PT1H' },
+                    start: { type: 'string' },
+                    comment: { type: 'string' },
+                },
+                required: ['issueId', 'duration'],
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().addIssueWorklog(args);
+        },
+    });
+    registerTool({
+        zodSchema: countIssuesSchema,
+        schema: {
+            name: 'count_issues',
+            description: 'Count issues matching query or filter (POST /issues/_count) without fetching the list. Provide exactly one of query or filter.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    query: { type: 'string', description: 'Tracker query language' },
+                    filter: { type: 'object', additionalProperties: true },
+                },
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().countIssues(args);
+        },
+    });
+    registerTool({
+        zodSchema: issueIdSchema,
+        schema: {
+            name: 'get_issue_checklist',
+            description: 'Get checklist items for an issue (GET /issues/{issueId}/checklistItems).',
+            inputSchema: {
+                type: 'object',
+                properties: { issueId: { type: 'string' } },
+                required: ['issueId'],
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().getIssueChecklist(args.issueId);
+        },
+    });
+    registerTool({
+        zodSchema: checklistItemSchema,
+        schema: {
+            name: 'update_checklist_item',
+            description: 'UPDATE a checklist item (PATCH …/checklistItems/{itemId}). Side effect. Set checked and/or text.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    issueId: { type: 'string' },
+                    itemId: { type: 'string' },
+                    checked: { type: 'boolean' },
+                    text: { type: 'string' },
+                },
+                required: ['issueId', 'itemId'],
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().updateChecklistItem(args);
+        },
+    });
+    registerTool({
+        zodSchema: uploadSchema,
+        schema: {
+            name: 'upload_issue_attachment',
+            description: 'UPLOAD a local file to an issue (POST /issues/{issueId}/attachments/). Side effect. Pass absolute filePath on the machine running the MCP server.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    issueId: { type: 'string' },
+                    filePath: { type: 'string', description: 'Absolute local file path' },
+                    filename: { type: 'string' },
+                },
+                required: ['issueId', 'filePath'],
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().uploadIssueAttachment(args);
+        },
+    });
+}
+//# sourceMappingURL=issue-extras.js.map

package/dist/tools/issues.d.ts

@@ -0,0 +1,2 @@
+export declare function registerIssueTools(): void;
+//# sourceMappingURL=issues.d.ts.map